argbash VS oil

Compare argbash vs oil and see what are their differences.

oil

Oils is our upgrade path from bash to a better language and runtime. It's also for Python and JavaScript users who avoid shell! (by oilshell)
InfluxDB - Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured
argbash oil
13 241
1,376 2,782
- 0.9%
0.0 9.9
about 2 months ago 11 days ago
M4 Python
GNU General Public License v3.0 or later GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

argbash

Posts with mentions or reviews of argbash. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-04-04.

oil

Posts with mentions or reviews of oil. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-07-05.
  • The Software Crisis
    3 projects | news.ycombinator.com | 5 Jul 2024
    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 want 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!

  • The Pre-Scheme Restoration project is now underway
    6 projects | news.ycombinator.com | 21 Jun 2024
    This is similar to how https://www.oilshell.org/ is written

    There are two complete implementations

    1. one that runs under a stock Python interpreter (which doesn't use static types)

    2. one that's pure C++, translated from statically typed Python code, and from data structures generated in Python

    In the second case, everything before main() is "burned off" at build time -- e.g. there is metaprogramming on lexers, flag parsers, dicts, etc. that gets run and then into static C data -- i.e. pure data that incurs zero startup cost

    Comparison to Pre-Scheme: https://lobste.rs/s/tjiwrd/revival_pre_scheme_systems_progra... (types, compiler output, and GC)

    Brief Descriptions of a Python to C++ Translator - https://www.oilshell.org/blog/2022/05/mycpp.html

    ...

    And related to your other point, I remember looking at Racket's implementation around the time it started the Chez Scheme conversion. I was surprised that it was over 100K lines of hand-written C in the runtime -- it looked similar to CPython in many ways (which is at at least 250K lines of C in the core).

  • POSIX.1-2024 Is Published
    1 project | news.ycombinator.com | 14 Jun 2024
    Is it an array of strings because it's a "simple command"? Or does it behave like an assignment? You get two different answers depending on how you look at it.

    The bottom line is that assignment builtins are special and they don't follow the normal rules of simple commands. Shells have differed, but POSIX decided on this awhile ago.

    ---

    This is all of course mind numbing trivia that has no real reason for existing ... YSH fixes it, and it's now pure native C++, no more Python.

    YSH Doesn't Require Quoting Everywhere - https://www.oilshell.org/blog/2021/04/simple-word-eval.html (Oil was renamed to YSH since this blog post was written)

    Simple Word Evaluation in Unix Shell - https://www.oilshell.org/release/latest/doc/simple-word-eval...

    In YSH you can tell just by looking it's a single string or an array.

        ls $a  # identical to ls "$a"
  • New Programming Langauge Makes Bash Scripting Easier
    1 project | news.ycombinator.com | 13 Jun 2024
    Oils is a different approach to this - the base “OSH” language is pretty much identical to bash, and then you can incrementally opt in to more checks and QOL improvements.

    The key selling point is that you never have to totally rewrite your existing bash scripts - there’s an incremental upgrade path.

    https://www.oilshell.org/

  • Elvish, expressive programming language and a versatile interactive shell
    9 projects | news.ycombinator.com | 9 May 2024
    While I don't agree with most of your analysis - in particular for the second example, I'd invite you to read its explainer that goes into much more depth (https://elv.sh/learn/scripting-case-studies.html#update-serv...) - I think you might be more interested in the Oil Shell project, which is trying to chart a smooth upgrade path from bash: https://www.oilshell.org

    I think we simply can't say for sure which path is better for the future of shells, and I'm quite excited by the fact that different projects are exploring different directions. I will just stick to the path I find best and won't try to convert you :)

  • The life and times of an Abstract Syntax Tree
    1 project | news.ycombinator.com | 2 May 2024
    Some related references (on a somewhat messy wiki page) - https://github.com/oilshell/oil/wiki/Compact-AST-Representat...

    Feel free to add others

  • Autoconf makes me think we stopped evolving too soon
    8 projects | news.ycombinator.com | 3 Apr 2024
    will prevent almost all of the "silent footguns".

    YSH has strict:all and then a bunch of NEW features.

    There's been good feedback recently, which has led to many concrete changes. So your experience can definitely influence the language! https://github.com/oilshell/oil/wiki/Where-To-Send-Feedback

  • Basic Things
    1 project | news.ycombinator.com | 30 Mar 2024
    Regarding writing tools/tests/benchmarks in bash+Python, vs. writing tools in your main language:

    I think we might eventually concede that something Debian-like is the “standard development environment” (at least for server side stuff, i.e. not iOS apps)

    In this case, bash+Python is a non-issue. It works extremely reliably. That’s actually why I use it! Everything else seems to break, or it’s really slow (node.js is a very common alternative).

    - Microsoft conceded this back in ~2017, by building Linux into their kernel with WSL, and providing Ubuntu on top

    Yes bash + Python is a disaster on Windows (I have scars from it), but Microsoft agrees that the right place to solve that is in Windows :-)

    - Every CI system runs Debian/Ubuntu

    - Every hosting provider runs Debian/Ubuntu

    - Every online dev env like gitpod.io provides Debian/Ubuntu

    This is somewhat related to remote dev envs: https://lobste.rs/s/ucirlx/lapdev_self_hosted_remote_dev

    One vision for https://www.oilshell.org/ is that the CI environment is the dev environment is the hosting environment.

    Everything is just an equal node in a distributed system. BUT it’s more git like, in that you explicitly sync and work “locally”, wherever that is. You don’t have the network chatter and flakiness of “the cloud”.

    Oils has a very large set of monotonically increasing properties too - https://www.oilshell.org/release/0.21.0/quality.html

    All that is bash+Python that is run on every commit, and it’s extremely good at catching bugs and perf regressions.

    I’m skeptical that any project has that level of quality automation written in pure Rust or Zig. More likely it’s a bunch of cloud services with YAML.

    Also a bunch of “hard-coded” toolchains that you can’t script with bespoke code. Like some shell commands in your package.json, which is just a worse way of writing a shell script.

    Our quality process is all self-hosted, in the repo, and runs on both Github Actions and sourcehut - https://www.oilshell.org/release/0.21.0/pub/metrics.wwz/line...

    bash and Python runs perfectly on Github Actions and sourcehut, with zero change. Containers also do.

    (Although we need to unify the CI and release, because the release runs on 2 different real hardware machines, while CI is cloud only.)

    Also, a main point Oils is that bash now has another highly compatible, spec-driven implementation – OSH. Having 2 independent implementations is something newer languages don’t have.

    (copy of lobste.rs comment)

  • The secret weapon of Bash power users
    2 projects | news.ycombinator.com | 24 Mar 2024
    in your bashrc to enable it. I've used it for probably ~18 years now.

    It also works with https://www.oilshell.org/ since we use GNU readline. Just 'set -o vi' in ~/.config/oils/oshrc

  • Pipexec – Handling pipe of commands like a single command
    6 projects | news.ycombinator.com | 9 Mar 2024
    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 was 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.

What are some alternatives?

When comparing argbash and oil you can also consider the following projects:

bash-argsparse - An high level argument parsing library for bash

nushell - A new type of shell

docopts - Shell interpreter for docopt, the command-line interface description language.

fish-shell - The user-friendly command line shell.

getoptions - An elegant option/argument parser for shell scripts (full support for bash and all POSIX shells)

elvish - Powerful scripting language & versatile interactive shell

modernish - Modernish is a library for writing robust, portable, readable, and powerful programs for POSIX-based shells and utilities.

xonsh - :shell: Python-powered shell. Full-featured and cross-platform.

argparse-bash - Use python's argparse module in shell scripts

FaceFusion - Next generation face swapper and enhancer

bash_opts - SImple Bash options parser

PowerShell - PowerShell for every system!

InfluxDB - Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured