just is a handy way to save and run project-specific commands. Commands, called recipes, are stored in a file called justfile with syntax inspired by make:

You can then run them with just RECIPE:

Initialize new justfile:

Print what just would do without doing it:

List available recipes and their arguments:

List names of variables:

Create a file named justfile in the root of your project with the following contents:

When you invoke just it looks for file justfile in the current directory and upwards, so you can invoke it from any subdirectory of your project.

The search for a justfile is case insensitive, so any case, like Justfile, JUSTFILE, or JuStFiLe, will work. just will also look for files with the name .justfile, in case you’d like to hide a justfile.

Running just with no arguments runs the first recipe in the justfile:

One or more arguments specify the recipe(s) to run:

just prints each command to standard error before running it, which is why echo 'This is a recipe!' was printed. This is suppressed for lines starting with @, which is why echo 'This is another recipe.' was not printed.

Recipes stop running if a command fails. Here cargo publish will only run if cargo test succeeds:

Recipes can depend on other recipes. Here the test recipe depends on the build recipe, so build will run before test:

Recipes without dependencies will run in the order they’re given on the command line:

When just is invoked without a recipe, it runs the first recipe in the justfile. This recipe might be the most frequently run command in the project, like running the tests:

You can also use dependencies to run multiple recipes by default:

If no recipe makes sense as the default recipe, you can add a recipe to the beginning of your justfile that lists the available recipes:

Recipes can be listed in alphabetical order with just --list:

just --summary is more concise:

If you'd like just to default to listing the recipes in the justfile, you can use this as your default recipe:

The heading text can be customized with --list-heading:

Aliases allow recipes to be invoked with alternative names:

Settings control interpretation and execution. Each setting may be specified at most once, anywhere in the justfile.

For example:

If dotenv-load, dotenv-filename or dotenv-path is set, just will load environment variables from a file.

If dotenv-path is set, just will look for a file at the given path.

Otherwise, just looks for a file named .env by default, unless dotenv-filename set, in which case the value of dotenv-filename is used. This file can be located in the same directory as your justfile or in a parent directory.

The loaded variables are environment variables, not just variables, and so must be accessed using $VARIABLE_NAME in recipes and backticks.

For example, if your .env file contains:

And your justfile contains:

just serve will output:

If positional-arguments is true, recipe arguments will be passed as positional arguments to commands. For linewise recipes, argument $0 will be the name of the recipe.

For example, running this recipe:

Will produce the following output:

When using an sh-compatible shell, such as bash or zsh, $@ expands to the positional arguments given to the recipe, starting from one. When used within double quotes as "$@", arguments including whitespace will be passed on as if they were double-quoted. That is, "$@" is equivalent to "$1" "$2"… When there are no positional parameters, "$@" and $@ expand to nothing (i.e., they are removed).

This example recipe will print arguments one by one on separate lines:

Running it with two arguments:

The shell setting controls the command used to invoke recipe lines and backticks. Shebang recipes are unaffected.

just passes the command to be executed as an argument. Many shells will need an additional flag, often -c, to make them evaluate the first argument.

Comments immediately preceding a recipe will appear in just --list:

Variables, strings, concatenation, path joining, and substitution using {{…}} are supported:

The / operator can be used to join two strings with a slash:

Note that a / is added even if one is already present:

Absolute paths can also be constructed:

To write a recipe containing {{, use {{{{:

(An unmatched }} is ignored, so it doesn't need to be escaped.)

Another option is to put all the text you'd like to escape inside of an interpolation:

Yet another option is to use {{ "{{" }}:

Normally, if a command returns a non-zero exit status, execution will stop. To continue execution after a command, even if it fails, prefix the command with -:

just provides a few built-in functions that might be useful when writing recipes.

For example:

For example, to call rustfmt on files just under the "current directory" (from the user/invoker's perspective), use the following rule:

Alternatively, if your command needs to be run from the current directory, you could use (e.g.):

For example, to run a command relative to the location of the current justfile:

For example:

These functions can fail, for example if a path does not have an extension, which will halt execution.

Recipes may be annotated with attributes that change their behavior.

A recipe can have multiple attributes, either on multiple lines:

Or separated by commas on a single line:

The [linux], [macos], [unix], and [windows] attributes are configuration attributes. By default, recipes are always enabled. A recipe with one or more configuration attributes will only be enabled when one or more of those configurations is active.

This can be used to write justfiles that behave differently depending on which operating system they run on. The run recipe in this justfile will compile and run main.c, using a different C compiler and using the correct output binary name for that compiler depending on the operating system:

just normally executes recipes with the current directory set to the directory that contains the justfile. This can be disabled using the [no-cd] attribute. This can be used to create recipes which use paths relative to the invocation directory, or which operate on the current directory.

For example, this commit recipe:

Can be used with paths that are relative to the current directory, because [no-cd] prevents just from changing the current directory when executing commit.

Backticks can be used to store the result of commands:

Indented backticks, delimited by three backticks, are de-indented in the same manner as indented strings:

<pre><code>just

# This backtick evaluates the command `echo foo\necho bar\n`, which produces the value `foo\nbar\n`.

stuff := ``` echo foo echo bar

```

</code></pre>

if/else expressions evaluate different branches depending on if two expressions evaluate to the same value:

It is also possible to test for inequality:

And match against regular expressions:

Regular expressions are provided by the regex crate, whose syntax is documented on docs.rs. Since regular expressions commonly use backslash escape sequences, consider using single-quoted string literals, which will pass slashes to the regex parser unmolested.

Conditional expressions short-circuit, which means they only evaluate one of their branches. This can be used to make sure that backtick expressions don't run when they shouldn't.

Conditionals can be used inside of recipes:

Multiple conditionals can be chained:

Execution can be halted with the error function. For example:

Which produce the following error when run:

Variables can be overridden from the command line.

Any number of arguments of the form NAME=VALUE can be passed before recipes:

Or you can use the --set flag:

Assignments prefixed with the export keyword will be exported to recipes as environment variables:

Parameters prefixed with a $ will be exported as environment variables:

Exported variables and parameters are not exported to backticks in the same scope.

When export is set, all just variables are exported as environment variables.

Environment variables from the environment are passed automatically to the recipes.

Environment variables can be propagated to just variables using the functions env_var() and env_var_or_default().

Recipes may have parameters. Here recipe build has a parameter called target:

To pass arguments on the command line, put them after the recipe name:

To pass arguments to a dependency, put the dependency in parentheses along with the arguments:

Variables can also be passed as arguments to dependencies:

A command's arguments can be passed to dependency by putting the dependency in parentheses along with the arguments:

Parameters may have default values:

Parameters with default values may be omitted:

Or supplied:

Default values may be arbitrary expressions, but concatenations or path joins must be parenthesized:

The last parameter of a recipe may be variadic, indicated with either a + or a * before the argument name:

Variadic parameters prefixed with + accept one or more arguments and expand to a string containing those arguments separated by spaces:

Variadic parameters prefixed with * accept zero or more arguments and expand to a string containing those arguments separated by spaces, or an empty string if no arguments are present:

Variadic parameters can be assigned default values. These are overridden by arguments passed on the command line:

{{…}} substitutions may need to be quoted if they contain spaces. For example, if you have the following recipe:

And you type:

just will run the command lynx https://www.google.com/?q=cat toupee, which will get parsed by sh as lynx, https://www.google.com/?q=cat, and toupee, and not the intended lynx and https://www.google.com/?q=cat toupee.

You can fix this by adding quotes:

Parameters prefixed with a $ will be exported as environment variables:

Normal dependencies of a recipes always run before a recipe starts. That is to say, the dependee always runs before the depender. These dependencies are called "prior dependencies".

A recipe can also have subsequent dependencies, which run after the recipe and are introduced with an &&:

…running b prints:

just doesn't support running recipes in the middle of another recipe, but you can call just recursively in the middle of a recipe. Given the following justfile:

…running b prints:

This has limitations, since recipe c is run with an entirely new invocation of just: Assignments will be recalculated, dependencies might run twice, and command line arguments will not be propagated to the child just process.

Recipes that start with #! are called shebang recipes, and are executed by saving the recipe body to a file and running it. This lets you write recipes in different languages:

On Unix-like operating systems, including Linux and MacOS, shebang recipes are executed by saving the recipe body to a file in a temporary directory, marking the file as executable, and executing it. The OS then parses the shebang line into a command line and invokes it, including the path to the file. For example, if a recipe starts with #!/usr/bin/env bash, the final command that the OS runs will be something like /usr/bin/env bash /tmp/PATH_TO_SAVED_RECIPE_BODY. Keep in mind that different operating systems split shebang lines differently.

Windows does not support shebang lines. On Windows, just splits the shebang line into a command and arguments, saves the recipe body to a file, and invokes the split command and arguments, adding the path to the saved recipe body as the final argument.

Recipes without an initial shebang are evaluated and run line-by-line, which means that multi-line constructs probably won't do what you want.

For example, with the following justfile:

The extra leading whitespace before the second line of the conditional recipe will produce a parse error:

To work around this, you can write conditionals on one line, escape newlines with slashes, or add a shebang to your recipe. Some examples of multi-line constructs are provided for reference.

Recipes and aliases whose name starts with a _ are omitted from just --list:

The [private] attribute may also be used to hide recipes or aliases without needing to change the name:

This is useful for helper recipes which are only meant to be used as dependencies of other recipes.