I have written more throwaway awk one-liners than I care to admit. Parse a column out of ls -l, grab a field from a JSON response with a fragile grep, count something in a CSV by piping through cut and sort and uniq -c and squinting. It works, it has always worked, and every single time I do it I am converting structured data into text and then desperately trying to convert it back into structure with string surgery. Bash pipelines move bytes. My data was never bytes. It was tables and records and lists, and I was flattening it at every pipe just to reconstruct it downstream.
Nushell is the shell built on the premise that this is insane. After four months of running it as my daily driver alongside my usual fish setup, I am convinced it is right about the big idea, even where it is still rough on the details. This is the honest review from real use, not a weekend tour.
What Nushell Actually Is
Nushell, usually written nu, is a shell written in Rust whose defining feature is that data flowing through a pipeline is structured, not a stream of bytes. When you run ls in Nushell, you do not get text that looks like a table. You get an actual table: rows and typed columns, name and size and modified date, that you can filter, sort, and query with commands instead of parsing with regex.
That one decision cascades into everything. Because ls returns a table, ls | where size > 10mb | sort-by modified is not string manipulation, it is a query. Because an HTTP response can be parsed into a record, you reach into nested JSON with get user.address.city instead of piping through jq and hoping. The whole shell is organized around the idea that your data has shape, and the shell should respect that shape all the way through the pipe.
If you have ever used a dataframe library or written SQL, Nushell will feel weirdly familiar, because it borrows the good ideas from both and puts them at your command prompt.
The Structured Pipeline Is the Whole Argument
Let me make this concrete, because the pitch sounds abstract until you see it. Suppose you want the five largest files in a directory tree. In bash you are reaching for find, du, sort -rh, head, and probably a -print0 and xargs dance to survive filenames with spaces. In Nushell it is:
ls **/*.* | sort-by size --reverse | first 5 | select name sizeEvery stage there operates on a table. sort-by size sorts on the real numeric size column, not a text approximation of it, so a 9-megabyte file never sorts above a 100-kilobyte one because “9” is a bigger character than “1.” select name size picks columns like a SQL statement. Filenames with spaces, newlines, and unicode just work, because nothing was ever a fragile space-delimited string.
Now do it with an API. Fetch some JSON, and instead of curl ... | jq '.items[] | select(.active)', you write http get $url | get items | where active. The response became a table the moment it arrived, and where active is filtering rows, not grepping text. This is the moment Nushell clicks for most people. Your data stopped being a blob the instant it entered the shell, and it stays queryable the entire way down the pipe.
Built-In Parsers Turn Every File Into a Table
Nushell ships with parsers for the formats you actually deal with: JSON, YAML, TOML, CSV, TSV, INI, XML, and more. open config.toml does not dump text at you, it returns a record you can navigate. open data.csv | where region == "west" | math sum amount reads a CSV, filters rows, and sums a column, with no external tool and no format-specific syntax to remember. The open command sniffs the extension and does the right thing.
This is the feature that quietly changed how I work. I stopped context-switching between jq for JSON, yq for YAML, and hand-rolled awk for CSV. It is all one query language now, over one table abstraction, regardless of what the file on disk happens to be. When your config files, your data files, and your API responses all become the same kind of queryable table, a whole category of “how do I parse this particular format again” friction just evaporates.
The Dataframe Plugin Is a Genuinely Serious Tool
For heavier lifting, Nushell has a polars plugin that brings the Polars dataframe engine into the shell. This is not a toy. Polars is a fast, columnar, Rust-based dataframe library in the same conversation as pandas, and having it a pipe away means real data analysis in the terminal without opening a Python REPL or a notebook.
I have used it to chew through multi-hundred-megabyte CSVs, doing group-bys and aggregations that would have been a genuine wait in a naive script, and Polars handled them at a speed that made me double-check it had actually done the work. For anyone who lives near data but does not want the ceremony of spinning up a full Python environment for a quick question, this alone is a reason to keep Nushell installed even if it is not your login shell. It is the fastest path from “I have a big CSV and a question” to “I have the answer” that I know of at a command prompt.
Errors That Actually Point at the Problem
A small thing that I did not expect to love: Nushell’s error messages are Rust-compiler-style. When something goes wrong, it does not just say “command failed.” It shows you the span of your input that caused the problem, with an arrow pointing at it and an explanation of what type it expected versus what it got. Because the shell has a real type system, a mistake like treating a number as a string or reaching for a column that does not exist gets caught with a clear, located message instead of an empty result and a confused evening.
After years of bash silently producing wrong output because a variable was empty and a pipeline happily processed nothing, a shell that tells me precisely where and why I was wrong feels like a genuine upgrade in dignity.
The POSIX Tax Is Real and You Must Understand It
Here is where I stop selling and get honest, because Nushell asks something significant of you. It is not POSIX-compatible, and it does not pretend to be. Your bash and zsh muscle memory does not transfer cleanly. The install script from a project’s README that starts with curl ... | bash assumes a POSIX shell, and while you can absolutely call out to bash -c for those, you will do it often enough to notice. Stack Overflow answers, dotfiles from strangers, that clever one-liner a coworker sends you: none of it pastes in and just runs the way it would in bash or zsh.
This is the same trade fish makes, but Nushell makes it harder, because Nushell is not merely a nicer interactive shell with quirky scripting. It is a different paradigm. The payoff is the structured pipeline, and it is a big payoff, but you are relearning how to think at the prompt, not just memorizing new command names. Go in expecting that and it is exciting. Go in expecting bash-with-tables and you will be frustrated by lunchtime.
The Pre-1.0 Reality
Nushell is still before its 1.0 release, and it behaves like it. The team ships frequently, the language is still refining itself, and occasionally a release changes syntax in a way that breaks scripts you wrote against an older version. This is not carelessness, it is the honest cost of a project that is still deciding what it wants to be, and the changelogs are clear about it. But if you write a pile of Nushell scripts and depend on them, budget some maintenance time across upgrades. For interactive daily use this barely registers. For durable automation you lean on, it is a real consideration, and I keep my genuinely load-bearing scripts in POSIX sh for exactly this reason until 1.0 settles things down.
Who Should Actually Switch
I will be direct about the fit, because Nushell is not for everyone and pretending otherwise would waste your time.
If you spend your days wrangling data at the terminal, parsing JSON from APIs, slicing CSVs, querying logs, poking at config files, Nushell is a legitimate productivity upgrade and you should try it this week. The structured pipeline will change how you work.
If you are a shell minimalist who wants a fast, POSIX-compatible login shell and rarely does data gymnastics, Nushell is a fascinating thing to keep in your back pocket but probably not your daily driver. Install it, use it for the data tasks, and let bash or fish keep the login-shell job.
The pattern I have settled into, and the one I would recommend to most people, is that Nushell does not have to be your login shell to be worth it. I keep fish as my interactive default and reach for nu the moment I have structured data to interrogate. Having it a command away, ready to turn a nasty CSV into a clean query, is worth the install even if you never set it as your default shell.
The Bottom Line
Nushell is the most genuinely new idea I have seen in a shell in a long time, and the core insight is correct: your data has structure, and the shell should stop destroying it at every pipe. When ls returns a real table, when a JSON response is queryable the instant it lands, when a giant CSV is a polars pipe away from an answer, you feel how much cognitive overhead bash’s everything-is-text model was quietly charging you all along.
It is not free. You pay a real POSIX-compatibility tax, you relearn how to think at the prompt, and you accept some pre-1.0 churn on scripts you want to keep. Those are honest costs and I will not wave them away. But for data-heavy terminal work, Nushell is better than bash in a way that is hard to unsee once you have felt it, and you do not even have to commit to it as your login shell to reap most of the benefit. Install it, point it at the nastiest CSV or JSON blob on your disk, and watch it become a clean queryable table. If that makes you grin the way it made me grin, you are exactly who this shell was built for.