Nushell: A New Type of Shell for Structured Data

A new type of shell. Nushell rethinks the traditional command-line experience by treating data as structured, not merely as text. It is designed to help you discover, transform, and reason about data through pipelines that pass structured values from one command to another. As you explore the project, you’ll notice a focus on consistency, cross-platform usability, and a philosophy that puts data first.

Be sure to check out this quick visual example of Nushell in action:

Status: A Solid MVP with Visible Mountains to Climb

Nushell has reached a minimum viable product level that many users rely on for daily tasks. It provides a practical and usable experience for day-to-day workflows, and a surprising amount of real-world work gets done with it. However, like many ambitious, evolving projects, some commands can be unstable as the ecosystem matures. The team’s design remains intentionally forward-looking, with an eye toward improvements, refinements, and new features as the shell grows.

In addition to being usable now, Nushell is actively developed with a vibrant community. The project embraces changes that come with maturation, and contributors continually push toward richer functionality, better reliability, and broader platform coverage.

If you’re curious about ongoing development, there’s plenty of activity to explore in the project’s GitHub repository, including commit history, discussion threads, and ongoing planning. The project community also maintains regular communication through its Discord channel and a changelog that highlights progress and new capabilities.

Learning About Nushell

Education is a core pillar of Nushell’s mission. The primary reference for newcomers and seasoned users alike is the Nushell book, which provides in-depth explanations, tutorials, and practical examples. The book becomes your go-to resource for understanding how Nushell works, how to write effective commands, and how to reason about data as structured values.

Key learning resources include:

• The Nushell book: A comprehensive guide to commands, data structures, and workflows.
• A complete list of Nu commands in the book, with practical examples you can try in your own environment.
• The cookbook, which showcases practical use cases, tricks, and patterns for real-world tasks.
• The Nushell community on Discord, a place to ask questions, share discoveries, and get feedback from contributors and other users.

If you prefer guided exploration, you’ll find plenty of demonstrations and scenarios that illustrate how Nushell handles lists, tables, records, and streams. The emphasis is on predictability and composability: you combine simple building blocks to craft sophisticated data-processing pipelines.

Installation: Getting Nushell on Your System

Installing Nushell is straightforward and designed to work across a range of platforms. Quick-start options enable you to get up and running with minimal fuss.

• Linux and macOS:
• brew install nushell
• Windows:
• winget install nushell

For those who prefer using Nu inside automation workflows, Nushell can be integrated into GitHub Actions via setup-nu, a marketplace action that prepares Nu for use in your pipelines.

If you want to dive deeper or customize your setup, the book’s installation chapter provides more detailed guidance and platform-specific notes. Nushell is distributed through multiple package managers, ensuring broad coverage across operating systems and distributions, with packaging status shown by the community-maintained indicators.

A note on platform support: the project maintains a platform support policy to help you understand which environments are actively supported and tested. This helps you plan usage in production while keeping expectations aligned with the project’s current capabilities.

Visually, the project also keeps a footprint in the ecosystem through various badges indicating build status, nightly builds, and community feedback channels.

Configuration: How Nushell Starts and Where to Tweak Things

When Nushell starts, it uses a set of default configurations designed to work out of the box. You can customize these defaults to fit your workflow, preferences, and environment, making Nushell adapt to you rather than the other way around.

• Default configurations are stored in sample_config, located within the repository’s default files. This snapshot shows the structure of the configuration and what the shell expects on startup.
• To discover where your own configuration lives on your system, you can query the shell with a simple command: nu.config-path. The result will tell you the precise location of your config.nu file.
• For a deeper dive into configuration options, you should consult the book’s configuration chapter, which covers topics like environment variables, profile settings, and ways to tailor Nushell to your needs.

In practice, most users start with the defaults and gradually adjust specific settings as their workflows mature. Because Nushell treats data with structure, configuration can itself become part of your data-driven workflows: you can model configuration as structured data and apply pipelines to transform or inspect it.

Philosophy: Structured Data, Pipelines, and Functional Workflows

Nushell is built on a distinctive philosophy that blends influences from PowerShell, functional programming, and modern CLI design. The central idea is that input data has structure, and commands in the shell should operate on that structure in a predictable, composable way.

• Structured thinking: When you list a directory, you don’t just get raw text lines. You get a table of rows, with each row representing an item and columns describing its properties. This structured perspective makes it easier to filter, transform, and reason about data.
• Pipelines as first-class citizens: Like Unix pipelines, Nushell lets you chain commands with the pipe character. But Nushell expands this concept by maintaining the structured nature of data throughout the pipeline. The commands you choose can produce streams, filter streams, or consume and summarize data.
• A triad of command types:
• Commands that produce a stream (for example, listing a directory, which generates a sequence of structured items)
• Commands that filter a stream (such as selecting items based on a condition)
• Commands that consume the output (for example, rendering a final table, exporting data, or performing an action on the collected data)
• Consistent data handling: Because data is structured, the same commands can be reused with different inputs and pipelines. This consistency reduces the friction of learning new tasks and encourages reusability.

Pipelines in Nushell are designed to feel natural and expressive. You can assemble a sequence of transformations from left to right, and the output of one command becomes the input to the next. This approach emphasizes a data-centric, functional-style workflow where state is not mutated abruptly; instead, data flows through a chain of transformations that can be tested and observed at each step.

A typical Nushell workflow might look like this:

• Listing a directory and selecting only items of a certain type
• Filtering by metadata such as modification time or size
• Rendering a concise summary with a table that shows the most relevant fields

To illustrate the spirit without reproducing heavy code, imagine a scenario where you list items, filter by type, and then present a clean summary. The same semantics apply across different commands: produce data, refine it, and present it in a readable form, all while preserving structure.

Opening Files: Bringing External Data into Nushell

Opening files or URLs in Nushell is designed to be intuitive and powerful. When you load a file, Nushell can interpret its content as raw text or as structured data if the format is recognized. This makes working with configuration files, manifests, or data in TOML, YAML, JSON, and other formats straightforward.

• Example: open Cargo.toml
• This command reads the Cargo.toml file and presents its contents as structured data. You can then inspect high-level sections such as bin, dependencies, features, and workspace with targeted queries.
• Drilling down into the data: after loading a file, you can drill into specific columns or fields with commands like get. For instance, open Cargo.toml | get package reveals metadata about the package, such as authors, description, homepage, and repository.
• Nested exploration: you can continue drilling down to deeper fields, such as version numbers or license, until you reach exactly the information you need.

This approach lets you work with configuration and data files in a way that is both human-readable and machine-friendly. The ability to load structured data from a file and then apply a pipeline to extract just the pieces you want is one of Nushell’s core strengths.

Plugins: Extending Nushell with Fluent, Structured Extensions

Plugins in Nushell extend the shell’s capabilities with additional functionality while preserving the same structured data model that builtin commands use. Plugins are binaries that exist in your system path and adhere to a naming convention that makes them discoverable by Nushell as nuplugin* tools.

• Plugins communicate with Nushell through a lightweight JSON-RPC protocol. The command identifies itself and passes configuration, enabling seamless integration into pipelines.
• Data streaming behavior depends on the plugin type:
• If the plugin is a filter, it can process data elements incrementally, streaming results back via stdout as data arrives.
• If the plugin is a sink, it receives the full data vector and is free to leverage stdout/stderr in whatever way suits its purpose.
• The ecosystem around Nushell includes repositories like awesome-nu (which curates a variety of plugins) and showcase (which highlights blog posts and videos related to Nushell topics).

Plugins embody the idea that Nushell can grow through community contributions while preserving the same core model of structured data and composable pipelines.

Goals: Design Tenets and Practical Commitments

Nushell adheres to a clear set of design goals that guide its evolution. These goals emphasize portability, interoperability, usability, and a functional approach to data.

• Cross-platform first: Commands and techniques should work across Windows, macOS, and Linux, with explicit first-class support for each platform.
• Interoperability: Nushell aims to remain compatible with existing platform-specific executables and ecosystems, easing adoption in diverse environments.
• Modern usability: The shell should feel familiar and efficient for users of contemporary software in 2022 and beyond, balancing familiarity with novel capabilities.
• Structured data mindset: Data is treated as either structured or unstructured, with a strong emphasis on structured handling for everything from file listings to process information.
• Functional workflow: Rather than mutating state in place, pipelines act as a mechanism to load, transform, and save data in a functional, composable manner.

These goals reflect a philosophy of thoughtful, data-driven tooling that supports both beginners and power users who crave precise, repeatable workflows.

Officially Supported By

Nushell enjoys support and collaboration from a growing ecosystem of projects that complement and extend its capabilities. Examples include:

• zoxide
• starship
• oh-my-posh
• Couchbase Shell
• virtualenv
• atuin
• clap (and related clapcompletenushell)
• Dorothy
• Direnv
• x-cmd
• vfox
• Windmill

If you’re using Nushell in a broader tooling stack, these projects offer complementary functionality, from efficient navigation to enhanced prompts and shell ergonomics. The community welcomes additional contributions and endorsements as Nushell continues to mature.

Contributing: Join the Development Effort

Contributing to Nushell is a welcoming process designed to invite a broad range of skills, from Rust programming to documentation, tooling, and community assistance. The project maintains a CONTRIBUTING.md document that outlines how to get involved, how to report issues, and how to propose improvements.

To get a sense of the community’s scale, you can look at the contributor banner. It showcases the breadth of people who have contributed to the project, highlighting the collaborative nature of open-source development.

A thriving, visible community is visible in the contributor image (a dynamic banner of contributors) and in ongoing discussions across the project’s channels. Whether you’re a seasoned Rust developer or simply interested in shell UX, your input matters and can help shape Nushell’s trajectory.

License

Nushell is distributed under the MIT license. This permissive license aligns with the project’s open development model, encouraging experimentation, reuse, and collaboration. If you’re curious about licensing specifics, you can review the LICENSE file in the repository.

---

As you explore Nushell, you’ll encounter a thoughtful blend of data-centric design, practical tooling, and community-driven growth. It’s a shell built around the idea that data has structure and that you should be able to reason about it in transparent, composable steps. The project’s emphasis on cross-platform usability, a comprehensive learning footprint, and a vibrant plugin ecosystem makes Nushell a compelling option for developers, data scientists, system administrators, and curious explorers who want to reshape the way they interact with the command line.

If you’re ready to experiment, start with the basics in the Nushell book, try the quick installation commands, and then dive into Pipelines and Opening Files to see how a simple dataset becomes a powerful, navigable workflow. The journey from listing directory contents to extracting precise information and presenting it in a clean table is not just about getting results—it’s about embracing a workflow that treats data as first-class citizens and pipelines as a natural way to reason about it.