Just: A Command Runner

• just

  180 20,804 9.5 Rust

  🤖 Just a command runner

  This is actually very different than `make`, since it will always run the tasks even if their inputs haven't changed[0].

  It's a bit bizarre to me that their example involves building code, since this application generally benefits from the "idiosyncratic" behavior of `make`.

  In fact, you probably would want the behavior of `make` for the `test` command too, to avoid running potentially time-consuming tests unnecessarily. Bazel caches test results to avoid this, for example.

  [0] https://github.com/casey/just#what-are-the-idiosyncrasies-of...

• SaaSHub

  www.saashub.com featured

  SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

  

• Task

  119 11,217 9.6 Go

  A task runner / simpler Make alternative written in Go

  

  It seems to me much nicer choice is https://taskfile.dev/

  Just doesn't seem to even support caching task results (by declaring inputs/outputs)?

• run

  17 479 3.5 Go

  Task runner that helps you easily manage and invoke small scripts and wrappers (by TekWizely)

  A tool that I created in the same category:

  RUN : A Task runner that helps you easily manage and invoke small scripts and wrappers

  * https://github.com/TekWizely/run

  Do you find yourself using tools like make to manage non-build-related scripts?

  Build tools are great, but they are not optimized for general script management.

  Run aims to be better at managing small scripts and wrappers, while incorporating a familiar make-like syntax.

  Some features:

  * Auto generates command list

  * Auto generates help for commands

  * Supports defining command-line arguments, which are presented in help text

  * Can be composed via includes

  * Each command can define its own shell (or even python, etc)

  If you're interested in task runners, I hope you'll take a look!

• sqlite-utils

  37 1,644 6.5 Python

  Python CLI utility and library for manipulating SQLite databases

  I've been using this for about six months now and I absolutely love it.

  Make never stuck for me - I couldn't quite get it to fit inside my head.

  Just has the exact set of features I want.

  Here's one example of one of my Justfiles: https://github.com/simonw/sqlite-utils/blob/fc221f9b62ed8624... - documented here: https://sqlite-utils.datasette.io/en/stable/contributing.htm...

  I also wrote about using Just with Django in this TIL: https://til.simonwillison.net/django/just-with-django

• GLI

  1 1,257 7.1 Ruby

  Make awesome command-line applications the easy way

  I use https://github.com/davetron5000/gli for this, since I work in ruby. Adding something like just or gli to your project is a huge win. Every dev can just `just update_db` to refresh their dev db, `just update_secrets` to update dev secrets. Whatever. So much better than putting snippets in a wiki or whatever.

  I like gli because it gives you subcommands, like `gli database refresh` etc.

• doit

  20 1,856 0.0 Python

  CLI task management & automation tool

  

• build

  2 18 10.0 Lua

  build is like Makefile for single files (by hbbio)

  Shameless plug: https://github.com/hbbio/build

  This is just a basic prototype but I'm still using it after many years and sits just over a 100 lines of Lua.

  The core idea is to embed a way to compile/build files from a single line comment in each file directly.

• cargo-make

  27 2,560 9.3 Rust

  Rust task runner and build tool.

  https://github.com/sagiegurari/cargo-make

  I ended up using it over just because it felt easier to use cross platform, and toml seemed like a right choice

• ninja

  51 11,124 8.7 C++

  a small build system with a focus on speed

  

  Oh excellent, then better (and more portable!) tools are available:

  http://pants.build

  https://ninja-build.org

  https://buck.build

  and, if you hate yourself: https://bazel.build

• Buck

  14 8,564 3.9 Java

  Discontinued A fast build system that encourages the creation of small, reusable modules over a variety of platforms and languages.

  

  Oh excellent, then better (and more portable!) tools are available:

  http://pants.build

  https://ninja-build.org

  https://buck.build

  and, if you hate yourself: https://bazel.build

• Bazel

  139 23,057 10.0 Java

  a fast, scalable, multi-language and extensible build system

  

  Oh excellent, then better (and more portable!) tools are available:

  http://pants.build

  https://ninja-build.org

  https://buck.build

  and, if you hate yourself: https://bazel.build

• pure-sh-bible

  29 6,281 0.0 Shell

  Discontinued 📖 A collection of pure POSIX sh alternatives to external processes.

  There is the "pure bash bible" but it seems less than maintained these days: https://github.com/dylanaraps/pure-sh-bible

  Otherwise you're stuck reading the POSIX standard: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V...

• aws-sdk-api-changes

  1 0 10.0

  aws sdk api changes published as a static site

  I also love just, but I try to restrict my usage to projects that don't have larger communities or user populations, as the getting it installed aspect is nowhere near universal as make. my favorite is mixing scripting languages and shell in the same file, albeit its got some rope.. but its productive and intuitive. https://github.com/kapilt/aws-sdk-api-changes/blob/master/ju...

• ShellCheck

  494 36,220 8.6 Haskell

  ShellCheck, a static analysis tool for shell scripts

  https://www.shellcheck.net/ and it’s accompanying cmdline tool/ lsp integrations is a lifesaver for preventing that kind of thing. It’ll warn you if you’re doing anything not portable and even smartly changes it’s behavior depending whether your shebang line uses bash or sh (iirc)

• oop0

  2 0 2.1 C

  OOP library for C99

  You can see that here. You can also see my Make+BASH solution for documenting targets.

  https://github.com/lpsantil/oop0/blob/master/Makefile#L87-L1...

• scripts-to-rule-them-all

  8 3,140 0.0 Shell

  Discontinued Set of boilerplate scripts describing the normalized script pattern that GitHub uses in its projects.

  

  I dig the general idea, but question the value add over a directory of `scripts` that follow sane conventions (ie `script/test`, `script/build` etc). Is the main thing that you can do `just -l` to see available commands? I have never really reached for `make` when I've had a choice, as I've done mostly ruby, JS, or java where you have more sane, humane tools (i.e. Rake, Yarn, Maven though that one is never fun).

  My general approach is every repo should have something that follows https://github.com/github/scripts-to-rule-them-all, written in sh (maybe bash, its 2023), linted with shellcheck. When you need something fancy Rake is great or grab some nice bash command line helper and source it from all your scripts. Is a command listing really worth another dependency over what you get from `ls script` or `cat script/README` ?

• makesure

  14 341 9.2 Shell

  Simple task/command runner with declarative goals and dependencies

  Another simple tool similar to this is makesure[1]. It’s written in shell so the idea is you include makesure itself in your repo, which avoids needing to install another tool to run commands on your project.

  It’s very simple so isn’t good for everything, but works well as a simple command runner.

  [1] https://github.com/xonixx/makesure

• makesh

  2 3 2.6 Shell

  Makefile-sorta-kinda-alike Bash task runner

  Looks cool! Including the script in the project directory is the way, and I created on makesh[1] with that in mind. Since it's a submodule it can be easily pulled around with a repo and updated.

  Glad to see people are finally going back to ahell scripts since they are very ergonomic and with a little portability in mind, they can be cross platform too.

  [1] https://github.com/Baldomo/makesh

Suggest a related project