Nushell: Introduction to a new kind of shell

https://dataswamp.org/~solene/2022-10-31-nushell.html

by hucste • 4 years ago

319 247 4 years ago

Ygg23• 4 years ago

Nushell is PowerShell done right.

vips7L7• 4 years ago

It felt less powerful than PowerShell to me, and didn’t feel like it brought anything different to the table that would warrant me to switch. It also has far less tooling and plugin support.

nostoc• 4 years ago

Powershell is powerful because of the deep integration with the .NET ecosystem, and by extension, the OS.

This new shell lacks that, I agree. But I think it's a way harder problem to solve on linux.

subjectsigma• 4 years ago

IDK, my first reaction was that it was PowerShell except worse.

majkinetor8• 4 years ago

Yeah, lets live in holywood movies where decades old project is replaced overnight with right solution :)

alkonaut3• 4 years ago

What are the features that are done differently, or in other words, why would I choose Nushell over PowerShell?

majkinetor8• 4 years ago

You don't.

The good thing is you have alternative in case you need it. Performance might be different in specific case.

Ygg23• 4 years ago

Error messages are great, autocomplete works out of the box, and commands ArentCamelCaseMonstrocitiesOnlyMicrosoft --CouldLove.

ripley1213• 4 years ago

I'm one of the Nushell developers, and one of the main reasons I joined the project was that I couldn't find a cross-platform shell I was happy with.

PowerShell has a _lot_ of baggage. I don't like a lot of their design decisions (ex: the super verbose naming, the continue-on-error default that makes scripting a pain), and it's unlikely that those decisions will ever be revisited.

I tried pretty seriously to use PowerShell as my daily driver on Linux and macOS 2 years ago and was disappointed. Too many rough edges and Windows-first features.

PowerShell's startup performance is also pretty rough; I was seeing startup times around 2s after some minor profile customization.

I think Nushell addresses all of those points well; it's got nice concise syntax, solid support for Mac/Windows/Linux, and instant startup times. On the other hand, Nushell's less polished+stable than PowerShell; we're still making breaking changes to the syntax+commands.

xamde• 4 years ago

Should have been called nutshell

kevsim• 4 years ago

That's what I read it as and was a bit disappointed when it turned out not to be the case.

o_1• 4 years ago

same

RedlineTriad• 4 years ago

Nushell has the huge advantage of being searchable, which I think is really important for new projects where you need to look up docs often.

It is cumbersome to always add a postfix: rust (lang), go (lang), etc...

agumonkey• 4 years ago

Looks pretty pragmatic and readable

_dhruva• 4 years ago

I thought the original Nushell was written by Jonathan Turner.

Is this different? Some attribution in the article would help.

(Thanks for pointing, there are links to original in the article)

https://www.nushell.sh/

afranchuk• 4 years ago

It doesn't seem so. While not immediately clear, this article doesn't seem to be claiming ownership of the project. It is a third-party review/introduction. They link to the project after the first section.

jamincan2• 4 years ago

I get the impression that she packaged it for OpenBSD and wrote this as an intro to the shell for others. The 'written by Solene' bit reads initially as though she's claiming to have written Nushell, but when reading the text, it's pretty clear she didn't:

With nushell, it feels like I finally have a better tool to create more reliable, robust, portable and faster command pipelines. The learning curve didn't feel too hard, but maybe it's because I'm already used to functional programming.

wodenokoto• 4 years ago

I packaged it for OpenBSD, so it's available on -current (and will be in releases after 7.3 is out), the port could be used on 7.2 with no effort.

I think this is what makes it sound like the author of the article is the author of nushell. My first reading led me to believe the same, but she is "only" responsible for the OpenBSD package.

solene2• 4 years ago

oh, I'm indeed not the author of nushell, I'll try to make it more clear!

asicsp• 4 years ago

