---
obj: application
website: https://just.systems/
repo: https://github.com/casey/just
---
# just
`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`:

![Screenshot][Screenshot]

You can then run them with `just RECIPE`:
```shell
$ just test-all
cc *.c -o main
./test --all
Yay, all your tests passed!
```

## Usage
Initialize new justfile:
```shell
just --init
```

Print what just would do without doing it:
```shell
just --dry-run
```

List available recipes and their arguments:
```shell
just -l
just --list
```

List names of variables:
```shell
just --variables
```

### Options
| Option                                        | Description                                                                  |
| --------------------------------------------- | ---------------------------------------------------------------------------- |
| `--dotenv-filename <DOTENV-FILENAME>`         | Search for environment file named \<DOTENV-FILENAME> instead of `.env`       |
| `--dotenv-path <DOTENV-PATH>`                 | Load environment file at \<DOTENV-PATH> instead of searching for one         |
| `-f, --justfile <JUSTFILE>`                   | Use \<JUSTFILE> as justfile                                                  |
| `--list-heading <TEXT>`                       | Print \<TEXT> before list                                                    |
| `--set <VARIABLE> <VALUE>`                    | Override \<VARIABLE> with \<VALUE>                                           |
| `-d, --working-directory <WORKING-DIRECTORY>` | Use \<WORKING-DIRECTORY> as working directory. `--justfile` must also be set | 

## Quick Start
Create a file named `justfile` in the root of your project with the following contents:
```
recipe-name:
	echo 'This is a recipe!'
	
# this is a comment
another-recipe:
	@echo 'This is another recipe.'
```

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`:
```shell
$ just
echo 'This is a recipe!'
This is a recipe!
```

One or more arguments specify the recipe(s) to run:
```shell
$ just another-recipe
This is another recipe.
```

`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:
```
publish:
	cargo test   # tests passed, time to publish!
	cargo publish
```

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

```
build:
	cc main.c foo.c bar.c -o main

test: build
	./test
	
sloc:
	@echo "`wc -l *.c` lines of code"
```

```shell
$ just test
cc main.c foo.c bar.c -o main
./test
testing… all tests passed!`
```

Recipes without dependencies will run in the order they’re given on the command line:
```shell
$ just build sloc
cc main.c foo.c bar.c -o main
1337 lines of code
```

## Features
### Default Recipe
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:
```
test:
	cargo test
```

You can also use dependencies to run multiple recipes by default:
```
default: lint build test

build:
	echo Building
	
test:
	echo Testing

lint:
	echo Linting
```

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:
```
default:
	@just --list
```

### Listing Available Recipes
Recipes can be listed in alphabetical order with `just --list`:
```shell
$ just --list
Available recipes:
    build
    test
    deploy
    lint
```

`just --summary` is more concise:
```shell
$ just --summary
build test deploy lint
```

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

> Note that you may need to add `--justfile {{justfile()}}` to the line above above. Without it, if you executed `just -f /some/distant/justfile -d .` or `just -f ./non-standard-justfile`, the plain `just --list` inside the recipe would not necessarily use the file you provided. It would try to find a justfile in your current path, maybe even resulting in a `No justfile found` error.

The heading text can be customized with `--list-heading`:
```shell
$ just --list --list-heading $'Cool stuff…\n'
Cool stuff…
    test
    build
```

### Aliases
Aliases allow recipes to be invoked with alternative names:
```just
alias b := build

build:
  echo 'Building!'
```

```shell
$ just b
build
echo 'Building!'
Building!
```

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

For example:
```just
set shell := ["zsh", "-cu"]

