just stores project commands as recipes in a justfile

Recipes live in a justfile with make inspired syntax

just saves project specific commands under names called recipes. Those recipes live in a file called justfile and the syntax draws on make. The project page for the runner is https://just.systems, the code is Rust under CC0-1.0, the default branch is master, and version 1.58.0 was released on 2026-08-03 after 1.57.0 on 2026-07-19 and 1.56.0 on 2026-07-10, with the last push on 2026-09-27. A minimal flow looks like this:

$ just test-all
cc *.c -o main
./test --all
Yay, all your tests passed!

The invocation pattern is just RECIPE, so just test-all runs the recipe named test-all. That single pattern matters because everything else builds on it: parameters extend a recipe, listing shows recipe names, and modules split recipes across files. Readers coming from make should notice the deliberate scope choice. just calls itself a command runner, not a build system, so there is no .PHONY marker for recipes. The repository layout around that idea includes src, tests, examples, completions, book, www, contrib, crates, etc, bin, and a justfile of its own with grouped recipes for dev, test, check, misc, doc and release work.

One justfile serves every subdirectory through modules and imports

A justfile does not force every terminal session to start in the same folder. just can be invoked from any subdirectory, not only the directory that contains the justfile. For a repository with frontend, backend and docs folders, that means one justfile at the root still serves commands run deeper in the tree, and contributors do not need wrapper scripts that cd back to the root first. The companion organization tools are modules and imports. justfiles can be organized into multiple files using modules and imports, so a large recipe collection splits into smaller files instead of growing one long file. The repository ships examples that show the range, including examples/cross-platform.just, examples/keybase.just, examples/kitchen-sink.just, examples/powershell.just, examples/pre-commit.just, examples/rule124.just and examples/screenshot.just. The manual at https://just.systems/man/en/ carries the full reference, and the book reflects the latest release while the README on GitHub reflects latest master, with a Chinese edition kept at README.中文.md. Help channels are opening an issue, pinging the maintainer on Discord at https://discord.gg/ezYScXR, or mail to [email protected].

Unknown recipes and dependency cycles fail before anything runs

just resolves several classes of mistakes before running anything. Unknown recipes and circular dependencies are reported before anything runs, wherever possible errors are resolved statically, errors are specific and informative, and syntax errors are reported along with their source context. The practical effect is fail fast at parse time rather than halfway through a multi step recipe. A typo in a recipe name surfaces instead of executing half the steps, and a cycle between recipes surfaces instead of looping. Recipes also accept command line arguments, including flags and options, and just adds an expression language with many built in functions. The Cargo.toml description repeats the short pitch as Just a command runner, with categories command-line-utilities and development-tools, keywords command-line, task, runner, development and utility, edition 2024 and rust-version 1.89.0. Dependencies named there include blake3, camino, chrono, clap, clap_complete, clap_mangen, dotenvy, heck, regex, semver, serde, serde_json, sha2, shellexpand, similar, snafu, strsim, strum, tempfile, typed-arena, unicode-width and uuid, with nix on unix and ctrlc on Windows. Those facts do not by themselves prove speed or scale: the README and Cargo.toml give no benchmark numbers to quote.

Dotenv loading plus shebang recipes cut down wrapper scripts

Environment handling and language choice reduce glue code around recipes. just loads .env files, which makes it easy to populate environment variables, so secrets and per project settings move out of each recipe body into one dotenv file. Recipes can be listed from the command line, and command line completion scripts are available for most popular shells, with a completions directory in the repository and generated man output supported by the project justfile through a man recipe that writes man/just.1. Recipes can be written in arbitrary languages like Python or Node.js through shebang recipes, which lets a team keep shell for short steps and switch a single recipe to Python or Node.js without adding a separate script file and a separate invocation convention. The project justfile itself shows grouping and reuse: alias t := test maps a short name to a longer recipe, grouped recipes cover watch, test, check, ci, run, filter, build, fmt, shellcheck, man, view-man, doc, update-changelog, update-contributors, action-versions, outdated, unused and publish, and parameterized recipes such as watch and filter accept args or PATTERN values. For readers, the consequence is fewer one off shell wrappers, at the cost of learning just specific settings for groups, aliases, parameters and dotenv behavior.