Previous discussions about Nushell (https://hn.algolia.com/?q=Nushell), for example:

https://news.ycombinator.com/item?id=27525031 (763 points | 1 year ago | 398 comments)

https://news.ycombinator.com/item?id=20783006 (1477 points | 3 years ago | 366 comments)

dang• 4 years ago

Thanks! Macroexpanded:

Nushell 0.60 Released - https://news.ycombinator.com/item?id=30772042 - March 2022 (40 comments)

Nushell: A New Kind of Shell - https://news.ycombinator.com/item?id=30718349 - March 2022 (8 comments)

Nushell – a new type of shell written in Rust - https://news.ycombinator.com/item?id=28968966 - Oct 2021 (3 comments)

Nushell 0.38 - https://news.ycombinator.com/item?id=28841901 - Oct 2021 (1 comment)

GitHub – nushell/nushell: A new type of shell - https://news.ycombinator.com/item?id=27525031 - June 2021 (398 comments)

Nushell: A New Type of Shell - https://news.ycombinator.com/item?id=26712741 - April 2021 (2 comments)

Cbsh – a couchbase shell in rust on top of nushell - https://news.ycombinator.com/item?id=24767244 - Oct 2020 (4 comments)

One Year of Nushell - https://news.ycombinator.com/item?id=24259914 - Aug 2020 (47 comments)

Nushell – A New Type of Shell - https://news.ycombinator.com/item?id=22880320 - April 2020 (37 comments)

Nushell – a modern shell written in Rust - https://news.ycombinator.com/item?id=20845584 - Aug 2019 (4 comments)

Introducing nushell - https://news.ycombinator.com/item?id=20783006 - Aug 2019 (366 comments)

teilo• 4 years ago

How did I not know about this? I will never parse text in Bash again.

ratboy6662• 4 years ago

But... Bash (sh) is not meant to parse text!

Bash (sh) is glue. awk can parse text. As can SNOBOL4 if you REALLY want to go crazy. Or sed. Math is done by expr, dc and bc.

siph• 4 years ago

'In a way, Nu is a way of saying “what if we didn’t need tools like awk so often?” Since you’re working with structured data, as we add more support for file types, it’s less often you need to reach for “awk”, “jq”, “grep”, and the array of other tools to open and work with common file types.'

From this interview: https://www.notamonadtutorial.com/nushell-the-shell-where-tr...

cyber_kinetist5• 4 years ago

I use it as my primary driver, for the sole reason is that it's the only cross-platform shell that properly supports Windows (without resorting to Cygwin/MSYS, which has performance issues and many pain points). I'm still getting used to the syntax though...

(Edit: forgot to mention Powershell, since nowadays it also works on Macs and Linux)

actually_a_dog• 4 years ago

I'm curious what you mean by "properly supports Windows." Are you on a version of Windows that supports WSL2 (Windows Subsystem for Linux)?

pletnes5• 4 years ago

WSL is great but it’s basically a convenient VM. It’s no longer windows, as far as I’m concerned.

cyber_kinetist5• 4 years ago

I really don't want to start up a separate Linux VM just to open up a shell. (I already crossed out Cygwin / MSYS on the list because of performance issues...)

pletnes5• 4 years ago

Doesn’t xonsh run correctly on windows? I used it but hated the environment due to the lack of utilities on windows (it’s just a shell, not an environment).

deafpolygon5• 4 years ago

Why use this over PowerShell for example?

cyber_kinetist5• 4 years ago

Well, it is a good point, since nowadays PowerShell is also cross-platform, and seems to have more features than nushell does.

Though the true reason is: I haven't really found the time to. Changing a shell is really stressful since you have to unlearn / relearn lots of things from muscle memory, and PowerShell's huge deviance from the rest of the POSIX-y world doesn't help. At least in nushell `rm -rf` works, the same doesn't in PowerShell.

stevefan1999• 4 years ago

No need for (a minimal set of) dotnet runtime. This means Nushell can possibly run on slightly resource constrained environment such as Raspberry Pi, of course you don't expect it to run well with 256MB of RAM though. Also, Nushell is battery packed. For example, say bye bye to your Oh-my-ZSH because the features you have with OMZ (like shell autocompletion, suggestion, theming and formatting) is built-in in Nushell. I have also tried to parse `zfs list` output in my Proxmox machine that I don't want to use `zfs list | less` that often.

That said, I hope Powershell Core can be packed with dotnet 7 native AOT mode [1] so we don't have to screw around with 100 different MSIL DLL files to run a single shell...

[1] https://learn.microsoft.com/en-us/dotnet/core/deploying/nati...

forgotpwd165• 4 years ago

It's more Unix-y. Smaller footprint, opens faster, short commands by default. Otherwise the PowerShell influence is vastly understated in project page and docs.

sixothree4• 4 years ago

I am a C# programmer at heart, and I use powershell a good bit. I can honestly say I can never use powershell without my cheat sheets or my list of favorite commands (and especially the arguments to use).

I looked at this and kinda get it and think I could do some things with it. I don't think it's as powerful and can _definitely_ say it won't be capable of the same automations we use.

That said, the text parsing people do with bash makes me cringe. It's so repulsive and sketchy. Anything to get linux world off of bash would be a good thing.

cassepipe• 4 years ago

It's dumb but I personally can't get over Camel-Kebab-Case commands. I hate typing Caps, and hyphens.

ripley1213• 4 years ago

Some reasons I prefer Nushell over PowerShell:

- less verbose syntax

- better cross-platform support (PowerShell is technically cross-platform, but it has some baggage from its Windows-first history)

- way faster to start up

I'm a little biased (I'm a member of the Nushell core team), but those are all things that drew me to start contributing to Nushell.

On the other hand, Nushell is certainly less mature+stable than PowerShell.

BeetleB2• 4 years ago

xonsh (Python based shell) works fine on Windows. Been using it for over 4 years.

dloss• 4 years ago

Its dataframe support (based on Apache Arrow and the Polars Rust library) looks very interesting. https://www.nushell.sh/book/dataframes.html

zozbot234• 4 years ago

Yes, it really should be called Polarshell.

WastingMyTime892• 4 years ago

Should probably be switched to the official project page rather than a subpage on an unrelated party website: https://www.nushell.sh/

It’s a lot better at introducing Nushell and feels like a proper landing page.

wkdneidbwf2• 4 years ago

haha, thanks for this. i was looking at the examples on the other page and was like, "jfc, no thanks"

