HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
oils-for-unix
oils
Python2016–2025
oils-for-unix / oils

oils

Oils is our upgrade path from bash to a better language and runtime. It's also for Python and JavaScript users who avoid shell!

35Distinct people
225Mentions
1Explicit recommenders
3.4KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Oils is our upgrade path from bash to a better language and runtime. It's also for Python and JavaScript users who avoid shell!

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

There are Usenix papers on bash and ksh -- I archived the ksh one here: http://www.oilshell.org/archive/ksh-usenix.pdf The surprising thing to me is that ksh was Lua-like in…

chubot used a recommendation phrase. 4 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 4:59:52 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year225 dated mentions

Observed mentions: 2016-11-26 10:24:57 UTC to 2025-11-06 22:34:08 UTC.

02040602016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20162017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 13 mentions; 0 submissions, 13 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 27 mentions; 2 submissions, 25 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 52 mentions; 3 submissions, 49 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 41 mentions; 2 submissions, 39 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 27 mentions; 3 submissions, 24 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 16 mentions; 1 submissions, 15 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 17 mentions; 2 submissions, 15 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 20 mentions; 2 submissions, 18 comments2025

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC303
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC13013
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC909
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC27225
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC52349
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC41239
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC27324
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC16115
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC17215
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC20218

What Hacker News says

