Open-source project
casey/just avatar
casey/just

just: A Command Runner That Avoids Make's Complexity

🤖 Just a command runner

36,712 stars908 forksRustCC0-1.0

At a glance

What is it?
just stores project-specific commands in a make-inspired justfile and runs them with a single command. It is a command runner, not a build system, and it targets developers who want simpler, more predictable task execution.
Who is it for?
Adopt just if you manage project-specific commands and want a tool that avoids make's build-system baggage, supports multiple shells, and offers static error checking. Skip it if you need a full build system with dependency tracking and incremental builds, or if your team is already invested in make or a task runner like Task.
Can I use it commercially?
Yes. CC0-1.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • casey/just36,712 ★ · +1,364
Star history
Repository2026-08-182026-11-15
casey/just35.3k36.7k

1,364 Stars in the last 89 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What just Solves and Who It Is For

just solves the problem of remembering and running project-specific commands. Instead of typing long shell commands or scrolling through documentation, you define them in a file called justfile, then run them with just RECIPE. The README positions it as a command runner, not a build system, which is a key distinction. It avoids much of make's complexity and idiosyncrasies, such as the need for .PHONY recipes. The target user is a developer who works on a project with repetitive tasks: testing, building, deploying, or any sequence of shell commands. It is for individuals and teams who want a single, discoverable place for those commands, with the ability to pass arguments, use environment variables, and write recipes in multiple languages.

How just Works: Recipes, Shells, and Static Checks

The core mechanism is the justfile, a file with syntax inspired by make. Each command is a recipe. When you run just test-all, just finds the justfile in the current directory or any parent directory, parses it, and executes the recipe's lines in the system shell. The README shows a simple example: a recipe that compiles C files, runs a test, and prints a message. Just does not track file dependencies or decide what to rebuild; it simply runs the commands you give it. This is a deliberate design choice. The documentation emphasizes that errors are resolved statically where possible: unknown recipes and circular dependencies are reported before anything runs. This means you get feedback at parse time, not after a long command chain fails halfway. The shell is configurable. On Unix, it uses sh by default, but on Windows you can set it to PowerShell or cmd.exe via the set shell directive or command-line arguments like --shell powershell.exe --shell-arg -c. This flexibility is important for cross-platform teams.

Getting Started: Installation and First justfile

Installation is straightforward. The README lists many package managers: brew install just for macOS, cargo install just for Rust users, conda install -c conda-forge just, snap install --edge --classic just for Linux, and even npm install -g rust-just or pipx install rust-just. The README also points to pre-built binaries. After installation, you create a justfile in your project root. The syntax is simple: a recipe name followed by a colon, then indented commands. For example:

build: cargo build

test: cargo test

You run just build or just test. The README also shows a PowerShell example:

set shell := ["powershell.exe", "-c"]

hello: Write-Host "Hello, world!"

You can also list available recipes from the command line, which helps discoverability. The justfile can be invoked from any subdirectory, not just the one containing the file, which is a practical improvement over some task runners.

Limitations and Failure Modes

The main limitation is that just is not a build system. It does not track file timestamps or dependencies, so it cannot skip work that is already done. If you need incremental builds, you are better off with make or a dedicated build tool. Another limitation is the shell dependency. The README states that just should run on any system with a reasonable sh, but on Windows, you must have sh from Git for Windows, GitHub Desktop, or Cygwin, or you must configure a different shell. If you forget to set the shell on a Windows machine without sh, just will fail with an error. The documentation also notes that cmd.exe is 'quite fiddly,' so PowerShell is recommended. A third failure mode is the expression language and built-in functions. The README only mentions a rich expression language and many built-in functions, so users will need to consult the manual for advanced features, and there is a learning curve beyond the basic syntax. Finally, the README mentions that justfiles can be organized into multiple files using modules and imports, but the details are in the manual.

Alternative: make and Its Approach

The most direct alternative is make, which just explicitly draws inspiration from and aims to simplify. Make is a build system that tracks file dependencies and rebuilds targets only when prerequisites change. It uses a Makefile with rules like target: prerequisites, and it has automatic variables like $@ and $<. Just avoids these features, which reduces complexity but also removes the ability to express incremental builds. For example, in make you can write:

main.o: main.c cc -c main.c -o main.o

and make will only recompile if main.c is newer. Just has no equivalent; it always runs the recipe. This is a fundamental difference in approach: make is declarative about dependencies, while just is imperative about commands. The key takeaway is that if you need dependency tracking, make is the tool; if you just want to run commands, just is simpler.

Maintenance, Upgrade Cost, and License

The repository shows active development, with recent releases 1.57.0 (2026-07-19), 1.58.0 (2026-08-03) and 1.59.0 (2026-10-15). The last push was on 2026-11-02, which suggests a steady release cadence. Upgrading is typically a matter of installing a new binary or running your package manager's update command, such as brew upgrade just or cargo install just --force. The README notes that the online book reflects the latest release, while the GitHub README reflects the latest master, so there is a distinction between stable and development versions. The license is CC0-1.0, which is a public domain dedication. This means you can use, modify, and distribute the software without restriction, and you do not need to include attribution. This is permissive and removes legal friction for adoption, though it is not a substitute for legal advice on your specific use case. The project is written in Rust, which means it compiles to a single binary with no runtime dependencies beyond the shell, keeping deployment simple.

Editorial conclusion

Adopt just if you manage project-specific commands and want a tool that avoids make's build-system baggage, supports multiple shells, and offers static error checking. Skip it if you need a full build system with dependency tracking and incremental builds, or if your team is already invested in make or a task runner like Task. Before adopting, verify that your CI environment has the required shell (sh on Unix, or a configured alternative on Windows) and check the justfile syntax for any recipes that rely on make-specific features like automatic variables or pattern rules, which just does not support.

Frequently asked questions

What is just command runner?

just is a Rust command runner for saving and running project-specific commands. Commands are called recipes, they are stored in a file called a justfile, and the syntax is inspired by make. The README's cross-platform package table lists twelve package managers including Cargo, Homebrew, Nix, Conda, Snap, Spack, asdf, arkade, Cargo Binstall, and the npm, pipx and uv packages, which are all named rust-just.

How do I install Just?

Through a package manager, by downloading a pre-built binary, or with cargo install just. There is one prerequisite regardless of route: a reasonable sh must be available, including on Windows where it comes from Git for Windows, GitHub Desktop or Cygwin and must be on the PATH, unless you set the shell in your justfile instead.

What is a Justfile?

A justfile is the file that holds recipes, which are just's name for commands, in a syntax inspired by make. Because just is a command runner rather than a build system, recipes do not need to be declared phony. Recipes can be organised across multiple files using modules and imports, and just can be invoked from any subdirectory rather than only where the justfile lives.

What is the purpose of the Just tool?

The stated purpose is a handy way to save and run project-specific commands, avoiding much of make's complexity and idiosyncrasies. It resolves errors statically where possible, so unknown recipes and circular dependencies are reported before anything runs, and it reports syntax errors with their source context. It also loads .env files, lists recipes from the command line, and offers shell completion for most popular shells.

Official sources

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

Where developers are discussing it

Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 0 in the last 30 days; newest first.

Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/casey-just.svg)](https://hysenlabs.com/projects/casey-just)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/casey-just.svg)](https://hysenlabs.com/projects/casey-just)

Was this useful?