foo:
  # this line will be run as `zsh -cu 'ls **/*.txt'`
  ls **/*.txt
```

#### Table of Settings
| Name                      | Value              | Default | Description                                                                                   |
| ------------------------- | ------------------ | ------- | --------------------------------------------------------------------------------------------- |
| `allow-duplicate-recipes` | boolean            | `false` | Allow recipes appearing later in a `justfile` to override earlier recipes with the same name. |
| `dotenv-filename`         | string             | -       | Load a `.env` file with a custom name, if present.                                            |
| `dotenv-load`             | boolean            | `false` | Load a `.env` file, if present.                                                               |
| `dotenv-path`             | string             | -       | Load a `.env` file from a custom path, if present. Overrides `dotenv-filename`.               |
| `export`                  | boolean            | `false` | Export all variables as [environment variables](../../linux/Environment%20Variables.md).                                                |
| `fallback`                | boolean            | `false` | Search `justfile` in parent directory if the first recipe on the command line is not found.   |
| `ignore-comments`         | boolean            | `false` | Ignore recipe lines beginning with `#`.                                                       |
| `positional-arguments`    | boolean            | `false` | Pass positional arguments.                                                                    |
| `shell`                   | `[COMMAND, ARGS…]` | -       | Set the command used to invoke recipes and evaluate backticks.                                |
| `tempdir`                 | string             | -       | Create temporary directories in `tempdir` instead of the system default temporary directory.  |
| `windows-powershell`      | boolean            | `false` | Use PowerShell on [Windows](../../windows/Windows.md) as default [shell](Shell.md). (Deprecated. Use `windows-shell` instead.         |
| `windows-shell`           | `[COMMAND, ARGS…]` | -       | Set the command used to invoke recipes and evaluate backticks.                                |

#### Dotenv Settings
If `dotenv-load`, `dotenv-filename` or `dotenv-path` is set, `just` will load [environment variables](../../linux/Environment%20Variables.md) 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](../../linux/Environment%20Variables.md), not `just` variables, and so must be accessed using `$VARIABLE_NAME` in recipes and backticks.

For example, if your `.env` file contains:
```shell
# a comment, will be ignored
DATABASE_ADDRESS=localhost:6379
SERVER_PORT=1337
```

And your `justfile` contains:
```just
set dotenv-load

serve:
  @echo "Starting server with database $DATABASE_ADDRESS on port $SERVER_PORT…"
  ./server --database $DATABASE_ADDRESS --port $SERVER_PORT
```

`just serve` will output:
```shell
$ just serve
Starting server with database localhost:6379 on port 1337…
./server --database $DATABASE_ADDRESS --port $SERVER_PORT
```

#### Positional Arguments
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:
```just
set positional-arguments

@foo bar:
  echo $0
  echo $1
```

Will produce the following output:
```shell
$ just foo hello
foo
hello
```

When using an `sh`-compatible [shell](Shell.md), such as [`bash`](bash.md) or [`zsh`](zsh.md), `$@` 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:
```just
set positional-arguments

@test *args='':
  bash -c 'while (( "$#" )); do echo - $1; shift; done' -- "$@"
```

Running it with _two_ arguments:
```shell
$ just test foo "bar baz"
- foo
- bar baz
```

#### Shell
The `shell` setting controls the command used to invoke recipe lines and backticks. Shebang recipes are unaffected.
```just
# use python3 to execute recipe lines and backticks
set shell := ["python3", "-c"]

# use print to capture result of evaluation
foos := `print("foo" * 4)`

foo:
  print("Snake snake snake snake.")
  print("{{foos}}")
```

`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.

### Documentation Comments
Comments immediately preceding a recipe will appear in `just --list`:
```just
# build stuff
build:
  ./bin/build

# test stuff
test:
  ./bin/test
```

```shell
$ just --list
Available recipes:
    build # build stuff
    test # test stuff
```

### Variables and Substitution
Variables, strings, concatenation, path joining, and substitution using `{{…}}` are supported:
```just
tmpdir  := `mktemp -d`
version := "0.2.7"
tardir  := tmpdir / "awesomesauce-" + version
tarball := tardir + ".tar.gz"

publish:
  rm -f {{tarball}}
  mkdir {{tardir}}
  cp README.md *.c {{tardir}}
  tar zcvf {{tarball}} {{tardir}}
  scp {{tarball}} me@server.com:release/
  rm -rf {{tarball}} {{tardir}}
```

#### Joining Paths
The `/` operator can be used to join two strings with a slash:
```just
foo := "a" / "b"
```

```
$ just --evaluate foo
a/b
```

Note that a `/` is added even if one is already present:
```just
foo := "a/"
bar := foo / "b"
```

```
$ just --evaluate bar
a//b
```

Absolute paths can also be constructed:
```just
foo := / "b"
```

```
$ just --evaluate foo
/b
```

#### Escaping `{{`
To write a recipe containing `{{`, use `{{{{`:
```just
braces:
  echo 'I {{{{LOVE}} curly braces!'
```

(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:
```just
braces:
  echo '{{'I {{LOVE}} curly braces!'}}'
```

Yet another option is to use `{{ "{{" }}`:
```just
braces:
  echo 'I {{ "{{" }}LOVE}} curly braces!'
```

### Ignoring Errors
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
foo:
  -cat foo
  echo 'Done!'
```

```shell
$ just foo
cat foo
cat: foo: No such file or directory
echo 'Done!'
Done!
```

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

#### System Information
- `arch()` — Instruction set architecture. Possible values are: `"aarch64"`, `"arm"`, `"asmjs"`, `"hexagon"`, `"mips"`, `"msp430"`, `"powerpc"`, `"powerpc64"`, `"s390x"`, `"sparc"`, `"wasm32"`, `"x86"`, `"x86_64"`, and `"xcore"`.
- `num_cpus()` - Number of logical CPUs.
- `os()` — Operating system. Possible values are: `"android"`, `"bitrig"`, `"dragonfly"`, `"emscripten"`, `"freebsd"`, `"haiku"`, `"ios"`, `"linux"`, `"macos"`, `"netbsd"`, `"openbsd"`, `"solaris"`, and `"windows"`.
- `os_family()` — Operating system family; possible values are: `"unix"` and `"windows"`.

For example:
```just
system-info:
  @echo "This is an {{arch()}} machine".
```

```shell
$ just system-info
This is an x86_64 machine
```

#### [Environment Variables](../../linux/Environment%20Variables.md)
- `env_var(key)` — Retrieves the environment variable with name `key`, aborting if it is not present.

```just
home_dir := env_var('HOME')

test:
  echo "{{home_dir}}"
```

```shell
$ just
/home/user1
```

- `env_var_or_default(key, default)` — Retrieves the environment variable with name `key`, returning `default` if it is not present.
- `env(key)` — Alias for `env_var(key)`.
- `env(key, default)` — Alias for `env_var_or_default(key, default)`.

#### Invocation Directory
- `invocation_directory()` - Retrieves the absolute path to the current directory when `just` was invoked.

For example, to call `rustfmt` on files just under the "current directory" (from the user/invoker's perspective), use the following rule:
```just
rustfmt:
  find {{invocation_directory()}} -name \*.rs -exec rustfmt {} \;
```

Alternatively, if your command needs to be run from the current directory, you could use (e.g.):
```just
build:
  cd {{invocation_directory()}}; ./some_script_that_needs_to_be_run_from_here
```

#### Justfile and Justfile Directory
- `justfile()` - Retrieves the path of the current `justfile`.
- `justfile_directory()` - Retrieves the path of the parent directory of the current `justfile`.

For example, to run a command relative to the location of the current `justfile`:
```just
script:
  ./{{justfile_directory()}}/scripts/some_script
```

#### Just Executable
- `just_executable()` - Absolute path to the `just` executable.

For example:
```just
executable:
  @echo The executable is at: {{just_executable()}}
```

```shell
$ just
The executable is at: /bin/just
```

#### String Manipulation
- `quote(s)` - Replace all single quotes with `'\''` and prepend and append single quotes to `s`. This is sufficient to escape special characters for many shells, including most Bourne [shell](Shell.md) descendants.
- `replace(s, from, to)` - Replace all occurrences of `from` in `s` to `to`.
- `replace_regex(s, regex, replacement)` - Replace all occurrences of `regex` in `s` to `replacement`. Regular expressions are provided by the [Rust `regex` crate](https://docs.rs/regex/latest/regex/). See the [syntax documentation](https://docs.rs/regex/latest/regex/#syntax) for usage examples. Capture groups are supported. The `replacement` string uses [Replacement string syntax](https://docs.rs/regex/latest/regex/struct.Regex.html#replacement-string-syntax).
- `trim(s)` - Remove leading and trailing whitespace from `s`.
- `trim_end(s)` - Remove trailing whitespace from `s`.
- `trim_end_match(s, pat)` - Remove suffix of `s` matching `pat`.
- `trim_end_matches(s, pat)` - Repeatedly remove suffixes of `s` matching `pat`.
- `trim_start(s)` - Remove leading whitespace from `s`.
- `trim_start_match(s, pat)` - Remove prefix of `s` matching `pat`.
- `trim_start_matches(s, pat)` - Repeatedly remove prefixes of `s` matching `pat`.

#### Case Conversion
- `capitalize(s)` - Convert first character of `s` to uppercase and the rest to lowercase.
- `kebabcase(s)` - Convert `s` to `kebab-case`.
- `lowercamelcase(s)` - Convert `s` to `lowerCamelCase`.
- `lowercase(s)` - Convert `s` to lowercase.
- `shoutykebabcase(s)` - Convert `s` to `SHOUTY-KEBAB-CASE`.
- `shoutysnakecase(s)` - Convert `s` to `SHOUTY_SNAKE_CASE`.
- `snakecase(s)` - Convert `s` to `snake_case`.
- `titlecase(s)` - Convert `s` to `Title Case`.
- `uppercamelcase(s)` - Convert `s` to `UpperCamelCase`.
- `uppercase(s)` - Convert `s` to uppercase.

#### Path Manipulation
##### Fallible
- `absolute_path(path)` - Absolute path to relative `path` in the working directory. `absolute_path("./bar.txt")` in directory `/foo` is `/foo/bar.txt`.
- `extension(path)` - Extension of `path`. `extension("/foo/bar.txt")` is `txt`.
- `file_name(path)` - File name of `path` with any leading directory components removed. `file_name("/foo/bar.txt")` is `bar.txt`.
- `file_stem(path)` - File name of `path` without extension. `file_stem("/foo/bar.txt")` is `bar`.
- `parent_directory(path)` - Parent directory of `path`. `parent_directory("/foo/bar.txt")` is `/foo`.
- `without_extension(path)` - `path` without extension. `without_extension("/foo/bar.txt")` is `/foo/bar`.

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

##### Infallible
- `clean(path)` - Simplify `path` by removing extra path separators, intermediate `.` components, and `..` where possible. `clean("foo//bar")` is `foo/bar`, `clean("foo/..")` is `.`, `clean("foo/./bar")` is `foo/bar`.
- `join(a, b…)` - _This function uses `/` on Unix and `\` on [Windows](../../windows/Windows.md), which can be lead to unwanted behavior. The `/` operator, e.g., `a / b`, which always uses `/`, should be considered as a replacement unless `\`s are specifically desired on [Windows](../../windows/Windows.md)._ Join path `a` with path `b`. `join("foo/bar", "baz")` is `foo/bar/baz`. Accepts two or more arguments.

#### Filesystem Access
- `path_exists(path)` - Returns `true` if the path points at an existing entity and `false` otherwise. Traverses symbolic links, and returns `false` if the path is inaccessible or points to a broken symlink.

#### Error Reporting
- `error(message)` - Abort execution and report error `message` to user.

#### [UUID](../../linux/UUID.md) and Hash Generation
- `sha256(string)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of `string` as a hexadecimal string.
- `sha256_file(path)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of the file at `path` as a hexadecimal string.
- `uuid()` - Return a randomly generated [UUID](../../linux/UUID.md).

### Recipe Attributes
Recipes may be annotated with attributes that change their behavior.

| Name                | Description                                     |
| ------------------- | ----------------------------------------------- |
| `[no-cd]`           | Don't change directory before executing recipe. |
| `[no-exit-message]` | Don't print an error message if recipe fails.   |
| `[linux]`           | Enable recipe on [Linux](../../linux/Linux.md).                         |
| `[macos]`           | Enable recipe on [MacOS](../../macos/macOS.md).                         |
| `[unix]`            | Enable recipe on Unixes. (Includes [MacOS](../../macos/macOS.md)).      |
| `[windows]`         | Enable recipe on [Windows](../../windows/Windows.md).                       |
| `[private]`1        | See Private Recipes.                            | 

A recipe can have multiple attributes, either on multiple lines:
```just
[no-cd]
[private]
foo:
    echo "foo"
```

Or separated by commas on a single line:
```just
[no-cd, private]
foo:
    echo "foo"
```

#### Enabling and Disabling Recipes
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 `justfile`s 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
[unix]
run:
  cc main.c
  ./a.out

[windows]
run:
  cl main.c
  main.exe
```

#### Disabling Changing Directory
`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:
```just
[no-cd]
commit file:
  git add {{file}}
  git commit
```

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`.

### Command Evaluation Using Backticks
Backticks can be used to store the result of commands:
```just
localhost := `dumpinterfaces | cut -d: -f2 | sed 's/\/.*//' | sed 's/ //g'`

serve:
  ./serve {{localhost}} 8080
```

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>

### Conditional Expressions
`if`/`else` expressions evaluate different branches depending on if two expressions evaluate to the same value:
```just
foo := if "2" == "2" { "Good!" } else { "1984" }

bar:
  @echo "{{foo}}"
```

```shell
$ just bar
Good!
```

It is also possible to test for inequality:
```just
foo := if "hello" != "goodbye" { "xyz" } else { "abc" }

bar:
  @echo {{foo}}
```

```shell
$ just bar
xyz
```

And match against regular expressions:
```just
foo := if "hello" =~ 'hel+o' { "match" } else { "mismatch" }

bar:
  @echo {{foo}}
```

```shell
$ just bar
match
```

Regular expressions are provided by the [regex crate](https://github.com/rust-lang/regex), whose syntax is documented on [docs.rs](https://docs.rs/regex/1.5.4/regex/#syntax). 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.
```just
foo := if env_var("RELEASE") == "true" { `get-something-from-release-database` } else { "dummy-value" }
```

Conditionals can be used inside of recipes:
```just
bar foo:
  echo {{ if foo == "bar" { "hello" } else { "goodbye" } }}
```

> Note the space after the final `}`! Without the space, the interpolation will be prematurely closed.

Multiple conditionals can be chained:
```just
foo := if "hello" == "goodbye" {
  "xyz"
} else if "a" == "a" {
  "abc"
} else {
  "123"
}