17 sources
Congrats to the fish team! Great writeup with lots of interesting detail. I wonder if this is the biggest project that has moved from C++ entirely to Rust (or maybe even C to Rust?) It probably has useful lessons for other projects. If I'm reading this right, it looks like fish was not released as a hybrid C++ / Rust program, with the autocxx-generated bindings. There was a release during that time, but it says "fish 3.7 remains a C++ program" [1] It sounds like they could have released if they wanted to, but there was a last stage of testing that didn't happen until the end. Some people didn't quite get the motivation for adding C++ features to Rust [2], and vice versa, to enable inter-op. But perhaps this is a good case study. It would be nice if you could just write new Rust code in a C++ codebase, without writing/generating bindin
Read the rest
gs, and then throwing them away, which is mentioned in this post. --- Also the #1 gripe with Rust seems to be that it supports version detection, not feature detection. But feature detection is better for distros, web browsers, and compilers: Feature Detection Is Better than Version Detection - https://github.com/oils-for-unix/oils/wiki/Feature-Detection... Version/name detection is why Chrome and IE pretend to be Mozilla, and why Clang pretends to be GCC. Feature detection (e.g. ./configure and eval() ) doesn't cause this problem! [1] https://github.com/fish-shell/fish-shell/releases [2] e.g. https://news.ycombinator.com/from?site=safecpp.org
In Fish 4.0: The Fish of Theseus
Oils aims to be the absolute best way to migrate shell scripts! (I created the project, and the wiki page being discussed) https://www.oilshell.org/ OSH is the most bash-compatible shell in the world, and YSH is a new language ls | sort | uniq | wc -l # this is both OSH and YSH var mydict = {foo: 42, bar: ['a', 'b']} # this is new YSH stuff you can start using json write (mydict) The difference between OSH and YSH is exactly a set of "shopt" options [1], although YSH feels like a brand new language too! There is a smooth blend. I think it's worth it for 2 things alone - YSH checks all errors - you never lose an exit code - YSH has real arrays and doesn't mangle your variables with word splitting There's a lot more: modules with namespaces (use mymodule.ysh), buffered I/O that's not slow, etc. Gradually upgrading -htt
Read the rest
ps://github.com/oils-for-unix/oils/wiki/Gradually-Upgradi... (people are writing new YSH, but not many people have gradually upgraded, so I'd definitely appreciate feedback from people with a big "shell script problem") --- There is a FAQ here about Perl: Are you reinventing Perl? - https://www.oilshell.org/blog/2021/01/why-a-new-shell.html#a... Not to say that migrating to Perl is worse in any way, i.e. if you already know Perl or your team knows it. But objectively YSH is also a shell, so I think more of the code carries over, and there is a more direct upgrade path. --- [1] Unix Shell Should Evolve like Perl 5 - https://www.oilshell.org/blog/2020/07/blog-roadmap.html#the-... - i.e. with compatible upgrade options
In Biggest shell programs
FWIW there are several Haskell and OCaml shell projects on this wiki page, which is editable: Internal DSLs for Shell - https://github.com/oils-for-unix/oils/wiki/Internal-DSLs-for... and ones in many other languages like Scheme and Lisp e.g. https://github.com/jgoerzen/hsh/wiki https://github.com/luke-clifton/shh/tree/master/shh And also a page of alternative shells: https://github.com/oils-for-unix/oils/wiki/Alternative-Shell...
In A Tour of Hell – Shell scripting Haskell dialect
Hm I'm not familiar with that library (or really any others in the landscape). Why pick that one? Why be doubtful it's buggy -- is it used in a major app? I can't really tell from this page: https://www.libtom.net/LibTomMath/ I'd be interested in a review / survey of different options, and the strategy for testing. Basically the tests should "argue" that the code is correct, and documentation / blog posts also count! (I'm honestly not sure how hard it is to make a correct big num library. But I think the original article in this series said there were probably bugs, so I'm guessing it's not trivial) To give a flavor, we publish test results and and coverage numbers like this [1], and any new library should be consistent with this: https://www.oilshell.org/release/0.22.0/quality.html Our GC runtime has less than 5000 lines of hand-writ
Read the rest
ten C++ now, so any solution should be in proportion to that. That is, we probably wouldn't take on 3000 lines of code just for big nums. So we favor correctness over performance. Hopefully there would be little perf loss in the small int case, but it's OK if the big int case is slow. It's the rarer case for sure. It's a shell, not a Fortran competitor! --- As far as the grant, we pay in 2500 euro or 5000 euro increments, and I don't try to parse "effort spent" any more than that. I care about the result, not if it's easy for a particular person :) For example earlier this year we had a contributor Justin who worked on the pretty printer, with Wadler's algorithm (which I was unfamiliar with). https://www.oilshell.org/blog/2024/06/release-0.22.0.html And he had co-authored a paper on pretty printing, so it was probably not too difficult overall. But that's a good thing as far as I'm concerned! So if you or anyone else thinks it's easy, please feel free to contact me / play around with the code, etc. https://github.com/oilshell/oil/wiki/Where-Contributors-Have... [1] our unit test coverage is reported at 83% or so, but we favor "exterior" tests, so it's really close to 95% or 99%. Also of course line coverage isn't really a way to measure correctness per se.
In Optimizing a bignum library for fun
Very useful post! Also it's cool to see how many people in this thread have worked on this problem -- lots of new info here I haven't seen I wonder if anyone is interested in implementing a big numbers in Oils? It's a Unix shell with TWO complete implementations - the "executable spec" in Python, and an automatic translation to pure C++ (which is 30x-50x faster) We currently use 64-bit integers in C++, but big nums are a better semantic. Some trivia about bad shell semantics here: Integers - Don't do whatever Python or C++ does - https://www.oilshell.org/blog/2024/03/release-0.21.0.html#in... This is a very self-contained project: the interface is defined by 200 lines of Python: https://github.com/oilshell/oil/blob/master/mycpp/mops.py and the trivial 64-bit overflowing implementation is also about 200 lines: https://github.com/oilshe
Read the rest
ll/oil/blob/master/mycpp/gc_mops.h https://github.com/oilshell/oil/blob/master/mycpp/gc_mops.cc (We have a fast Ninja-based build system, so you can probably iterate on this in 100 milliseconds or less -- it should be fun for the right person) --- I think the main reason it is specific to Oils is that the bigger number should become GC objects. Details on our GC here: Pictures of a Working Garbage Collector - https://www.oilshell.org/blog/2023/01/garbage-collector.html It's been very solid for the last 18 months, basically because it's well tested by ASAN and #ifdef testing modes. The main thing I'd be concerned with is how to TEST that big number operations are correct. I think there are probably some interesting strategies, which I'd love to discuss. You're of course welcome to adapt existing open source code, including code you've already written -- I probably even prefer that, i.e. something that has had some real world testing. We want all the operations in that file, and it should be integrated with our GC. --- We've had ~6 contributors funded by grants from https://nlnet.nl for the past couple years, so you can even be paid (there's a chance it depends on the country you live in, but generally a wide range of situations is OK). Contact me at andy at oilshell.org or https://oilshell.zulipchat.com/ if interested!
In Optimizing a bignum library for fun
Oh yes feel free to join https://oilshell.zulipchat.com/ -- there is a whole #shell-gui channel . We are mainly developing OSH and YSH now, but it would be nice to work on the interactive shell too The key idea is that OSH and YSH can run "headless" with the "FANOS" protocol (file descriptors and netstrings over unix domain socket), which has a tiny implementations in C and Python The reason we use FD passing with Unix sockets is so that anything that uses terminal still works: ls --color pip install cargo build All these programs will output ANSI color if `isatty(stdout)` is true (roughly speaking). Most people didn't quite get that -- they thought we should use "nREPL" or something -- but my opinion is that you really need a specific protocol to communicate with a shell, because a shell spawns other programs you still wan
Read the rest
t to work. --- Here is a pure Python 3 implementation of the recv() side of FANOS in only ~100 lines https://github.com/oilshell/oil/blob/master/client/py_fanos.... It uses the recvmsg() binding . I'm pretty sure node.js has that too? i.e. it has Unix domain socket support --- Anyway, thanks for taking a look - we're interested in feedback!
In The Software Crisis
This looks pretty cool! I agree -- a big reason I like Unix, and find it productive, is that it's "shallow and composable". But GUIs have long been a weakness. I guess because there are many "global" concerns -- whether a UI is nice isn't a "modular" property. Personally I would more of a UI, but still retain automation That is, the property of shell where I can just saved what I typed in a file, and then run it later And modify it and run it again Or I can copy and paste a command, send it to my friend in an e-mail, etc. --- As context, I've been working on a from-scratch shell for many years, and it has a "headless mode" meant for GUIs. There are real demos that other people have written, but nobody's working on it at the moment. Screenshots: https://www.oilshell.org/blog/2023/12/screencasts.html#headl... https://www.oilshell.org/blog
Read the rest
/tags.html?tag=headless#headles... More links here - https://github.com/oilshell/oil/wiki/Interactive-Shell - some interesting (inactive) projects like Xiki If you find the need for a compatible shell that's divorced from the terminal, or a NEW shell that is, feel free to let me know (by e-mail or https://oilshell.zulipchat.com ) Basically we need to people to test out the headless protocol and tell us how it can be improved. I think we should make a shell GUI that HAS a terminal, but IS NOT a terminal -- which looks like it has some relation to what you're building Right now we're working mostly on the new YSH language, but I'd like to revive the GUI work too ... I'm not an experienced UI programmer, so it would be nice to have some different viewpoints :) --- Also, I'm a big fan of ggplot, so I'm glad you included it there. Actually ggplot is exactly where I miss having graphics in shell!
In The Software Crisis
A better solution is just to write a plain ass shell script that tests if various C snippets compile. https://github.com/oilshell/oil/blob/master/configure https://github.com/oilshell/oil/blob/master/build/detect-pwe... Not an unholy mix of m4, shell, and C, all in the same file. --- These are the same style as a the configure scripts that Fabrice Bellard wrote for tcc and QEMU. They are plain ass shell scripts, because he actually understands the code he writes. https://github.com/qemu/qemu/blob/master/configure https://github.com/TinyCC/tinycc/blob/mob/configure OCaml’s configure script is also “normal”. You don’t have to copy and paste thousands of lines of GNU stuff that you don’t understand. (copy of lobste.rs comment)
In Autoconf makes me think we stopped evolving too soon
Oh wow, I had stumbled on the zsh behavior of echo hi > *.txt # writes ALL of the files! No other shell does that. But I didn't know it was called MULTIOS until now. (I guess that's read "mult I/O's"? I have a hard time not reading it as "multi-OS" :) ) It seems a bit niche to be honest, but it's possible to support in Oils. --- Oils also uses Unix domain sockets already for the headless shell protocol https://github.com/oilshell/oil/wiki/Headless-Mode We could do something like dgsh, but so far I haven't seen a lot of uptake / demand. Every time it's mentioned, somebody kinda wants it, and then it kinda peters out again ... still possible though. I think flat files work fine for a lot of use cases, and once you add streaming, you also want monitoring, more control over backpressure/queue sizes, etc.
In Pipexec – Handling pipe of commands like a single command

Showing the 15 most recent of 17 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.