eatonphil3• 4 years ago

It's someone's personal blog post. No need to be mean. The styles are a little brutalist but also readable to me.

eatonphil3• 4 years ago

So HN is not supposed to allow blog posts about projects but must always swap out for the project site itself? As someone who writes blog posts about projects, I hope not! It's not like this blog post is affiliate spam.

marcosdumay• 4 years ago

If the project site is better written and has the same content, yeah, I would prefer to see it.

But this is not the case here.

JW_00000• 4 years ago

It's a blog post but somehow the styling doesn't make it look like one.

forgotpwd165• 4 years ago

Better not. In this case the blog post provides more complex and interesting examples than the simplistic ones on the official page.

solene2• 4 years ago

Isn't https://www.nushell.sh/ the official website?

rodorgas• 4 years ago

It doesn’t need to be switched, you can submit the project page anytime.

libria• 4 years ago

These are 2 different types of posts.

1. A new product

2. An independent party's pro/con opinions about that product

This thread is about #2. If you feel #1 has value on its own, post that.

Read both your link and the OP's. While the topic is the same, the content is markedly different.

DeathArrow• 4 years ago

This is just an example from YAML to JSON, but you can convert much more formats into other formats.
open dev/home-impermanence/tests/impermanence.yml | to json

I can do it with PowerShell:

$os_list = (Get-Content -Path "C:\temp\operating-systems.yml" | ConvertFrom-Yaml)

Set-Content -Path "C:\temp\PowerShell_operating-systems.json" -Value ($os_list | ConvertTo-Json)

ac130kz2• 4 years ago

Powershell is also quite anti-semantic, non-portable and verbose

delta_p_delta_x4• 4 years ago

anti-semantic

Why?

non-portable

PowerShell 6 and later run on Windows, macOS, and Linux.

verbose

This is by design.

Semaphor5• 4 years ago

That is a great example, but for different reasons. I think PowerShell is amazing, but it never feels like something I want to work in as a shell. Writing scripts in an IDE, sure. But to convert some yaml to json I’d much rather type open/file.yml | to json

0x4454425• 4 years ago

This is where I’m at with PS as well. It’s stuck in this no man’s land between bash and python. It’s a better scripting language than bash and a better shell than python. But when compared to their main purposes it’s a worse shell than bash and a worse scripting language than python.

The caveat of course is Windows system administration. I’m sure it’s excellent in that domain.

vips7L7• 4 years ago

OP here wrote this the most verbose way I could think possible. Most commands are pre-aliased in PowerShell and arguments are fuzzy matched as long as they're not ambiguous.

For example:

   Remove-Item $directory -Recurse -Force
   rm $directory -r -fo

For this specific example ConvertFrom-Yaml actually doesn't exist as a standard cmdlet and ConvertTo-Json isn't aliased by default:

    gc ./something.yml | ConvertFrom-Yaml | ConvertTo-Json > /some/file.json

js2• 4 years ago

With any shell:

    $ brew install yq
    $ yq -o json . < config.yml

ratboy6662• 4 years ago

This... yq eats yaml. And this is all I need to know (really). I don't know yaml. I don't WANT to know yaml.

Two letter command which I can remember, in the same way that I know jq. And, as a short-form jo. I would not use jo to eat json. I do think that yq is "misnamed" slightly, in that there is no yo command.

(note that I do have yq installed, but not nushell or PowerShell).

shell is glue, not oop -- json is an object notation, converted to stringyness. Which makes for oop->shell. Since "objects" are programmer-think, this should not be the primary command interface. People (not programmers) recognize this, and thus PowerShell is not used by "non-programmers". Ok, you want something above bash (sh, shell), for more programming structure? This is why the #! construct is exec() is so important. That lets you use... um awk, sh, (and should support PowerShell -- not sure). Even C (with tiny-c). I would go with javascript, myself, because it fits with json, and thus jq and jo in the eco-system.

Now, for a criticism of yq -- jq is 30K for a front-end and 350K (or so) for a library. jo is 120K, yq is (gulp) 12MB. Ok, I have the disk space. And it is GO, so ok. Compared with the other GO programs I use commonly: minio (100MB), mcli (mc, 20MB), doctl (20MB), it isn't bad at all. But, I guess that is what GO demands...

Can I teach "functional shell"? Frankly, no. I can get through simple shell in a semester.

vips7L7• 4 years ago

Probably better to write this with the standard alias's so people don't complain about verbosity:

  gc ./something.yml | ConvertFrom-Yaml | ConvertTo-Json > /some/file.json

Also I don't think ConvertFrom-Yaml actually exists as a standard cmdlet.

ravi-delia• 4 years ago

I mean, yeah? As much as I hate to admit it (and believe me, I hate to admit it), PowerShell is better than bash at composing tools made by all sorts of people on the fly in easy to write pipelines. I have my issues with it as a language, but it's not like I'm thrilled to write bash. Nushell is an attempt at making a scripting language which builds on bash, rather than supplanting it. PowerShell is much less nice on Linux, especially when you'd have to translate every existing resource.

sedatk• 4 years ago

Yeah, PowerShell eliminated the output parsing overhead which was the significant portion of any composed shell operation. That's where all shells need to be heading I believe.