bar:
  @echo {{foo}}
```

```shell
$ just bar
abc
```

### Stopping execution with error
Execution can be halted with the `error` function. For example:
```just
foo := if "hello" == "goodbye" {
  "xyz"
} else if "a" == "b" {
  "abc"
} else {
  error("123")
}
```

Which produce the following error when run:
```
error: Call to function `error` failed: 123
   |
16 |   error("123")
```

### Setting Variables from the Command Line
Variables can be overridden from the command line.
```just
os := "linux"

test: build
  ./test --test {{os}}

build:
  ./build {{os}}
```

```shell
$ just
./build linux
./test --test linux
```

Any number of arguments of the form `NAME=VALUE` can be passed before recipes:
```shell
$ just os=plan9
./build plan9
./test --test plan9
```

Or you can use the `--set` flag:
```shell
$ just --set os bsd
./build bsd
./test --test bsd
```

### Getting and Setting [Environment Variables](../../linux/Environment%20Variables.md)
#### Exporting `just` Variables
Assignments prefixed with the `export` keyword will be exported to recipes as [environment variables](../../linux/Environment%20Variables.md):
```just
export RUST_BACKTRACE := "1"

test:
  # will print a stack trace if it crashes
  cargo test
```

Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
```just
test $RUST_BACKTRACE="1":
  # will print a stack trace if it crashes
  cargo test
