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

recipe-name:
  echo 'This is a 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`:

```console
$ just
echo 'This is a recipe!'
This is a recipe!

$ just another-recipe
This is another recipe.

publish:
  cargo test
  # tests passed, time to publish!
  cargo publish

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

test: build
  ./test

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

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

$ just build sloc
cc main.c foo.c bar.c -o main
1337 lines of code

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

mod foo

baz: foo::bar

test:
  cargo test

default: lint build test

build:
  echo Building…

test:
  echo Testing…

lint:
  echo Linting…

default:
  just --list

$ just --list
Available recipes:
    build
    test
    deploy
    lint

$ cat justfile
mod foo
$ cat foo.just
mod bar
$ cat bar.just
baz:
$ just --list foo bar
Available recipes:
    baz
$ just --list foo::bar
Available recipes:
    baz

$ just --summary
build test deploy lint

test:
  echo 'Testing!'

build:
  echo 'Building!'

$ just --list --unsorted
Available recipes:
    test
    build

$ just --summary --unsorted
test build

default:
  @just --list

$ just --list --list-heading $'Cool stuff…\n'
Cool stuff…
    test
    build

$ just --list --list-prefix ····
Available recipes:
····test
····build

$ just --list --list-heading ''
    test
    build

build:
  make web

serve:
  python3 -m http.server -d out 8000

$ just build serve
make web
python3 -m http.server -d out 8000

build project:
  make {{project}}

serve:
  python3 -m http.server -d out 8000

$ just build serve
make: *** No rule to make target `serve'.  Stop.

$ just --one build serve
error: Expected 1 command-line recipe invocation but found 2.

@foo:
  pwd

[no-cd]
@bar:
  pwd

$ cd subdir
$ just foo
/
$ just bar
/subdir

set working-directory := 'bar'

@foo:
  pwd

$ pwd
/home/bob
$ just foo
/home/bob/bar

[working-directory: 'bar']
@foo:
  pwd

$ pwd
/home/bob
$ just foo
/home/bob/bar

alias b := build

build:
  echo 'Building!'

$ just b
echo 'Building!'
Building!

mod foo

alias baz := foo::bar

set shell := ["zsh", "-cu"]

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

set NAME

set NAME := true

set allow-duplicate-recipes

@foo:
  echo foo

@foo:
  echo bar

$ just foo
bar

set allow-duplicate-variables

a := "foo"
a := "bar"

@foo:
  echo {{a}}

$ just foo
bar

undefined

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
Starting server with database localhost:6379 on port 1337…
./server --database $DATABASE_ADDRESS --port $SERVER_PORT

set export

a := "hello"

@foo b:
  echo $a
  echo $b

$ just foo goodbye
hello
goodbye

set positional-arguments

@foo bar:
  echo $0
  echo $1

$ just foo hello
foo
hello

set positional-arguments

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

$ just test foo "bar baz"
- foo
- bar baz

[positional-arguments]
@foo bar:
  echo $0
  echo $1

set shell := ['pwsh.exe', '-CommandWithArgs']
set positional-arguments

print-args a b c:
  Write-Output @($args[1..($args.Count - 1)])

undefined

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

set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]

hello:
  Write-Host "Hello, world!"

set windows-powershell := true

hello:
  Write-Host "Hello, world!"

set shell := ["python3", "-c"]

set shell := ["bash", "-uc"]

set shell := ["zsh", "-uc"]

set shell := ["fish", "-c"]

set shell := ["nu", "-c"]

set shell := ['nu', '-m', 'light', '-c']

undefined

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

undefined

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

tmpdir  := `mktemp -d`
version := "0.2.7"
tardir  := tmpdir / "awesomesauce-" + version
tarball := tardir + ".tar.gz"
config  := quote(config_dir() / ".project-config")

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

foobar := 'foo' + 'bar'

foo := '' && 'goodbye'      # ''
bar := 'hello' && 'goodbye' # 'goodbye'

foo := '' || 'goodbye'      # 'goodbye'
bar := 'hello' || 'goodbye' # 'hello'

foo := "a" / "b"

$ just --evaluate foo
a/b

foo := "a/"
bar := foo / "b"

$ just --evaluate bar
a//b

foo := / "b"

$ just --evaluate foo
/b

braces:
  echo 'I {{{{LOVE}} curly braces!'

braces:
  echo '{{'I {{LOVE}} curly braces!'}}'

braces:
  echo 'I {{ "{{" }}LOVE}} curly braces!'

carriage-return   := "\r"
double-quote      := "\""
newline           := "\n"
no-newline        := "\
"
slash             := "\\"
tab               := "\t"
unicode-codepoint := "\u{1F916}"

$ just --evaluate
"arriage-return   := "
double-quote      := """
newline           := "
"
no-newline        := ""
slash             := "\"
tab               := "     "
unicode-codepoint := "🤖"

single := '
hello
'

double := "
goodbye
"

escapes := '\t\n\r\"\\'

$ just --evaluate
escapes := "\t\n\r\"\\"

undefined

Similar to unindented strings, indented double-quoted strings process escape
sequences, and indented single-quoted strings ignore escape sequences. Escape
sequence processing takes place after unindentation. The unindentation
algorithm does not take escape-sequence produced whitespace or newlines into
account.

foobar := x'~/$FOO/${BAR}'

name := "world"
message := f'Hello, {{name}}!'

foo := f'I {{{{LOVE} curly braces!'

foo:
  -cat foo
  echo 'Done!'

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

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

$ just system-info
This is an x86_64 machine

undefined

```just

undefined

home_dir := env('HOME')

test:
  echo "{{home_dir}}"

$ just
/home/user1

set unstable

foo := env('FOO', '') || 'DEFAULT_VALUE'

rustfmt:
  find {{invocation_directory()}} -name \*.rs -exec rustfmt {} \;

build:
  cd {{invocation_directory()}}; ./some_script_that_needs_to_be_run_from_here

script:
  {{justfile_directory()}}/scripts/some_script

executable:
  @echo The executable is at: {{just_executable()}}

$ just
The executable is at: /bin/just

pid:
  @echo The process ID is: {{ just_pid() }}

$ just
The process ID is: 420