photochemsyn• 4 years ago

It'd be useful if there was some site detailing and benchmarking the size, overhead, performance etc. of the various popular shells on different systems. This looks interesting but the binaries seem rather large relative to bash. For example, what do the developers view as the minimal system parameters needed to avoid annoying latency?

stoplying12• 4 years ago

I just ported a bunch of scripts to nushell.

I hit some bugs, a couple of which are a bit sharp, but wow, the list of quirks I have to remember for nutshell are so much fewer than for bash.

Constantly impressed at the errors it catches at parse time, kinda crazy sometimes.

Oh my god I could cry, strings are sane to work with. I may never write a bash script again (it's okay, I use Nix so I get nushell everywhere I'm might need it, for free)

Everyone is asking about PowerShell. I never hated it, but lord it makes some awful, stupid infuriating decisions. I've lost hair and sanity to some stupid list/single-item-list beahvior. Numerous operators and bits of syntax are just different. Everything about the script syntax is just slight odd and confusing. There's basically none of this with nushell. Jonathan Turner is a gifted person with an eye for language design and it really shows.

Edit: I do think it's missing some important output redirection functionality. You can workaround by using "complete" but that feels non-ideal.

mustache_kimono• 4 years ago

I may never write a bash script again

I wrote 2x 200 line-ish shell scripts recently, and it was simply terrible, and although I'm increasingly convinced we need a shell like abstraction, I can't believe `bash` is the best we can do. Really hope I find one of these alt shells that suits me. Not a fan of Python but xonsh looks really cool too.

pletnes5• 4 years ago

Xonsh is very posix/bash-like but you can call python functions in an integrated way. Even if you don’t love python it’s a more sane language than bash. I really like it but I’ve been using zsh for too long.

nerdponx6• 4 years ago

Bash is not the best we can do!

If you want a traditional Unix-like shell that is mostly sensible in the places where Bash is not, check out Zsh. It has a ton of complicated features, but most Bash scripts can be ported easily (if not outright copied and pasted). Zsh has fewer footguns by default than Bash, and it has more "safety" settings that you can enable.

There is also the Oil shell, whose creator often posts on HN, and which I think is meant to be a superset of Bash, but I have not used it myself and can't vouch for it.

As for the alt shells, I've was specifically interested in Elvish, but I dropped it as soon as I saw that they don't support parameter interpolation in string literals, like `"${HOME}/.local"`. This is such a common operation in shell scripts that I have no interest in a shell that doesn't support it, and I can't imagine why Elvish doesn't.

naikrovek2• 4 years ago

Bash is not the best we can do, but it is definitely the best that most people agree on.

I fear there will be no defacto bash replacement for many years.

Pet_Ant• 4 years ago

Honestly I’ve enjoyed working with PowerShell for scripts to work for all developers on my team regardless of what OS they are using.

beanjuiceII• 4 years ago

yep been using powershell here too..great stuff

csdvrx2• 4 years ago

It feels very different from unix shell. I like them both!

I think Powershell more advanced ecosystem with a default output more like the sqlite tables of nushell would be wonderful: the objects handled by PS would be more naturally suitable to this, and would compose more easily.

nerdponx6• 4 years ago

I wanted to like Powershell, but it is missing some features that I think are essential. For example, apparently checking the return status of an arbitrary command is not trivial, and there's no equivalent of `-eu -o pipefail`. Yes, I know `-eu -o pipefail` is imperfect too, but it covers most common cases. I also struggled badly to stop it from mangling the output encoding of my applications (no, I don't want a goddamn BOM, thank you), and the solutions I found all either had no effect or required me to write what looked like C# code embedded in my shell script.

fragmede• 4 years ago

strings are sane to work with

Okay, I'll bite - how does it handle filenames with spaces and newlines in them? I have a strong case of Stockholm syndrome with bash because I figured out how to deal with the first one, but I'd love a system that deals with that sanely.

gatane2• 4 years ago

bash + lua, and life is good again.

SighMagi3• 4 years ago

How do you use bash and lua together?

w4rh4wk5• 4 years ago

I learned PowerShell some time ago. I really like the concept and the power that comes with it. But, coming from Bash, I can't get a grip of the syntax.

I am in the process of switching most of my shell scripts over to Python; I wonder whether nushell would be the better option.

rileymat2• 4 years ago

You are absolutely not alone with this. There appears to be so much power so much potential, but it /feels/ so awkward syntactically.

ripley1213• 4 years ago

I do think it's missing some important output redirection functionality. You can workaround by using "complete" but that feels non-ideal.

Yeah, this is a very fair criticism. We're working on it :)

Test01292• 4 years ago

In a nutshell, nushell is non-POSIX shell, so most of your regular shells knowledge (zsh, bash, ksh, etc…) can't be applied on it, and using it feels like doing functional programming.

Is there a reason some shells like fish (and now nushell) are non-POSIX? What is the benefit? I really like fish but I've kept away from it because it's non-POSIX and won't necessarily play well with years of POSIX scripts and knowledge I have.

eatonphil3• 4 years ago

Is there a reason every PL designer in the world didn't just make a new implementation of Pascal rather than design Python or Java or Rust? :)

d4mi3n• 4 years ago

Correct me if I’m wrong, but doesn’t POSIX dictate a text stream as STDIN/STDOUT?

If my understanding is correct, this basically rules out any attempts to create richer CLI pipelines that necessitate other kinds of data interchange. IIRC this was one of the motivating factors in the design of PowerShell—though I don’t know PS well enough to say if it’s POSIX complaint or not.

dec0dedab0de3• 4 years ago

Is there a reason some shells like fish (and now nushell) are non-POSIX?

Some things are different than other things. It's the same reason that not all desserts are pie, and not all automobiles are trucks.

Test01292• 4 years ago

I guess I was more curious about the cost/benefit. Given a well defined standard like POSIX, and the difficulty of swapping in a new shell into Windows, I wasn't seeing why you'd buck the well established trend.

xigoi• 4 years ago

Because POSIX shell syntax is an unreadable and dangerous mess.

sigzero• 4 years ago

The output being in tables is nice and being able to act on it as a table is also pretty nice. At first glance, it seems it's well documented as well. I don't know that I would switch but I'll definitely read up on it.

mrtweetyhack• 4 years ago

Do we need a new shell or a few utilities that help produce structured output? For example, `ls | gen_structure | limit 50 | head 5`

forgotpwd165• 4 years ago

That's an interesting project to attempt. An issue that should be considered is that pipes can only pass plain text. So every command should import/export structured text which may impact performance and limit capabilities when compared to a shell that can pipe objects.

csdvrx2• 4 years ago

The structure can be done with ASCII: csv and tsv manage to pass data in plain text (the later while remaining readable)

Relational data would have the extra advantage over json-like property-based data of being both easier to present on screen (tables) and to interact with (SQL like: where + order + limit would cover most usecases)

geophile• 4 years ago

Eww. This is basically screen-scraping command output to enable structure-oriented commands. That means you need a scraper for every output, the scrapers need to be aware of all the options, handle filenames with whitespace correctly (not sure that's even possible in general).

And once you've done that, you have this new batch of commands that are structure-oriented, so you are using bash (for example) as a boot loader for your new shell. Why not just use the new shell?

I have a project in this space: https://marceltheshell.org. It is based on Python, so Python values (strings, numbers, tuples, lists, etc.) are piped between commands. No sublanguages (as in awk); instead you write Python functions.

Marcel has an ls command, but instead of producing a list of strings, it generates a stream of File objects which can be piped downstream to other commands that operate on Files.

Example: sum of file sizes under directory foobar:

    ls -f foobar | (f: f.size) | red +

-f means files only. In parens is a Python function (you can omit "lambda") that maps a file to its size. red + means reduce using addition, i.e., add up all the file sizes.

Or to compute size by file extension:

    ls -f foobar | (f: (f.suffix, f.size)) | red . +

f.suffix is the extension. "red . +" means to group by the first field of the tuple (the extension) and add up the sizes within each group.

zokier3• 4 years ago

Here you go: https://github.com/kellyjonbrazil/jc

commitpizza• 4 years ago

Seems like a missed naming opportunity, it should've been "Nutshell" :D

norman7843• 4 years ago

One issue I have with nushell is that on macOS they use the `Library/Application Support` path for the config instead of the `.config` making it awkward, their reason is that the former is the correct path of application data, while none of the other CLI apps I use do this, every other app just points to the `$HOME` dir or `.config` dir.

I used it for a while but I switched back to zsh, maybe in the future when it has a stable release I try it again, was too much hassle to update the config on almost each release. Also didn't worked well with some utils I use that has specific initialisation for each shell (i.e. rbenv).

Otherwise nushell seems to be a good contender for an alternative shell.

130e13a• 4 years ago

surely something as basic as the location of the config folder can somehow be changed to a custom path, right?

radlad• 4 years ago

Configuring where configuration data lives can be tricky. (Chicken/egg problem.)

But you can certainly create your own symlink.

pie_flavor6• 4 years ago

it is the correct path for application data. Configs go in ~/.config on Linux, ~/Library/Application Support on Mac, and ~\AppData\Roaming on Windows; some other tools doing the wrong thing isn't a reason for nushell to do the wrong thing, and your preference for nushell doing the wrong thing shouldn't mean I have to suffer it. If you want it to be visible in your home dir, you can easily put a symlink there.

norman7843• 4 years ago

When you work on multiple OSes (mainly macOS and Linux), having your dot files normalized is IMHO the best experience, yes, I have symlinked, but if I need to setup a new mac (that does not happen often) then I could forgot about it and will take an extra step to setup, as I said that's just my preference.

Also I want to say that the ~/Library/Application Support directory only works good for desktop app, so it's easy to get rid of the configurations of an app that you want to uninstall (I use AppCleaner), but terminal apps you install most likely by a curl|bash or brew, so there's no point on using that directory IMHO, to me feels that the maintainers are not mac users so they don't care on improving that, for me, is a pain point.

But that does not take the merit of nushell, from all the other new ones (fish, oil, etc) I think is the one that I enjoyed the most.

blahgeek• 4 years ago

I still believes that [xonsh](https://xon.sh/) is the best of its kind because I do not want to remember yet another language syntax

gatane2• 4 years ago

Is there something like this but with Lua?

forgotpwd165• 4 years ago

There was an attempt: http://lua-users.org/wiki/LuaShell

drey08• 4 years ago

It looks promising, but why does it flicker every time I input a key? Using WSL & Terminal.

orf• 4 years ago

Open an issue?

ripley1213• 4 years ago

We (Nushell core team) think it's a Windows Terminal bug, please upvote the issue: https://github.com/microsoft/terminal/issues/13710

yewenjie• 4 years ago

Has anybody switched to any newer shell from Fish?

anentropic• 4 years ago

Speaking of non-POSIX shells, I stumbled upon this last week:

https://github.com/letoram/cat9

https://arcan-fe.com/2022/10/15/whipping-up-a-new-shell-lash...

gg-klotho• 4 years ago

I tried nushell for a few days, but sh syntax is just too ingrained... It slowed me down a bunch and couldn't get over the initial learning curve. Ended up going back to zsh. Also, losing a bunch of completions for tools I used was a bummer. I wish nushell could parse bash/zsh completion scripts or something to help ease the transition.

Maybe I'll revisit it at some point in the future.

kibwen• 4 years ago

It took me about a decade after fish came out for me to finally switch from bash. Nu looks like an improvement over fish, but I expect it will also take me about a decade to bite the bullet and use it. :P

acedTrex• 4 years ago

I would kill for a different shell language but im so deep into ohmyzsh its hard to switch

otikik• 4 years ago

Calling things “new something” is usually a bad idea. It might be new now, but it won’t stay new for long. And then it becomes a lie.

“Newcastle”, “Newport”, “The New iPad”(which was later renamed to a much more logical 3.0)

ElijahLynn• 4 years ago

A comparison to fish (shell) would be useful too.

bsdetector3• 4 years ago

Having written a lot of shell scripts, the single greatest thing I've ever experienced is shell-friendly outputs.

For example, consider if ls had a "--shell" option that output each entry as a single line of shell-quoted variables safe for eval:

    # cd /usr/share/dict
    # ls --shell words
    path="/usr/share/dict" file="words" user="root" group="root" size=985084 ...

Then all sorts of things become easy.

    # eval $(ls --shell words); echo "$size" "$file"

This nushell doesn't really change anything important about this biggest scripting problem. You're still parsing human readable output and it's still dependent on particular versions and options passed.

If I had a genie wish of nushell being installed everywhere or even just coreutils having a --shell option I'd take the latter any day.

d33• 4 years ago

I like the idea, but if it was interpreted directly, that would be a security nightmare unless we also had something like Python's ast.literal_eval(). Which makes us come back to JSON-like outputs because we need some form of serialization anyway, I guess.

bsdetector3• 4 years ago

Of course there could be some tweaks like a scoped eval to prevent stomping on the script's variables, but it's really not very hard for a C program to escape shell variables correctly and safely.

You could have an eval that only read variables, but trusting a program to only return variables is a really low bar; it's very hard to mess that up.

dkarl• 4 years ago

jc [0] is dedicated to providing this externally for common commands, but I agree that it would be better if command authors built it in as an option. It would make shell scripts shorter, more readable, and less buggy.

[0] https://github.com/kellyjonbrazil/jc

com2kid2• 4 years ago

Having written a lot of shell scripts, the single greatest thing I've ever experienced is shell-friendly outputs.

This is basically the idea of PowerShell. Output is well formatted data that can be passed around and manipulated in a regular manner. No slicing on columns or anything like that.

PowerShell has other issues (many of which are documented in these very comments!) but shell friendly output is one of its central ideas.

mastax2• 4 years ago

Well in nushell you wouldn't be using the coreutils commands, you'd be using the nushell builtin replacements. Those builtins return structured data.

Now for the 1000 other non-coreutils commands on your system, that's not very helpful. --shell is a good idea, though it seems like JSON is becoming the most common alternative structured output implemented by commands. Nushell and PowerShell can turn JSON into a structured variable easily, though using jq in shell is alright most of the time.

eternalban• 4 years ago

Wouldn't 'find .. -exec ' and friends get you this?

    find . -type f -depth 1 -exec ls -la {} + | awk {'print "file="$9 " user=" $3 " group=" $4 " size=" $5'}

kazinator2• 4 years ago

Your awk has to put out file="..." notation, and if double quotes occur, they have to be escaped. So you're looking at substantially longer command.

  | awk 'function esc(str) {
         ...
         }
         { print "file=\"" esc($9) " user=\"" ... }'

kazinator2• 4 years ago

Calling an external too to list files is an anti-pattern; every programming language or shell language should have that built-in, so it's just doing that via the OS API (opendir/readdir/closedir).

The POSIX shell has that in the form of globbing. That only gives you names, and has quirks that are only adequately worked around with Bash options.

The fix is to use some real programming language for complex work.

I made a language for myself in this space, geared toward C and Unix people who are willing to try Lisp: TXR.

  1> (stat "/usr/share/dict/words")
  #S(stat dev 2306 ino 884986 mode 33188 nlink 1 uid 0 gid 0 rdev 0 size 931708
          blksize 4096 blocks 1832 atime 1667315034 atime-nsec 0 mtime 1238396423
          mtime-nsec 0 ctime 1405615444 ctime-nsec 0 path "/usr/share/dict/words")
  2> (flow "/usr/share/dict/words"
            stat
            [callf list .path .size])
  ("/usr/share/dict/words" 931708)
  3> (flow "/usr/share/dict/words"
            stat
            [callf list .path .size [chain .uid getpwuid .name]])
  ("/usr/share/dict/words" 931708 "root")

exyi4• 4 years ago

Many tools have some switch which will make them output JSON, which is easy to process if you have jq. For example `docker something --format='{{json .}}'`.

SoftTalker• 4 years ago

Part of it is knowing the tools. In this case, 'stat' is the command you probably want to get parsable details about a file, not more options to 'ls'. I often see convoluted shell scripts that could be a lot simpler with the use of more appropriate utilities.

bsdetector3• 4 years ago

It's just an example. With shell-friendly outputs you can recreate "ls -l" with any field order you want with just a few lines of readable shell script. Many of the unix tools only exist because it's so hard to parse the human-readable output in the shells.

raydiatian3• 4 years ago

“Ask and ye shell receive”: I swear I was just complaining about bash, zsh and the lot the other day saying that we needed a modern alternative shell without ridiculous names and design choices. Installing this tonight! So excited!

ripley1213• 4 years ago

Hope you enjoy it! The Nushell Discord is pretty active if you have any questions: https://discord.gg/NtAbbGn

mastax2• 4 years ago

I used nushell's data frame support a year ago to do some data munging. It was a pretty pleasant experience. That was before I learned pandas, though, so I don't know if I'd reach for it again.

the__alchemist4• 4 years ago

Does anyone have an ELI5 for what this, BASH, ZSH, Powershell etc do? It seems it's a conflation of #1: A CLI. #2: A specialized programming language that mainly does file-system operations. Is there a compelling reason to use something like this (or Powershell's scripting system, from the comments here), vice Python or Rust's etc standard library filesystem tools?

Context: I use Windows Terminal with embedded powershell on Windows, and Terminal on Linux. Useful for compiling programs, running Python scripts, and executing CLI-based programs (eg clippy, ipython, rust, various programming-language-specific formatters etc, some CLI-based text editors like VIM). Also, troubleshooting Linux problems.

raydiatian3• 4 years ago

A shell is pretty much what you described. More accurately it’s a program for interacting with the operating system, and it usually ships with a scripting language, and Utility programs. Hence the conflation.

If you’re using Windows Terminal, you’re using a sort of predecessor to Powershell (somebody please correct me on this), if you’re using terminal on Linux, you’re most likely using bash. Enter ps -p $$ at your Linux terminal to find out (which shell you’re using).

Useful for compiling programs, running Python scripts, and executing CLI-based programs

Yeah, so from here, it’s possible to automate those commands, if you wanted to. In windows you’re talking about .Bat or .Ps1 files. Shells are the language you use to write those scripts, and they typically ship with access to some useful (file/text oriented) commands.

The only problem is these shells were invented in the 80s 90s, and have awful conventions that make some people miserable enough that they go and write a new shell that tosses previous conventions out the window. And IMO they did a great job.

ripley1213• 4 years ago

If you’re using Windows Terminal, you’re using a sort of predecessor to Powershell (somebody please correct me on this)

Not necessarily. Windows Terminal is just a terminal emulator; you can run any shell in it: cmd.exe, PowerShell, Nushell, bash, fish...

the__alchemist4• 4 years ago

Appreciate those details! And as ripley said, Windows Terminal is a housing for other terminals like Powershell or various WSL OSes, but has tabs.

BoppreH2• 4 years ago

Shells are a combination of programming language, user interface, and standard library. The programming language and stdlib aspects are just like Python or Rust, but with a different focus:

- Terseness. I can very realistically type hundreds, if not thousands, of commands per day. Extra words or punctuation marks add up quickly.

- Shells are focused on executing things right now, as opposed to most other languages where the output is an abstract program to be run multiple times. This means using literals more often than variables, for example, which is why unquoted words in Bash are strings (except the first word of a command, because terseness is more important than consistency).

- They have more interactive features, such as warnings and prompts. Powershell detects if you're missing required params and prompts you one by one, for example.

- The purpose of a shell is to enable interactivity with OS primitives, be they Linux's files/processes or Windows' objects.

- Because most commands are typed interactively and only run once, glue code is especially painful and wasteful to write. So these languages pick a simple data structure for all function communication, and stick with it (e.g. Powershell's typed objects, Bash's newline separated strings, Lua's everything-is-a-table).

- Quality-of-life features. For example, Bash aliases (e.g. `alias wget='wget -c '`) are a pretty good idea that is non-trivial in other programming languages.

- Easy to plug stuff into other stuff. I don't mean just piping, but also things like temporary files via Bash's process substitution `<()`.

the__alchemist4• 4 years ago

Very clear explanation; thank you!

zacmps• 4 years ago

Yes, scripting languages all support both:

* A repl for performing common operations (moving around the file system, running programs, etc),

* A interpreted environment for scripting these operations.

The main reason to use these instead of Python/Rust is the ease of interfacing with other programs.

In Python, and most other non-scripting languages, spawning and interacting with external processes is quite verbose.

the__alchemist4• 4 years ago

It's verbose in Rust too; error handling; various types ways to handle the program's stdout/stderr etc.

dexterH• 4 years ago

finally. a unix powershell. everything is an object.

TheLocehiliosan• 4 years ago

Just was trying it. A couple minutes in, I discovered it doesn't support suspended jobs.

:( seems like that would be a very basic feature.

https://github.com/nushell/nushell/issues/1329

https://github.com/nushell/nushell/issues/1796

https://github.com/nushell/nushell/discussions/5239

SighMagi3• 4 years ago

In the past, I've toured these alternate, non-POSIX shells like Nushell. A lot of them (e.g. Powershell, Elvish) don't provide job control. I looked into how job control works and it's kind of a bother, so I see why they might have elided it. I wonder if multiplexing the terminal using tmux or screen is a good enough alternative the job control for many use-cases. You do lose state (i.e. environment variables, working directory), but if all you want to do is run something else maybe it's good enough.

I personally haven't tried living without job control though.

parhamn• 4 years ago

My data point: I prefer tmux/multiplexing over job control because the process hierarchy leads me to managing them better (I never accidentally quit tmux). Also I don't have to worry about std stream usage. I'm actually not sure of a case I'd care for job control.

Natfan• 4 years ago

Sorry, but you're incorrect here. PowerShell does most definitely provide job control.

    Get-Help about_Jobs

Alternatively, online documentation from Microsoft regarding jobs: https://learn.microsoft.com/en-us/powershell/module/microsof...

lisnake• 4 years ago

You might be interested in Cat9, https://github.com/letoram/cat9

It's another reimagination of a shell, but built around asynchronous jobs

Myrmornis• 4 years ago

I also use tmux for this. Personally, since starting to use tmux years ago, I've never even thought of wanting job control in an interactive shell process.

zokier3• 4 years ago

Please correct me if I'm wrong, but doesn't nushell suffer from the same problem as powershell that all the nice fancy stuff works only for in-process commands and external programs are bit of a second-class citizens?

To me interesting question is that is it even possible to build rich strucure-aware shell-like cli environment that would allow seamless integration of external polyglot programs in the same vein as unix shells where only minimal amount of stuff is required to be builtins (/bin/[ is cute example).

It is a difficult problem, at minimum probably requires all compatible software to be explicitly made so. But for best experience even the basic unix fundamental of stdin/stdout/stderr+argv/env might need re-evaluation.

exyi4• 4 years ago

nushell seems to have better way of parsing the string-only outputs of other commands.

https://www.nushell.sh/book/commands/parse.html

I don't know how to do a similar thing in powershell.

To me interesting question is that is it even possible to build rich strucure-aware shell-like cli environment that would allow seamless integration of external polyglot programs...

Problem is that most of the classic Unix programs output in some messy format. It would be nice if we could agree that each command has --json flag (for example) which will make the output trivial to parse programmatically in any other advanced shell.

ripley1213• 4 years ago

nushell seems to have better way of parsing the string-only outputs of other commands.

Yup. In addition to that `parse` command, Nu also has a suite of `from` commands that trivially convert other data formats to Nu tables. CSV, JSON, TOML, XML, YAML, and many more.

So if you're working with a program that can emit, say, JSON, you just do `some_external_command | from json` and boom, you've got a Nu table.

zokier3• 4 years ago

It would be nice if we could agree that each command has --json flag (for example) which will make the output trivial to parse programmatically in any other advanced shell.

That's part of the solution, but I think a signaling layer of sorts is needed too so that the reading side knows that the data is structured instead of just bytes. So basically instead of needing explicit

    > foo --json | from json | ...

You could have

    > foo --json | ...

From there it would then be easy to have env var or something instead of explicit cmdline flag to eventually end up with (almost) seamless

    > foo | ...

majkinetor8• 4 years ago

Powershell Select-String has the thing similar to nu's parse. See https://devblogs.microsoft.com/powershell/parsing-text-with-...

There is also very powerfull ConvertFrom-StringData

https://learn.microsoft.com/en-us/powershell/module/microsof...

PointyFluff• 4 years ago

I found Nushell to be too buggy for day to day use, but I sure am looking forward to the day it's stable!

peter_d_sherman• 4 years ago

Nushell looks pretty good!

But, how to automatically convert all existing shell scripts -- to Nushell?

I think it would be highly interesting if someone created "an LLVM for shell scripts"...

In other words -- given a shell script that runs on one shell, turn that into a parse tree -- then transpile that parse tree back into a script such that the transpiled script runs on a different shell -- with guaranteed full compatibility...

Maybe some work in this area is being done, or already has been done...

I'd be interested if anyone knew of anything like this...

If so -- then links would be appreciated!

Nushell: Introduction to a new kind of shell

Related Stories