```

Exported variables and parameters are not exported to backticks in the same scope.
```just
export WORLD := "world"
# This backtick will fail with "WORLD: unbound variable"
BAR := `echo hello $WORLD`
```

```just
# Running `just a foo` will fail with "A: unbound variable"
a $A $B=`echo $A`:
  echo $A $B
```

When `export` is set, all `just` variables are exported as [environment variables](../../linux/Environment%20Variables.md).

#### Getting [Environment Variables](../../linux/Environment%20Variables.md) from the environment
[Environment variables](../../linux/Environment%20Variables.md) from the environment are passed automatically to the recipes.

```just
print_home_folder:
  echo "HOME is: '${HOME}'"
```

```shell
$ just
HOME is '/home/myuser'
```

#### Setting `just` Variables from [Environment Variables](../../linux/Environment%20Variables.md)
[Environment variables](../../linux/Environment%20Variables.md) can be propagated to `just` variables using the functions `env_var()` and `env_var_or_default()`. 

### Recipe Parameters
Recipes may have parameters. Here recipe `build` has a parameter called `target`:
```just
build target:
  @echo 'Building {{target}}…'
  cd {{target}} && make
```

To pass arguments on the command line, put them after the recipe name:
```shell
$ just build my-awesome-project
Building my-awesome-project…
cd my-awesome-project && make
```

To pass arguments to a dependency, put the dependency in parentheses along with the arguments:
```just
default: (build "main")

build target:
  @echo 'Building {{target}}…'
  cd {{target}} && make
```

Variables can also be passed as arguments to dependencies:
```just
target := "main"

_build version:
  @echo 'Building {{version}}…'
  cd {{version}} && make

build: (_build target)
```

A command's arguments can be passed to dependency by putting the dependency in parentheses along with the arguments:
```just
build target:
  @echo "Building {{target}}…"

push target: (build target)
  @echo 'Pushing {{target}}…'
```

Parameters may have default values:
```just
default := 'all'

test target tests=default:
  @echo 'Testing {{target}}:{{tests}}…'
  ./test --tests {{tests}} {{target}}
```

Parameters with default values may be omitted:
```shell
$ just test server
Testing server:all…
./test --tests all server
```

Or supplied:
```shell
$ just test server unit
Testing server:unit…
./test --tests unit server
```

Default values may be arbitrary expressions, but concatenations or path joins must be parenthesized:
```just
arch := "wasm"

test triple=(arch + "-unknown-unknown") input=(arch / "input.dat"):
  ./test {{triple}}
```

The last parameter of a recipe may be variadic, indicated with either a `+` or a `*` before the argument name:
```just
backup +FILES:
  scp {{FILES}} me@server.com:
```

Variadic parameters prefixed with `+` accept _one or more_ arguments and expand to a string containing those arguments separated by spaces:
```shell
$ just backup FAQ.md GRAMMAR.md
scp FAQ.md GRAMMAR.md me@server.com:
FAQ.md                  100% 1831     1.8KB/s   00:00
GRAMMAR.md              100% 1666     1.6KB/s   00:00
```

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:
```just
commit MESSAGE *FLAGS:
  git commit {{FLAGS}} -m "{{MESSAGE}}"
```

Variadic parameters can be assigned default values. These are overridden by arguments passed on the command line:
```just
test +FLAGS='-q':
  cargo test {{FLAGS}}
```

`{{…}}` substitutions may need to be quoted if they contain spaces. For example, if you have the following recipe:
```just
search QUERY:
  lynx https://www.google.com/?q={{QUERY}}
```

And you type:
```shell
$ just search "cat toupee"
```

`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:
```just
search QUERY:
  lynx 'https://www.google.com/?q={{QUERY}}'
```

Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
```just
foo $bar:
  echo $bar
```

### Running Recipes at the End of a Recipe
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 `&&`:
```just
a:
  echo 'A!'

b: a && c d
  echo 'B!'

c:
  echo 'C!'

d:
  echo 'D!'
```

…running _b_ prints:
```shell
$ just b
echo 'A!'
A!
echo 'B!'
B!
echo 'C!'
C!
echo 'D!'
D!
```

### Running Recipes in the Middle of a Recipe
`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`:
```just
a:
  echo 'A!'

b: a
  echo 'B start!'
  just c
  echo 'B end!'

c:
  echo 'C!'
```

…running _b_ prints:
```shell
$ just b
echo 'A!'
A!
echo 'B start!'
B start!
echo 'C!'
C!
echo 'B end!'
B end!
```

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.

### Writing Recipes in Other Languages
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:
```just
polyglot: python js perl sh ruby nu

python:
  #!/usr/bin/env python3
  print('Hello from python!')

js:
  #!/usr/bin/env node
  console.log('Greetings from JavaScript!')

perl:
  #!/usr/bin/env perl
  print "Larry Wall says Hi!\n";

sh:
  #!/usr/bin/env sh
  hello='Yo'
  echo "$hello from a shell script!"

nu:
  #!/usr/bin/env nu
  let hello = 'Hola'
  echo $"($hello) from a nushell script!"

ruby:
  #!/usr/bin/env ruby
  puts "Hello from ruby!"
```

```shell
$ just polyglot
Hello from python!
Greetings from JavaScript!
Larry Wall says Hi!
Yo from a shell script!
Hola from a nushell script!
Hello from ruby!
```

On Unix-like operating systems, including [Linux](../../linux/Linux.md) and [MacOS](../../macos/macOS.md), 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](../../windows/Windows.md) does not support shebang lines. On [Windows](../../windows/Windows.md), `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.

### Multi-Line Constructs
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`:
```makefile
conditional:
  if true; then
    echo 'True!'
  fi
```

The extra leading whitespace before the second line of the `conditional` recipe will produce a parse error:
```shell
$ just conditional
error: Recipe line has extra leading whitespace
  |
3 |         echo 'True!'
  |     ^^^^^^^^^^^^^^^^
```

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.

#### `if` statements
```just
conditional:
  if true; then echo 'True!'; fi
```

```just
conditional:
  if true; then \
    echo 'True!'; \
  fi
```

```just
conditional:
  #!/usr/bin/env sh
  if true; then
    echo 'True!'
  fi
```

#### `for` loops
```just
for:
  for file in `ls .`; do echo $file; done
```

```just
for:
  for file in `ls .`; do \
    echo $file; \
  done
```

```just
for:
  #!/usr/bin/env sh
  for file in `ls .`; do
    echo $file
  done
```

#### `while` loops
```just
while:
  while `server-is-dead`; do ping -c 1 server; done
```

```just
while:
  while `server-is-dead`; do \
    ping -c 1 server; \
  done
```

```just
while:
  #!/usr/bin/env sh
  while `server-is-dead`; do
    ping -c 1 server
  done
```

### Private Recipes
Recipes and aliases whose name starts with a `_` are omitted from `just --list`:
```just
test: _test-helper
  ./bin/test

_test-helper:
  ./bin/super-secret-test-helper-stuff
```

```shell
$ just --list
Available recipes:
    test
```

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

[private]
alias b := bar

bar:
```

```shell
$ just --list
Available recipes:
    bar
```

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

[Screenshot]: data:image/webp;base64,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