Windows recipes stop when sh is missing from PATH

Windows support exists but it does not bundle the shell that recipes expect. just should run on any system with a reasonable sh, including Linux, macOS and the BSDs. On Windows, just works with the sh provided by Git for Windows at https://git-scm.com, GitHub Desktop at https://desktop.github.com, or Cygwin at http://www.cygwin.com, and after installation sh must be available in the PATH of the shell used to invoke just. If no sh is present, the reader has two paths: install one of those sh providers, or change the recipe shell with the shell setting. PowerShell is selected this way:

# use PowerShell instead of sh:
set shell := ["powershell.exe", "-c"]

hello:
  Write-Host "Hello, world!"

The cmd.exe variant follows the same shape:

# use cmd.exe instead of sh:
set shell := ["cmd.exe", "/c"]

list:
  dir

The shell can also be set per invocation with command line arguments, for example launching just with --shell powershell.exe --shell-arg -c. PowerShell is installed by default on Windows 7 SP1 and Windows Server 2008 R2 SP1 and later, and cmd.exe is described as quite fiddly, so PowerShell gets the recommendation for most Windows users. The consequence of missing this section is direct: recipes fail or behave oddly when sh is absent from PATH, and cross platform justfiles need explicit shell choices instead of assuming one shell everywhere.

No timestamp graph means every recipe runs from the top

just does not track file timestamps and rebuild only changed outputs. It avoids much of make complexity and idiosyncrasies, with no need for .PHONY recipes, but that simplicity removes the build graph that make users depend on for C, C++ and other compiled outputs. A recipe named build runs its lines every time it is invoked, even when inputs have not changed, unless the recipe author adds their own timestamp checks, hash checks or skip logic inside the recipe. For a small docs site or a test alias that gap hardly matters. For a large compiled tree it changes cost: every invocation pays full command time, incremental builds lose their free skip, and CI minutes grow when a recipe recompiles or retests unchanged work. The repository justfile hints at the workaround culture, with cargo watch commands, filter recipes that pass a PATTERN through, and explicit check and test groups that run cargo lcheck and cargo ltest forms with all targets. Those wrappers still execute when asked. Readers who need minimal rebuilds should keep make, ninja, cargo or another build tool for the artifact graph and reserve just for short entry points that call those tools, rather than expecting just to infer what is stale.

Fourteen install lines hide real channel tradeoffs

Getting the binary is easy, choosing a channel takes care. Installation offers three paths: package installation, pre-built binaries, and building from source with cargo install just. The cross platform table gives one line per manager:

arkade get just

cargo install just

cargo binstall just

conda install -c conda-forge just

brew install just

nix-env -iA nixpkgs.just

npm install -g rust-just

pipx install rust-just

snap install --edge --classic just

spack install just

uv tool install rust-just

The asdf path needs two steps, adding the plugin then installing a version. Note the packaging split: Rust oriented channels ship a crate named just, while npm, pipx and uv ship rust-just, so copying a command from the wrong ecosystem installs nothing or the wrong thing. Snap tracks edge with classic confinement, which trades stability for freshness and needs snapd support that some servers lack. Building from source needs a Rust toolchain at or above rust-version 1.89.0 and compiles dependencies such as clap, serde and blake3, which costs time on first install. Readers should pick the channel that matches their update habits: Homebrew, Conda, Nix or Spack for managed upgrades, Cargo or source for the newest master, npm or pipx or uv when the project already standardizes on those installers.

Editorial conclusion

Use just if you want a small Rust runner for project commands stored as recipes in a justfile, with a last push on 2026-09-27 and release 1.58.0 behind it. Skip it if you need make style rebuild avoidance or a Windows setup with no sh on PATH, and before adopting it confirm which shell your recipes will run under and where your justfile lives.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes