Repository files navigation

just is a handy way to save and run project-specific commands.

This readme is also available as abook.

(中文文档在这里,快看过来!)

Commands, called recipes, are stored in a file calledjustfile with syntaxinspired bymake:

You can then run them withjust RECIPE:

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

just has a ton of useful features, and many improvements overmake:

• just is a command runner, not a build system, so it avoids much ofmake's complexity and idiosyncrasies.No need for.PHONY recipes!

• Linux, MacOS, and Windows are supported with no additional dependencies.(Although if your system doesn't have ansh, you'll need tochoose a different shell.)

• Errors are specific and informative, and syntax errors are reported alongwith their source context.

• Recipes can acceptcommand line arguments.

• Wherever possible, errors are resolved statically. Unknown recipes andcircular dependencies are reported before anything runs.

• justloads.env files, making it easy to populateenvironment variables.

• Recipes can belisted from the command line.

• Command line completion scripts areavailable for most popular shells.

• Recipes can be written inarbitrary languages, like Python or NodeJS.

• just can be invoked from any subdirectory, not just the directory thatcontains thejustfile.

• Andmuch more!

If you need help withjust please feel free to open an issue or ping me onDiscord. Feature requests and bug reports arealways welcome!

just should run on any system with a reasonablesh, including Linux, MacOS,and the BSDs.

On Windows,just works with thesh provided byGit for Windows,GitHub Desktop, orCygwin.

If you'd rather not installsh, you can use theshell setting to use theshell of your choice.

Like PowerShell:

# use PowerShell instead of sh:setshell:= ["powershell.exe","-c"]hello:  Write-Host"Hello, world!"

…orcmd.exe:

# use cmd.exe instead of sh:setshell:= ["cmd.exe","/c"]list:  dir

You can also set the shell using command-line arguments. For example, to usePowerShell, launchjust with--shell powershell.exe --shell-arg -c.

(PowerShell is installed by default on Windows 7 SP1 and Windows Server 2008 R2S1 and later, andcmd.exe is quite fiddly, so PowerShell is recommended formost Windows users.)

Pre-built binaries for Linux, MacOS, and Windows can be found onthe releases page.

You can use the following command on Linux, MacOS, or Windows to download thelatest release, just replaceDEST with the directory where you'd like to putjust:

curl --proto'=https' --tlsv1.2 -sSf https://just.systems/install.sh| bash -s -- --to DEST

For example, to installjust to~/bin:

# create ~/binmkdir -p~/bin# download and extract just to ~/bin/justcurl --proto'=https' --tlsv1.2 -sSf https://just.systems/install.sh| bash -s -- --to~/bin# add `~/bin` to the paths that your shell searches for executables# this line should be added to your shells initialization file,# e.g. `~/.bashrc` or `~/.zshrc`export PATH="$PATH:$HOME/bin"# just should now be executablejust --help

Note thatinstall.sh may fail on GitHub Actions, or in other environmentswhere many machines share IP addresses.install.sh calls GitHub APIs in orderto determine the latest version ofjust to install, and those API calls arerate-limited on a per-IP basis. To makeinstall.sh more reliable in suchcircumstances, pass a specific tag to install with--tag.

just can be installed on GitHub Actions in a few ways.

Using package managers pre-installed on GitHub Actions runners on MacOS withbrew install just, and on Windows withchoco install just.

Withextractions/setup-just:

-uses:extractions/setup-just@v1with:just-version:1.5.0# optional semver specification, otherwise latest

Or withtaiki-e/install-action:

-uses:taiki-e/install-action@just

AnRSS feed ofjust releases is availablehere.

just-install can be used to automateinstallation ofjust in Node.js applications.

just is a great, more robust alternative to npm scripts. If you want toincludejust in the dependencies of a Node.js application,just-installwill install a local, platform-specific binary as part of thenpm installcommand. This removes the need for every developer to installjustindependently using one of the processes mentioned above. After installation,thejust command will work in npm scripts or with npx. It's great for teamswho want to make the set up process for their project as easy as possible.

For more information, see thejust-install README file.

With the release of version 1.0,just features a strong commitment tobackwards compatibility and stability.

Future releases will not introduce backwards incompatible changes that makeexistingjustfiles stop working, or break working invocations of thecommand-line interface.

This does not, however, preclude fixing outright bugs, even if doing so mightbreakjustfiles that rely on their behavior.

There will never be ajust 2.0. Any desirable backwards-incompatible changeswill be opt-in on a per-justfile basis, so users may migrate at theirleisure.

Features that aren't yet ready for stabilization are marked as unstable and maybe changed or removed at any time. Using unstable features produces an error bydefault, which can be suppressed with by passing the--unstable flag,set unstable, or setting the environment variableJUST_UNSTABLE, to anyvalue other thanfalse,0, or the empty string.

justfile syntax is close enough tomake that you may want to tell youreditor to usemake syntax highlighting forjust.

Thevim-just plugin provides syntaxhighlighting forjustfiles.

Install it with your favorite package manager, likePlug:

callplug#begin()Plug'NoahTheDuke/vim-just'callplug#end()

Or with Vim's built-in package support:

mkdir -p~/.vim/pack/vendor/startcd~/.vim/pack/vendor/startgit clone https://github.com/NoahTheDuke/vim-just.git

tree-sitter-just is anNvim Treesitter pluginfor Neovim.

Vim's built-in makefile syntax highlighting isn't perfect forjustfiles, butit's better than nothing. You can put the following in~/.vim/filetype.vim:

ifexists("did_load_filetypes")finishendifaugroupfiletypedetectauBufNewFile,BufReadjustfilesetfmakeaugroupEND

Or add the following to an individualjustfile to enablemake mode on aper-file basis:

# vim: set ft=make :

just-mode provides syntaxhighlighting and automatic indentation ofjustfiles. It is available onMELPA asjust-mode.

justl provides commands for executing andlisting recipes.

You can add the following to an individualjustfile to enablemake mode ona per-file basis:

# Local Variables:# mode: makefile# End:

An extension for VS Code isavailable here.

Unmaintained VS Code extensions includeskellock/vscode-just andsclu1034/vscode-just.

A plugin for JetBrains IDEs bylinux_china isavailable here.

Kakoune supportsjustfile syntax highlighting out of the box, thanks toTeddyDD.

Helix supportsjustfile syntax highlightingout-of-the-box since version 23.05.

TheJust package bynk9 withjust syntax and some other tools isavailable onPackageControl.

Micro supports Justfile syntax highlightingout of the box, thanks totomodachi94.

Feel free to send me the commands necessary to get syntax highlighting workingin your editor of choice so that I may include them here.

Seethe installation section for how to installjust on yourcomputer. Try runningjust --version to make sure that it's installedcorrectly.

For an overview of the syntax, check outthis cheatsheet.

Oncejust is installed and working, create a file namedjustfile in theroot of your project with the following contents:

recipe-name:  echo'This is a recipe!'# this is a commentanother-recipe:@echo'This is another recipe.'

When you invokejust it looks for filejustfile in the current directoryand upwards, so you can invoke it from any subdirectory of your project.

The search for ajustfile is case insensitive, so any case, likeJustfile,JUSTFILE, orJuStFiLe, will work.just will also look for files with thename.justfile, in case you'd like to hide ajustfile.

Runningjust with no arguments runs the first recipe in thejustfile:

$ justecho'This is a recipe!'This is a recipe!

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

$ just another-recipeThis is another recipe.

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

Recipes stop running if a command fails. Herecargo publish will only run ifcargo test succeeds:

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

Recipes can depend on other recipes. Here thetest recipe depends on thebuild recipe, sobuild will run beforetest:

build:  cc main.c foo.c bar.c -o maintest:build  ./testsloc:@echo"`wc -l *.c` lines of code"

$ justtestcc main.c foo.c bar.c -o main./testtesting… all tests passed!

Recipes without dependencies will run in the order they're given on the commandline:

$ just build sloccc main.c foo.c bar.c -o main1337 lines of code

Dependencies will always run first, even if they are passed after a recipe thatdepends on them:

$ justtest buildcc main.c foo.c bar.c -o main./testtesting… all tests passed!

A variety ofjustfiles can be found in theexamples directory and onGitHub.

Whenjust is invoked without a recipe, it runs the first recipe in thejustfile. This recipe might be the most frequently run command in theproject, like running the tests:

test:  cargo test

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

default:lintbuildtestbuild:  echo Building…test:  echo Testing…lint:  echo Linting…

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

default:  just --list

Recipes can be listed in alphabetical order withjust --list:

$ just --listAvailable recipes:    buildtest    deploy    lint

Recipes insubmodules can be listed withjust --list PATH,wherePATH is a space- or::-separated module path:

$ cat justfilemod foo$ cat foo.justmod bar$ cat bar.justbaz:$ just foo barAvailable recipes:    baz$ just foo::barAvailable recipes:    baz

just --summary is more concise:

$ just --summarybuildtest deploy lint

Pass--unsorted to print recipes in the order they appear in thejustfile:

test:  echo'Testing!'build:  echo'Building!'

$ just --list --unsortedAvailable recipes:test    build

$ just --summary --unsortedtest build

If you'd likejust to default to listing the recipes in thejustfile, youcan use this as your default recipe:

default:@just --list

Note that you may need to add--justfile {{justfile()}} to the line above.Without it, if you executedjust -f /some/distant/justfile -d . orjust -f ./non-standard-justfile, the plainjust --list inside the recipewould not necessarily use the file you provided. It would try to find ajustfile in your current path, maybe even resulting in aNo justfile founderror.

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

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

And the indentation can be customized with--list-prefix:

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

The argument to--list-heading replaces both the heading and the newlinefollowing it, so it should contain a newline if non-empty. It works this way soyou can suppress the heading line entirely by passing the empty string:

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

By default, recipes run with the working directory set to the directory thatcontains thejustfile.

The[no-cd] attribute can be used to make recipes run with the workingdirectory set to directory in whichjust was invoked.

@foo:  pwd[no-cd]@bar:  pwd

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

Aliases allow recipes to be invoked on the command line with alternative names:

aliasb:=buildbuild:  echo'Building!'

$ just becho'Building!'Building!

Settings control interpretation and execution. Each setting may be specified atmost once, anywhere in thejustfile.

For example:

setshell:= ["zsh","-cu"]foo:# this line will be run as `zsh -cu 'ls **/*.txt'`  ls **/*.txt

Boolean settings can be written as:

setNAME

Which is equivalent to:

setNAME:=true

Ifallow-duplicate-recipes is set totrue, defining multiple recipes withthe same name is not an error and the last definition is used. Defaults tofalse.

setallow-duplicate-recipes@foo:  echo foo@foo:  echo bar

$ just foobar

Ifallow-duplicate-variables is set totrue, defining multiple variableswith the same name is not an error and the last definition is used. Defaults tofalse.

setallow-duplicate-variablesa:="foo"a:="bar"@foo:  echo $a

$ just foobar

If any ofdotenv-load,dotenv-filename,dotenv-path, ordotenv-requiredare set,just will try to load environment variables from a file.

Ifdotenv-path is set,just will look for a file at the given path, whichmay be absolute, or relative to the working directory.

Ifdotenv-filename is setjust will look for a file at the given path,relative to the working directory and each of its ancestors.

Ifdotenv-filename is not set, butdotenv-load ordotenv-required areset, just will look for a file named.env, relative to the working directoryand each of its ancestors.

dotenv-filename anddotenv-path and similar, butdotenv-path is onlychecked relative to the working directory, whereasdotenv-filename is checkedrelative to the working directory and each of its ancestors.

It is not an error if an environment file is not found, unlessdotenv-required is set.

The loaded variables are environment variables, notjust variables, and somust be accessed using$VARIABLE_NAME in recipes and backticks.

For example, if your.env file contains:

# a comment, will be ignoredDATABASE_ADDRESS=localhost:6379SERVER_PORT=1337

And yourjustfile contains:

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

just serve will output:

$ just serveStarting server with database localhost:6379 on port 1337…./server --database$DATABASE_ADDRESS --port$SERVER_PORT

Theexport setting causes alljust variables to be exported as environmentvariables. Defaults tofalse.

setexporta:="hello"@foob:  echo $a  echo $b

$ just foo goodbyehellogoodbye

Ifpositional-arguments istrue, recipe arguments will be passed aspositional arguments to commands. For linewise recipes, argument$0 will bethe name of the recipe.

For example, running this recipe:

setpositional-arguments@foobar:  echo $0  echo $1

Will produce the following output:

$ just foo hellofoohello

When using ansh-compatible shell, such asbash orzsh,$@ expands tothe positional arguments given to the recipe, starting from one. When usedwithin double quotes as"$@", arguments including whitespace will be passedon 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:

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

Running it withtwo arguments:

$ justtest foo"bar baz"- foo- bar baz

Positional arguments may also be turned on on a per-recipe basis with the[positional-arguments] attribute^1.29.0:

[positional-arguments]@foobar:  echo $0  echo $1

Note that PowerShell does not handle positional arguments in the same way asother shells, so turning on positional arguments will likely break recipes thatuse PowerShell.

Theshell setting controls the command used to invoke recipe lines andbackticks. Shebang recipes are unaffected. The default shell issh -cu.

# use python3 to execute recipe lines and backtickssetshell:= ["python3","-c"]# use print to capture result of evaluationfoos:=`print("foo"* 4)`foo:  print("Snake snake snake snake.")  print("{{foos}}")

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

just usessh on Windows by default. To use a different shell on Windows,usewindows-shell:

setwindows-shell:= ["powershell.exe","-NoLogo","-Command"]hello:  Write-Host"Hello, world!"

Seepowershell.justfor a justfile that uses PowerShell on all platforms.

set windows-powershell uses the legacypowershell.exe binary, and is nolonger recommended. See thewindows-shell setting above for a more flexibleway to control which shell is used on Windows.

just usessh on Windows by default. To usepowershell.exe instead, setwindows-powershell to true.

setwindows-powershell:=truehello:  Write-Host"Hello, world!"

setshell:= ["python3","-c"]

setshell:= ["bash","-uc"]

setshell:= ["zsh","-uc"]

setshell:= ["fish","-c"]

setshell:= ["nu","-c"]

If you want to change the default table mode tolight:

setshell:= ['nu','-m','light','-c']

Nushell was written in Rust, andhascross-platform support for Windows / macOS and Linux.

Comments immediately preceding a recipe will appear injust --list:

# build stuffbuild:  ./bin/build# test stufftest:  ./bin/test

$ just --listAvailable recipes:    build# build stufftest# test stuff

The[doc] attribute can be used to set or suppress a recipe's doc comment:

# This comment won't appear[doc('Build stuff')]build:  ./bin/build# This one won't either[doc]test:  ./bin/test

$ just --listAvailable recipes:    build# Build stufftest

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

tmpdir:=`mktemp -d`version:="0.2.7"tardir:= tmpdir/"awesomesauce-"+ versiontarball:= 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}}

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

foo:="a"/"b"

$ just --evaluate fooa/b

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

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

$ just --evaluate bara//b

Absolute paths can also be constructed^1.5.0:

foo:=/"b"

$ just --evaluate foo/b

The/ operator uses the/ character, even on Windows. Thus, using the/operator should be avoided with paths that use universal naming convention(UNC), i.e., those that start with\?, since forward slashes are notsupported with UNC paths.

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

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 aninterpolation:

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

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

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

Double-quoted strings support escape sequences:

string-with-tab:="\t"string-with-newline:="\n"string-with-carriage-return:="\r"string-with-double-quote:="\""string-with-slash:="\\"string-with-no-newline:="\"

$ just --evaluate"tring-with-carriage-return :="string-with-double-quote    :="""string-with-newline         :=""string-with-no-newline      :=""string-with-slash           :="\"string-with-tab             :=""

Strings may contain line breaks:

single:='hello'double:="goodbye"

Single-quoted strings do not recognize escape sequences:

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

$ just --evaluateescapes :="\t\n\r\"\\"

Indented versions of both single- and double-quoted strings, delimited bytriple single- or double-quotes, are supported. Indented string lines arestripped of a leading line break, and leading whitespace common to allnon-blank lines:

# this string will evaluate to `foo\nbar\n`x:='''  foo  bar'''# this string will evaluate to `abc\n  wuv\nxyz\n`y:="""  abc    wuv  xyz"""

Similar to unindented strings, indented double-quoted strings process escapesequences, and indented single-quoted strings ignore escape sequences. Escapesequence processing takes place after unindentation. The unindentationalgorithm does not take escape-sequence produced whitespace or newlines intoaccount.

Strings prefixed withx are shell expanded^1.27.0:

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

This expansion is performed at compile time, so variables from.env files andexportedjust variables cannot be used. However, this allows shell expandedstrings to be used in places like settings and import paths, which cannotdepend onjust variables and.env files.

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

foo:-cat foo  echo'Done!'

$ just foocat foocat: foo: No such file or directoryecho'Done!'Done!

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

All functions ending in_directory can be abbreviated to_dir. Sohome_directory() can also be written ashome_dir(). In addition,invocation_directory_native() can be abbreviated toinvocation_dir_native().

• 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()^1.15.0 - 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:

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

$ just system-infoThis is an x86_64 machine

Theos_family() function can be used to create cross-platformjustfilesthat work on various operating systems. For an example, seecross-platform.justfile.

• shell(command, args...)^1.27.0 returns the standard output of shell scriptcommand with zero or more positional argumentsargs. The shell used tointerpretcommand is the same shell that is used to evaluate recipe lines,and can be changed withset shell := […].

  command is passed as the first argument, so if the command is'echo $@',the full command line, with the default shell commandshell -cu andargs'foo' and'bar' will be:

  'shell' '-cu' 'echo $@' 'echo $@' 'foo' 'bar'

  This is so that$@ works as expected, and$1 refers to the firstargument.$@ does not include the first positional argument, which isexpected to be the name of the program being run.

# arguments can be variables or expressionsfile:='/sys/class/power_supply/BAT0/status'bat0stat:=shell('cat $1', file)# commands can be variables or expressionscommand:='wc -l'output:=shell(command+' "$1"','main.c')# arguments referenced by the shell command must be usedempty:=shell('echo','foo')full:=shell('echo $1','foo')error:=shell('echo $1')

# Using python as the shell. Since `python -c` sets `sys.argv[0]` to `'-c'`,# the first "real" positional argument will be `sys.argv[2]`.setshell:= ["python3","-c"]olleh:=shell('import sys; print(sys.argv[2][::-1])','hello')

• env_var(key) — Retrieves the environment variable with namekey, abortingif it is not present.

home_dir:=env_var('HOME')test:  echo"{{home_dir}}"

$ just/home/user1

• env_var_or_default(key, default) — Retrieves the environment variable withnamekey, returningdefault if it is not present.
• env(key)^1.15.0 — Alias forenv_var(key).
• env(key, default)^1.15.0 — Alias forenv_var_or_default(key, default).

• is_dependency() - Returns the stringtrue if the current recipe is beingrun as a dependency of another recipe, rather than being run directly,otherwise returns the stringfalse.

• invocation_directory() - Retrieves the absolute path to the currentdirectory whenjust was invoked, beforejust changed it (chdir'd) priorto executing commands. On Windows,invocation_directory() usescygpath toconvert the invocation directory to a Cygwin-compatible/-separated path.Useinvocation_directory_native() to return the verbatim invocationdirectory on all platforms.

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

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

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

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

• invocation_directory_native() - Retrieves the absolute path to the currentdirectory whenjust was invoked, beforejust changed it (chdir'd) priorto executing commands.

• justfile() - Retrieves the path of the currentjustfile.

• justfile_directory() - Retrieves the path of the parent directory of thecurrentjustfile.

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

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

• source_file()^1.27.0 - Retrieves the path of the current source file.

• source_directory()^1.27.0 - Retrieves the path of the parent directory of thecurrent source file.

source_file() andsource_directory() behave the same asjustfile() andjustfile_directory() in the rootjustfile, but will return the path anddirectory, respectively, of the currentimport ormod source file whencalled from within an import or submodule.

• just_executable() - Absolute path to thejust executable.

For example:

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

$ justThe executable is at: /bin/just

• just_pid() - Process ID of thejust executable.

For example:

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

$ justThe process ID is: 420

• append(suffix, s)^1.27.0 Appendsuffix to whitespace-separatedstrings ins.append('/src', 'foo bar baz') →'foo/src bar/src baz/src'
• prepend(prefix, s)^1.27.0 Prependprefix towhitespace-separated strings ins.prepend('src/', 'foo bar baz') →'src/foo src/bar src/baz'
• encode_uri_component(s)^1.27.0 - Percent-encode characters insexcept[A-Za-z0-9_.!~*'()-], matching the behavior of theJavaScriptencodeURIComponent function.
• quote(s) - Replace all single quotes with'\'' and prepend and appendsingle quotes tos. This is sufficient to escape special characters formany shells, including most Bourne shell descendants.
• replace(s, from, to) - Replace all occurrences offrom ins toto.
• replace_regex(s, regex, replacement) - Replace all occurrences ofregexins toreplacement. Regular expressions are provided by theRustregex crate. See thesyntax documentation for usageexamples. Capture groups are supported. Thereplacement string usesReplacement string syntax.
• trim(s) - Remove leading and trailing whitespace froms.
• trim_end(s) - Remove trailing whitespace froms.
• trim_end_match(s, pat) - Remove suffix ofs matchingpat.
• trim_end_matches(s, pat) - Repeatedly remove suffixes ofs matchingpat.
• trim_start(s) - Remove leading whitespace froms.
• trim_start_match(s, pat) - Remove prefix ofs matchingpat.
• trim_start_matches(s, pat) - Repeatedly remove prefixes ofs matchingpat.

• capitalize(s)^1.7.0 - Convert first character ofs to uppercaseand the rest to lowercase.
• kebabcase(s)^1.7.0 - Converts tokebab-case.
• lowercamelcase(s)^1.7.0 - Converts tolowerCamelCase.
• lowercase(s) - Converts to lowercase.
• shoutykebabcase(s)^1.7.0 - Converts toSHOUTY-KEBAB-CASE.
• shoutysnakecase(s)^1.7.0 - Converts toSHOUTY_SNAKE_CASE.
• snakecase(s)^1.7.0 - Converts tosnake_case.
• titlecase(s)^1.7.0 - Converts toTitle Case.
• uppercamelcase(s)^1.7.0 - Converts toUpperCamelCase.
• uppercase(s) - Converts to uppercase.

• absolute_path(path) - Absolute path to relativepath in the workingdirectory.absolute_path("./bar.txt") in directory/foo is/foo/bar.txt.
• canonicalize(path)^1.24.0 - Canonicalizepath by resolving symlinks and removing.,.., and extra/s where possible.
• extension(path) - Extension ofpath.extension("/foo/bar.txt") istxt.
• file_name(path) - File name ofpath with any leading directory componentsremoved.file_name("/foo/bar.txt") isbar.txt.
• file_stem(path) - File name ofpath without extension.file_stem("/foo/bar.txt") isbar.
• parent_directory(path) - Parent directory ofpath.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.

• clean(path) - Simplifypath by removing extra path separators,intermediate. components, and.. where possible.clean("foo//bar") isfoo/bar,clean("foo/..") is.,clean("foo/./bar") isfoo/bar.
• join(a, b…) -This function uses/ on Unix and\ on Windows, which canbe lead to unwanted behavior. The/ operator, e.g.,a / b, which alwaysuses/, should be considered as a replacement unless\s are specificallydesired on Windows. Join patha with pathb.join("foo/bar", "baz") isfoo/bar/baz. Accepts two or more arguments.

• path_exists(path) - Returnstrue if the path points at an existing entityandfalse otherwise. Traverses symbolic links, and returnsfalse if thepath is inaccessible or points to a broken symlink.

• error(message) - Abort execution and report errormessage to user.

• blake3(string)^1.25.0 - ReturnBLAKE3 hash ofstring as hexadecimal string.
• blake3_file(path)^1.25.0 - ReturnBLAKE3 hash of file atpath as hexadecimalstring.
• sha256(string) - Return the SHA-256 hash ofstring as hexadecimal string.
• sha256_file(path) - Return SHA-256 hash of file atpath as hexadecimalstring.
• uuid() - Generate a random version 4 UUID.

• choose(n, alphabet)^1.27.0 - Generate a string ofn randomlyselected characters fromalphabet, which may not contain repeatedcharacters. For example,choose('64', HEX) will generate a random64-character lowercase hex string.

• datetime(format)^1.30.0 - Return local time withformat.
• datetime_utc(format)^1.30.0 - Return UTC time withformat.

The arguments todatetime anddatetime_utc arestrftime-style formatstrings, see thechrono library docsfor details.

• semver_matches(version, requirement)^1.16.0 - Check whether asemanticversion, e.g.,"0.1.0" matches arequirement, e.g.,">=0.1.0", returning"true" if so and"false"otherwise.

These functions return paths to user-specific directories for things likeconfiguration, data, caches, executables, and the user's home directory. Thesefunctions follow theXDG Base Directory Specification,and are implemented with thedirs crate.

• cache_directory() - The user-specific cache directory.
• config_directory() - The user-specific configuration directory.
• config_local_directory() - The local user-specific configuration directory.
• data_directory() - The user-specific data directory.
• data_local_directory() - The local user-specific data directory.
• executable_directory() - The user-specific executable directory.
• home_directory() - The user's home directory.

A number of constants are predefined:

@foo:  echo{{HEX}}

$ just foo0123456789abcdef

Recipes may be annotated with attributes that change their behavior.

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

[no-cd][private]foo:    echo"foo"

Or separated by commas on a single line^1.14.0:

[no-cd, private]foo:    echo"foo"

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

This can be used to writejustfiles that behave differently depending onwhich operating system they run on. Therun recipe in thisjustfile willcompile and runmain.c, using a different C compiler and using the correctoutput binary name for that compiler depending on the operating system:

[unix]run:  cc main.c  ./a.out[windows]run:  cl main.c  main.exe

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

For example, thiscommit recipe:

[no-cd]commitfile:  git add{{file}}  git commit

Can be used with paths that are relative to the current directory, because[no-cd] preventsjust from changing the current directory when executingcommit.

just normally executes all recipes unless there is an error. The[confirm]attribute allows recipes require confirmation in the terminal prior to running.This can be overridden by passing--yes tojust, which will automaticallyconfirm any recipes marked by this attribute.

Recipes dependent on a recipe that requires confirmation will not be run if therelied upon recipe is not confirmed, as well as recipes passed after any recipethat requires confirmation.

[confirm]delete-all:  rm -rf *

The default confirmation prompt can be overridden with[confirm(PROMPT)]:

[confirm("Are you sure you want to delete everything?")]delete-everything:  rm -rf *

Recipes can be annotated with a group name:

[group('lint')]js-lint:    echo'Running JS linter…'[group('rust recipes')][group('lint')]rust-lint:    echo'Running Rust linter…'[group('lint')]cpp-lint:  echo'Running C++ linter…'# not in any groupemail-everyone:    echo'Sending mass email…'

Recipes are listed by group:

$ just --listAvailable recipes:    (no group)    email-everyone # not in any group    [lint]    cpp-lint    js-lint    rust-lint    [rust recipes]    rust-lint

just --list --unsorted prints recipes in their justfile order within each group:

$ just --list --unsortedAvailable recipes:    (no group)    email-everyone # not in any group    [lint]    js-lint    rust-lint    cpp-lint    [rust recipes]    rust-lint

Groups can be listed with--groups:

$ just --groupsRecipe groups:  lint  rust recipes

Usejust --groups --unsorted to print groups in their justfile order.

Backticks can be used to store the result of commands:

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 samemanner as indented strings:

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

See theStrings section for details on unindenting.

Backticks may not start with#!. This syntax is reserved for a futureupgrade.

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

foo:=if"2"=="2" {"Good!" }else {"1984" }bar:@echo"{{foo}}"

$ just barGood!

It is also possible to test for inequality:

foo:=if"hello"!="goodbye" {"xyz" }else {"abc" }bar:@echo{{foo}}

$ just barxyz

And match against regular expressions:

foo:=if"hello"=~'hel+o' {"match" }else {"mismatch" }bar:@echo{{foo}}

$ just barmatch

Regular expressions are provided by theregex crate, whose syntax is documented ondocs.rs. Since regular expressionscommonly use backslash escape sequences, consider using single-quoted stringliterals, which will pass slashes to the regex parser unmolested.

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

foo:=ifenv_var("RELEASE")=="true" {`get-something-from-release-database` }else {"dummy-value" }

Conditionals can be used inside of recipes:

barfoo:  echo{{if foo=="bar" {"hello" }else {"goodbye" }}}

Note the space after the final}! Without the space, the interpolation willbe prematurely closed.

Multiple conditionals can be chained:

foo:=if"hello"=="goodbye" {"xyz"}elseif"a"=="a" {"abc"}else {"123"}bar:@echo{{foo}}

$ just barabc

Execution can be halted with theerror function. For example:

foo:=if"hello"=="goodbye" {"xyz"}elseif"a"=="b" {"abc"}else {error("123")}

Which produce the following error when run:

error: Call to function `error` failed: 123   |16 |   error("123")

Variables can be overridden from the command line.

os:="linux"test:build  ./test --test{{os}}build:  ./build{{os}}

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

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

$ just os=plan9./build plan9./test --test plan9

Or you can use the--set flag:

$ just --set os bsd./build bsd./test --test bsd

Assignments prefixed with theexport keyword will be exported to recipes asenvironment variables:

exportRUST_BACKTRACE:="1"test:# will print a stack trace if it crashes  cargo test

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

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.

exportWORLD:="world"# This backtick will fail with "WORLD: unbound variable"BAR:=`echo hello$WORLD`

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

Whenexport is set, alljust variables are exported as environmentvariables.

Environment variables can be unexported with theunexport keyword:

unexportFOO@foo:  echo $FOO

$ export FOO=bar$ just foosh: FOO: unbound variable

Environment variables from the environment are passed automatically to therecipes.

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

$ justHOME is'/home/myuser'

Environment variables can be propagated tojust variables using the functionsenv_var() andenv_var_or_default(). Seeenvironment-variables.

Recipes may have parameters. Here recipebuild has a parameter calledtarget:

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

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

$ just build my-awesome-projectBuilding my-awesome-project…cd my-awesome-project&& make

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

default: (build"main")buildtarget:@echo'Building{{target}}…'  cd{{target}}&& make

Variables can also be passed as arguments to dependencies:

target:="main"_buildversion:@echo'Building{{version}}…'  cd{{version}}&& makebuild: (_build target)

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

buildtarget:@echo"Building{{target}}…"pushtarget: (build target)@echo'Pushing{{target}}…'

Parameters may have default values:

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

Parameters with default values may be omitted:

$ justtest serverTesting server:all…./test --tests all server

Or supplied:

$ justtest server unitTesting server:unit…./test --tests unit server

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

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

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

backup+FILES:  scp{{FILES}} me@server.com:

Variadic parameters prefixed with+ acceptone or more arguments and expandto a string containing those arguments separated by spaces:

$ just backup FAQ.md GRAMMAR.mdscp FAQ.md GRAMMAR.md me@server.com:FAQ.md                  100% 1831     1.8KB/s   00:00GRAMMAR.md              100% 1666     1.6KB/s   00:00

Variadic parameters prefixed with* acceptzero or more arguments andexpand to a string containing those arguments separated by spaces, or an emptystring if no arguments are present:

commitMESSAGE*FLAGS:  git commit{{FLAGS}} -m"{{MESSAGE}}"

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

test+FLAGS='-q':  cargo test{{FLAGS}}

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

searchQUERY:  lynx https://www.google.com/?q={{QUERY}}

And you type:

$ just search"cat toupee"

just will run the commandlynx https://www.google.com/?q=cat toupee, whichwill get parsed bysh aslynx,https://www.google.com/?q=cat, andtoupee, and not the intendedlynx andhttps://www.google.com/?q=cat toupee.

You can fix this by adding quotes:

searchQUERY:  lynx'https://www.google.com/?q={{QUERY}}'

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

foo$bar:  echo $bar

Dependencies run before recipes that depend on them:

a:b@echo Ab:@echo B

$ just aBA

In a given invocation ofjust, a recipe with the same arguments will only runonce, regardless of how many times it appears in the command-line invocation,or how many times it appears as a dependency:

a:@echo Ab:a@echo Bc:a@echo C

$ just a a a a aA$ just b cABC

Multiple recipes may depend on a recipe that performs some kind of setup, andwhen those recipes run, that setup will only be performed once:

build:  cc main.ctest-foo:build  ./a.out --test footest-bar:build  ./a.out --test bar

$ just test-foo test-barcc main.c./a.out --test foo./a.out --test bar

Recipes in a given run are only skipped when they receive the same arguments:

build:  cc main.ctestTEST:build  ./a.out --test{{TEST}}

$ just test foo test barcc main.c./a.out --test foo./a.out --test bar

Normal dependencies of a recipes always run before a recipe starts. That is tosay, the dependee always runs before the depender. These dependencies arecalled "prior dependencies".

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

a:  echo'A!'b:a&&cd  echo'B!'c:  echo'C!'d:  echo'D!'

…runningb prints:

$ just becho'A!'A!echo'B!'B!echo'C!'C!echo'D!'D!

just doesn't support running recipes in the middle of another recipe, but youcan calljust recursively in the middle of a recipe. Given the followingjustfile:

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

…runningb prints:

$ just becho'A!'A!echo'B start!'B start!echo'C!'C!echo'B end!'B end!

This has limitations, since recipec is run with an entirely new invocationofjust: Assignments will be recalculated, dependencies might run twice, andcommand line arguments will not be propagated to the childjust process.

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

polyglot:pythonjsperlshrubynupython:#!/usr/bin/env python3print('Hello from python!')js:#!/usr/bin/env nodeconsole.log('Greetings from JavaScript!')perl:#!/usr/bin/env perlprint"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 rubyputs"Hello from ruby!"

$ just polyglotHello 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 and MacOS, shebang recipes areexecuted by saving the recipe body to a file in a temporary directory, markingthe file as executable, and executing it. The OS then parses the shebang lineinto a command line and invokes it, including the path to the file. Forexample, if a recipe starts with#!/usr/bin/env bash, the final command thatthe OS runs will be something like/usr/bin/env bash /tmp/PATH_TO_SAVED_RECIPE_BODY.

Shebang line splitting is operating system dependent. When passing a commandwith arguments, you may need to tellenv to split them explicitly by usingthe-S flag:

run:  #!/usr/bin/env -S bash -x  ls

Windows does not support shebang lines. On Windows,just splits the shebangline into a command and arguments, saves the recipe body to a file, and invokesthe split command and arguments, adding the path to the saved recipe body asthe final argument. For example, on Windows, if a recipe starts with#! py,the final command the OS runs will be something likepy C:\Temp\PATH_TO_SAVED_RECIPE_BODY.

Recipes with a[script(COMMAND)]^1.32.0 attribute are run asscripts interpreted byCOMMAND. This avoids some of the issues with shebangrecipes, such as the use ofcygpath on Windows, the need to use/usr/bin/env, and inconsistences in shebang line splitting across Unix OSs.

Recipes with an empty[script] attribute are executed with the value ofset script-interpreter := […]^master, defaulting tosh -eu.

The body of the recipe is evaluated, written to disk in the temporarydirectory, and run by passing its path as an argument toCOMMAND.

The[script(…)] attribute is unstable, so you'll need to useset unstable,set theJUST_UNSTABLE environment variable, or pass--unstable on thecommand line.

If you're writing abash shebang recipe, consider addingset -euxo pipefail:

foo:#!/usr/bin/env bashset -euxo pipefail  hello='Yo'echo"$hello from Bash!"

It isn't strictly necessary, butset -euxo pipefail turns on a few usefulfeatures that makebash shebang recipes behave more like normal, linewisejust recipe:

• set -e makesbash exit if a command fails.

• set -u makesbash exit if a variable is undefined.

• set -x makesbash print each script line before it's run.

• set -o pipefail makesbash exit if a command in a pipeline fails. This isbash-specific, so isn't turned on in normal linewisejust recipes.

Together, these avoid a lot of shell scripting gotchas.

On Windows, shebang interpreter paths containing a/ are translated fromUnix-style paths to Windows-style paths usingcygpath, a utility that shipswithCygwin.

For example, to execute this recipe on Windows:

echo:  #!/bin/sh  echo"Hello!"

The interpreter path/bin/sh will be translated to a Windows-style path usingcygpath before being executed.

If the interpreter path does not contain a/ it will be executed withoutbeing translated. This is useful ifcygpath is not available, or you wish topass a Windows-style path to the interpreter.

Recipe lines are interpreted by the shell, notjust, so it's not possible tosetjust variables in the middle of a recipe:

foo:x := "hello"# This doesn't work!  echo {{x}}

It is possible to use shell variables, but there's another problem. Everyrecipe line is run by a new shell instance, so variables set in one line won'tbe set in the next:

foo:  x=hello&& echo $x# This works!  y=bye  echo $y# This doesn't, `y` is undefined here!

The best way to work around this is to use a shebang recipe. Shebang recipebodies are extracted and run as scripts, so a single shell instance will runthe whole thing:

foo:#!/usr/bin/env bashset -euxo pipefail  x=helloecho$x

Each line of each recipe is executed by a fresh shell, so it is not possible toshare environment variables between recipes.

Some tools, likePython's venv,require loading environment variables in order to work, making them challengingto use withjust. As a workaround, you can execute the virtual environmentbinaries directly:

venv:  [ -d foo ] || python3 -m venv foorun:venv  ./foo/bin/python3 main.py

Each recipe line is executed by a new shell, so if you change the workingdirectory on one line, it won't have an effect on later lines:

foo:  pwd# This `pwd` will print the same directory…  cd bar  pwd# …as this `pwd`!

There are a couple ways around this. One is to callcd on the same line asthe command you want to run:

foo:  cd bar&& pwd

The other is to use a shebang recipe. Shebang recipe bodies are extracted andrun as scripts, so a single shell instance will run the whole thing, and thus apwd on one line will affect later lines, just like a shell script:

foo:#!/usr/bin/env bashset -euxo pipefailcd barpwd

Recipe lines can be indented with spaces or tabs, but not a mix of both. All ofa recipe's lines must have the same type of indentation, but different recipesin the samejustfile may use different indentation.

Each recipe must be indented at least one level from therecipe-name butafter that may be further indented.

Here's a justfile with a recipe indented with spaces, represented as·, andtabs, represented as→.

setwindows-shell:= ["pwsh","-NoLogo","-NoProfileLoadTime","-Command"]setignore-commentslist-spacedirectory:··#!pwsh··foreach ($item in $(Get-ChildItem {{directory}} )) {····echo $item.Name··}··echo""# indentation nesting works even when newlines are escapedlist-tabdirectory:→ @foreach ($item in $(Get-ChildItem {{directory}} )) { \→ → echo $item.Name \→ }→ @echo""

PS> just list-space ~DesktopDocumentsDownloadsPS> just list-tab ~DesktopDocumentsDownloads

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

For example, with the followingjustfile:

conditional:  if true; then    echo 'True!'  fi

The extra leading whitespace before the second line of theconditional recipewill produce a parse error:

$ just conditionalerror: Recipe line has extra leading whitespace|3|echo'True!'|     ^^^^^^^^^^^^^^^^

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

conditional:iftrue; then echo'True!'; fi

conditional:iftrue; then \    echo'True!'; \  fi

conditional:#!/usr/bin/env shiftrue;thenecho'True!'fi

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

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

for:#!/usr/bin/env shforfilein`ls .`;doecho$filedone

while:  while`server-is-dead`; do ping -c1 server; done

while:  while`server-is-dead`; do \    ping -c1 server; \  done

while:#!/usr/bin/env shwhile`server-is-dead`;do    ping -c 1 serverdone

Parenthesized expressions can span multiple lines:

abc:= ('a'+'b'+'c')abc2:= ('a'+'b'+'c')foo param=('foo'+'bar'    ):  echo{{param}}bar: (foo'Foo'     )  echo'Bar!'

Lines ending with a backslash continue on to the next line as if the lines werejoined by whitespace^1.15.0:

a:='foo'+ \'bar'foo param1 \  param2='foo' \  *varparam='': dep1 \                (dep2'foo')  echo{{param1}}{{param2}}{{varparam}}dep1: \# this comment is not part of the recipe body  echo'dep1'dep2 \  param:    echo'Dependency with parameter{{param}}'

Backslash line continuations can also be used in interpolations. The linefollowing the backslash must be indented.

recipe:  echo'{{ \  "This interpolation " + \    "has a lot of text." \  }}'  echo'back to recipe body'

just supports a number of useful command line options for listing, dumping,and debugging recipes and variables:

$ just --listAvailable recipes:  js  perl  polyglot  python  ruby$ just --show perlperl:#!/usr/bin/env perl  print"Larry Wall says Hi!\n";$ just --show polyglotpolyglot: python js perl sh ruby

Some command-line options can be set with environment variables. For example:

$export JUST_UNSTABLE=1$ just

Is equivalent to:

$ just --unstable

Consultjust --help to see which options can be set from environmentvariables.

Recipes and aliases whose name starts with a_ are omitted fromjust --list:

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

$ just --listAvailable recipes:test

And fromjust --summary:

$ just --summarytest

The[private] attribute^1.10.0 may also be used to hide recipes oraliases without needing to change the name:

[private]foo:[private]aliasb:=barbar:

$ just --listAvailable recipes:    bar

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

A recipe name may be prefixed with@ to invert the meaning of@ before eachline:

@quiet:  echo hello  echo goodbye@# all done!

Now only the lines starting with@ will be echoed:

$ just quiethellogoodbye# all done!

All recipes in a Justfile can be made quiet withset quiet:

setquietfoo:  echo"This is quiet"@foo2:  echo"This is also quiet"

The[no-quiet] attribute overrides this setting:

setquietfoo:  echo"This is quiet"[no-quiet]foo2:  echo"This is not quiet"

Shebang recipes are quiet by default:

foo:#!/usr/bin/env bashecho'Foo!'

$ just fooFoo!

Adding@ to a shebang recipe name makesjust print the recipe beforeexecuting it:

@bar:#!/usr/bin/env bashecho'Bar!'

$ just bar#!/usr/bin/env bashecho'Bar!'Bar!

just normally prints error messages when a recipe line fails. These errormessages can be suppressed using the[no-exit-message]^1.7.0attribute. You may find this especially useful with a recipe that wraps a tool:

git*args:@git{{args}}

$ just git statusfatal: not a git repository (or any of the parent directories): .giterror: Recipe`git` failed on line 2 withexit code 128

Add the attribute to suppress the exit error message when the tool exits with anon-zero code:

[no-exit-message]git*args:@git{{args}}

$ just git statusfatal: not a git repository (or any of the parent directories): .git

The--choose subcommand makesjust invoke a chooser to select which recipesto run. Choosers should read lines containing recipe names from standard inputand print one or more of those names separated by spaces to standard output.

Because there is currently no way to run a recipe that requires arguments with--choose, such recipes will not be given to the chooser. Private recipes andaliases are also skipped.

The chooser can be overridden with the--chooser flag. If--chooser is notgiven, thenjust first checks if$JUST_CHOOSER is set. If it isn't, thenthe chooser defaults tofzf, a popular fuzzy finder.

Arguments can be included in the chooser, i.e.fzf --exact.

The chooser is invoked in the same way as recipe lines. For example, if thechooser isfzf, it will be invoked withsh -cu 'fzf', and if the shell, orthe shell arguments are overridden, the chooser invocation will respect thoseoverrides.

If you'd likejust to default to selecting recipes with a chooser, you canuse this as your default recipe:

default:@just --choose

If the first argument passed tojust contains a/, then the followingoccurs:

1. The argument is split at the last/.

2. The part before the last/ is treated as a directory.just will startits search for thejustfile there, instead of in the current directory.

3. The part after the last slash is treated as a normal argument, or ignoredif it is empty.

This may seem a little strange, but it's useful if you wish to run a command inajustfile that is in a subdirectory.

For example, if you are in a directory which contains a subdirectory namedfoo, which contains ajustfile with the recipebuild, which is also thedefault recipe, the following are all equivalent:

$ (cd foo&& just build)$ just foo/build$ just foo/

Additional recipes after the first are sought in the samejustfile. Forexample, the following are both equivalent:

$ just foo/a b$ (cd foo&& just a b)

And will both invoke recipesa andb infoo/justfile.

Onejustfile can include the contents of another usingimport statements.

If you have the followingjustfile:

import 'foo/bar.just'a: b  @echo A

And the following text infoo/bar.just:

b:@echo B

foo/bar.just will be included injustfile and recipeb will be defined:

$ just bB$ just aBA

Theimport path can be absolute or relative to the location of the justfilecontaining it. A leading~/ in the import path is replaced with the currentusers home directory.

Justfiles are insensitive to order, so included files can reference variablesand recipes defined after theimport statement.

Imported files can themselves containimports, which are processedrecursively.

Whenallow-duplicate-recipes is set, recipes in parent modules overriderecipes in imports. In a similar manner, whenallow-duplicate-variables isset, variables in parent modules override variables in imports.

Imports may be made optional by putting a? after theimport keyword:

import? 'foo/bar.just'

Missing source files for optional imports do not produce an error.

Ajustfile can declare modules usingmod statements.

mod statements were stabilized injust^1.31.0. In earlierversions, you'll need to use the--unstable flag,set unstable, or set theJUST_UNSTABLE environment variable to use them.

If you have the followingjustfile:

mod bara:  @echo A

And the following text inbar.just:

b:@echo B

bar.just will be included injustfile as a submodule. Recipes, aliases, andvariables defined in one submodule cannot be used in another, and each moduleuses its own settings.

Recipes in submodules can be invoked as subcommands:

$ just bar bB

Or with path syntax:

$ just bar::bB

If a module is namedfoo, just will search for the module file infoo.just,foo/mod.just,foo/justfile, andfoo/.justfile. In the latter two cases,the module file may have any capitalization.

Module statements may be of the form:

mod foo 'PATH'

Which loads the module's source file fromPATH, instead of from the usuallocations. A leading~/ inPATH is replaced with the current user's homedirectory.PATH may point to the module source file itself, or to a directorycontaining the module source file with the namemod.just,justfile, or.justfile. In the latter two cases, the module file may have anycapitalization.

Environment files are only loaded for the root justfile, and loaded environmentvariables are available in submodules. Settings in submodules that affectenvironment file loading are ignored.

Recipes in submodules without the[no-cd] attribute run with the workingdirectory set to the directory containing the submodule source file.

justfile() andjustfile_directory() always return the path to the rootjustfile and the directory that contains it, even when called from submodulerecipes.

Modules may be made optional by putting a? after themod keyword:

mod? foo

Missing source files for optional modules do not produce an error.

Optional modules with no source file do not conflict, so you can have multiplemod statements with the same name, but with different source file paths, aslong as at most one source file exists:

mod? foo 'bar.just'mod? foo 'baz.just'

Modules may be given doc comments which appear in--listoutput^1.30.0:

# foo is a great module!mod foo

$ just --listAvailable recipes:    foo ...# foo is a great module!

See themodule stabilization tracking issuefor more information.

just looks forjustfiles namedjustfile and.justfile, which can beused to keep ajustfile hidden.

By adding a shebang line to the top of ajustfile and making it executable,just can be used as an interpreter for scripts:

$ cat> script<<EOF#!/usr/bin/env just --justfilefoo:  echo fooEOF$ chmod +x script$ ./script fooecho foofoo

When a script with a shebang is executed, the system supplies the path to thescript as an argument to the command in the shebang. So, with a shebang of#!/usr/bin/env just --justfile, the command will be/usr/bin/env just --justfile PATH_TO_SCRIPT.

With the above shebang,just will change its working directory to thelocation of the script. If you'd rather leave the working directory unchanged,use#!/usr/bin/env just --working-directory . --justfile.

Note: Shebang line splitting is not consistent across operating systems. Theprevious examples have only been tested on macOS. On Linux, you may need topass the-S flag toenv:

#!/usr/bin/env -S just --justfiledefault:  echo foo

Eachjustfile has a canonical formatting with respect to whitespace andnewlines.

You can overwrite the current justfile with a canonically-formatted versionusing the currently-unstable--fmt flag:

$ cat justfile# A lot of blank linessome-recipe:echo"foo"$ just --fmt --unstable$ cat justfile# A lot of blank linessome-recipe:echo"foo"

Invokingjust --fmt --check --unstable runs--fmt in check mode. Instead ofoverwriting thejustfile,just will exit with an exit code of 0 if it isformatted correctly, and will exit with 1 and print a diff if it is not.

You can use the--dump command to output a formatted version of thejustfile to stdout:

$ just --dump> formatted-justfile

The--dump command can be used with--dump-format json to print a JSONrepresentation of ajustfile.

If a recipe is not found in ajustfile and thefallback setting is set,just will look forjustfiles in the parent directory and up, until itreaches the root directory.just will stop after it reaches ajustfile inwhich thefallback setting isfalse or unset.

As an example, suppose the current directory contains thisjustfile:

setfallbackfoo:  echo foo

And the parent directory contains thisjustfile:

bar:  echo bar

$ just barTrying ../justfileecho barbar

Given thisjustfile:

fooargument:  touch{{argument}}

The following command will create two files,some andargument.txt:

$ just foo"some argument.txt"

The users shell will parse"some argument.txt" as a single argument, but whenjust replacestouch {{argument}} withtouch some argument.txt, the quotesare not preserved, andtouch will receive two arguments.

There are a few ways to avoid this: quoting, positional arguments, and exportedarguments.

Quotes can be added around the{{argument}} interpolation:

fooargument:  touch'{{argument}}'

This preservesjust's ability to catch variable name typos before running,for example if you were to write{{argument}}, but will not do what you wantif the value ofargument contains single quotes.

Thepositional-arguments setting causes all arguments to be passed aspositional arguments, allowing them to be accessed with$1,$2, …, and$@, which can be then double-quoted to avoid further splitting by the shell:

setpositional-argumentsfooargument:  touch"$1"

This defeatsjust's ability to catch typos, for example if you type$2instead of$1, but works for all possible values ofargument, includingthose with double quotes.

All arguments are exported when theexport setting is set:

setexportfooargument:  touch"$argument"

Or individual arguments may be exported by prefixing them with$:

foo$argument:  touch"$argument"

This defeatsjust's ability to catch typos, for example if you type$argumant, but works for all possible values ofargument, including thosewith double quotes.

There are a number of ways to configure the shell for linewise recipes, whichare the default when a recipe does not start with a#! shebang. Theirprecedence, from highest to lowest, is:

1. The--shell and--shell-arg command line options. Passing either ofthese will causejust to ignore any settings in the current justfile.
2. set windows-shell := [...]
3. set windows-powershell (deprecated)
4. set shell := [...]

Sinceset windows-shell has higher precedence thanset shell, you can useset windows-shell to pick a shell on Windows, andset shell to pick a shellfor all other platforms.

just can print timestamps before each recipe commands:

recipe:  echo one  sleep2  echo two

$ just --timestamp recipe[07:28:46] echo oneone[07:28:46] sleep 2[07:28:48] echo twotwo

By default, timestamps are formatted asHH:MM:SS. The format can be changedwith--timestamp-format:

$ just --timestamp recipe --timestamp-format '%H:%M:%S%.3f %Z'[07:32:11:.349 UTC] echo oneone[07:32:11:.350 UTC] sleep 2[07:32:13:.352 UTC] echo twotwo

The argument to--timestamp-format is astrftime-style format string, seethechrono library docsfor details.

A changelog for the latest release is available inCHANGELOG.md.Changelogs for previous releases are available onthe releases page.just --changelogcan also be used to make ajust binary print its changelog.

watchexec can re-run any commandwhen files change.

To re-run the recipefoo when any file changes:

watchexec just foo

Seewatchexec --help for more info, including how to specify which filesshould be watched for changes.

GNU parallel can be used to run tasks concurrently:

parallel:  #!/usr/bin/env -S parallel --shebang --ungroup --jobs{{num_cpus()}}  echo task1 start; sleep3; echo task1 done  echo task2 start; sleep3; echo task2 done  echo task3 start; sleep3; echo task3 done  echo task4 start; sleep3; echo task4 done

For lightning-fast command running, putalias j=just in your shell'sconfiguration file.

Inbash, the aliased command may not keep the shell completion functionalitydescribed in the next section. Add the following line to your.bashrc to usethe same completion function asjust for your aliased command:

complete -F _just -o bashdefault -o default j

Shell completion scripts for Bash, Elvish, Fish, Nushell, PowerShell, and Zshare availablerelease archives.

Thejust binary can also generate the same completion scripts at runtimeusingjust --completions SHELL:

$ just --completions zsh> just.zsh

Please refer to your shell's documentation for how to install them.

macOS Note: Recent versions of macOS use zsh as the default shell. If you useHomebrew to installjust, it will automatically install the most recent copyof the zsh completion script in the Homebrew zsh directory, which the built-inversion of zsh doesn't know about by default. It's best to use this copy of thescript if possible, since it will be updated whenever you updatejust viaHomebrew. Also, many other Homebrew packages use the same location forcompletion scripts, and the built-in zsh doesn't know about those either. Totake advantage ofjust completion in zsh in this scenario, you can setfpath to the Homebrew location before callingcompinit. Note also that OhMy Zsh runscompinit by default. So your.zshrc file could look like this:

# Init Homebrew, which adds environment variableseval"$(brew shellenv)"fpath=($HOMEBREW_PREFIX/share/zsh/site-functions$fpath)# Then choose one of these options:# 1. If you're using Oh My Zsh, you can initialize it here# source $ZSH/oh-my-zsh.sh# 2. Otherwise, run compinit yourself# autoload -U compinit# compinit

just can print its own man page withjust --man. Man pages are written inroff, a venerable markuplanguage and one of the first practical applications of Unix. If you havegroff installed you can view the manpage withjust --man | groff -mandoc -Tascii | less.

A non-normative grammar ofjustfiles can be found inGRAMMAR.md.

Beforejust was a fancy Rust program it was a tiny shell script that calledmake. You can find the old version incontrib/just.sh.

If you want some recipes to be available everywhere, you have a few options.

just --global-justfile, orjust -g for short, searches the following paths,in-order, for a justfile:

• $XDG_CONFIG_HOME/just/justfile
• $HOME/.config/just/justfile
• $HOME/justfile
• $HOME/.justfile

You can put recipes that are used across many projects in a global justfile toeasily invoke them from any directory.

You can also adopt some of the following workflows. These tips assume you'vecreated ajustfile at~/.user.justfile, but you can put thisjustfileat any convenient path on your system.

If you want to call the recipes in~/.user.justfile by name, and don't mindcreating an alias for every recipe, add the following to your shell'sinitialization script:

forrecipein`just --justfile~/.user.justfile --summary`;doalias$recipe="just --justfile ~/.user.justfile --working-directory .$recipe"done

Now, if you have a recipe calledfoo in~/.user.justfile, you can just typefoo at the command line to run it.

It took me way too long to realize that you could create recipe aliases likethis. Notwithstanding my tardiness, I am very pleased to bring you this majoradvance injustfile technology.

If you'd rather not create aliases for every recipe, you can create a single alias:

alias .j='just --justfile ~/.user.justfile --working-directory .'

Now, if you have a recipe calledfoo in~/.user.justfile, you can just type.j foo at the command line to run it.

I'm pretty sure that nobody actually uses this feature, but it's there.

¯\_(ツ)_/¯

You can customize the above aliases with additional options. For example, ifyou'd prefer to have the recipes in yourjustfile run in your home directory,instead of the current directory:

alias .j='just --justfile ~/.user.justfile --working-directory ~'

The following export statement givesjust recipes access to local Node modulebinaries, and makesjust recipe commands behave more likescript entries inNode.jspackage.json files:

exportPATH:="./node_modules/.bin:"+env_var('PATH')

On Windows, functions that return paths will return\-separated paths. Whennot using PowerShell orcmd.exe these paths should be quoted to prevent the\s from being intepreted as character escapes:

ls:    echo'{{absolute_path(".")}}'

If you wish to include amod orimport source file in manyjustfileswithout needing to duplicate it, you can use an optionalmod orimport,along with a recipe to fetch the module source:

import?'foo.just'fetch:  curl https://raw.githubusercontent.com/casey/just/master/justfile > foo.just

Given the abovejustfile, after runningjust fetch, the recipes infoo.just will be available.

There is no shortage of command runners! Some more or less similar alternativestojust include:

• make: The Unix build toolthat inspiredjust. There are a few different modern day descendents of theoriginalmake, includingFreeBSD Make andGNU Make.
• task: A YAML-based command runner writtenin Go.
• maid: A Markdown-based command runnerwritten in JavaScript.
• microsoft/just: A JavaScript-basedcommand runner written in JavaScript.
• cargo-make: A command runner forRust projects.
• mmake: A wrapper aroundmake with a numberof improvements, including remote includes.
• robo: A YAML-based command runner written inGo.
• mask: A Markdown-based command runnerwritten in Rust.
• makesure: A simple and portable commandrunner written in AWK and shell.
• haku: A make-like command runnerwritten in Rust.

just welcomes your contributions!just is released under the maximallypermissiveCC0 publicdomain dedication and fallback license, so your changes must also be releasedunder this license.

just is written in Rust. Userustup to install a Rust toolchain.

just is extensively tested. All new features must be covered by unit orintegration tests. Unit tests are undersrc, live alongside the codebeing tested, and test code in isolation. Integration tests are in thetestsdirectory and test thejustbinary from the outside by invokingjust on a givenjustfile and set ofcommand-line arguments, and checking the output.

You should write whichever type of tests are easiest to write for your featurewhile still providing good test coverage.

Unit tests are useful for testing new Rust functions that are used internallyand as an aid for development. A good example are the unit tests which covertheunindent() function,used to unindent triple-quoted strings and backticks.unindent() has a bunchof tricky edge cases which are easy to exercise with unit tests that callunindent() directly.

Integration tests are useful for making sure that the final behavior of thejust binary is correct.unindent() is also covered by integration testswhich make sure that evaluating a triple-quoted string produces the correctunindented value. However, there are not integration tests for all possiblecases. These are covered by faster, more concise unit tests that callunindent() directly.

Existing integration tests are in two forms, those that use thetest! macroand those that use theTest struct directly. Thetest! macro, while oftenconcise, is less flexible and harder to understand, so new tests should use theTest struct. TheTest struct is a builder which allows for easily invokingjust with a givenjustfile, arguments, and environment variables, andchecking the program's stdout, stderr, and exit code .

1. Make sure the feature is wanted. There should be an open issue about thefeature with a comment from@casey saying thatit's a good idea or seems reasonable. If there isn't, open a new issue andask for feedback.

   There are lots of good features which can't be merged, either because theyaren't backwards compatible, have an implementation which wouldovercomplicate the codebase, or go againstjust's design philosophy.

2. Settle on the design of the feature. If the feature has multiple possibleimplementations or syntaxes, make sure to nail down the details in theissue.

3. Clonejust and start hacking. The best workflow is to have the code you'reworking on in an editor alongside a job that re-runs tests whenever a filechanges. You can run such a job by installingcargo-watch withcargo install cargo-watch and runningjust watch test.

4. Add a failing test for your feature. Most of the time this will be anintegration test which exercises the feature end-to-end. Look for anappropriate file to put the test in intests, or add a new fileintests and add amodstatement importing that file intests/lib.rs.

5. Implement the feature.

6. Runjust ci to make sure that all tests, lints, and checks pass.

7. Open a PR with the new code that is editable by maintainers. PRs oftenrequire rebasing and minor tweaks. If the PR is not editable by maintainers,each rebase and tweak will require a round trip of code review. Your PR maybe summarily closed if it is not editable by maintainers.

8. Incorporate feedback.

9. Enjoy the sweet feeling of your PR getting merged!

Feel free to open a draft PR at any time for discussion and feedback.

Here are some hints to get you started with specific kinds of new features,which you can use in addition to the contribution workflow above.

1. Write a new integration test intests/attributes.rs.

2. Add a new variant to theAttributeenum.

3. Implement the functionality of the new attribute.

4. Runjust ci to make sure that all tests pass.

Janus is a tool for checking whether a changetojust breaks or changes the interpretation of existingjustfiles. Itcollects and analyzes publicjustfiles on GitHub.

Before merging a particularly large or gruesome change, Janus should be run tomake sure that nothing breaks. Don't worry about running Janus yourself, Caseywill happily run it for you on changes that need it.

The minimum supported Rust version, or MSRV, is current stable Rust. It maybuild on older versions of Rust, but this is not guaranteed.

New releases ofjust are made frequently so that users quickly get access tonew features.

Release commit messages use the following template:

Release x.y.z- Bump version: x.y.z → x.y.z- Update changelog- Update changelog contributor credits- Update dependencies- Update version references in readme

make has some behaviors which are confusing, complicated, or make itunsuitable for use as a general command runner.

One example is that under some circumstances,make won't actually run thecommands in a recipe. For example, if you have a file calledtest and thefollowing makefile:

test:  ./test

make will refuse to run your tests:

$ maketestmake:`test' is up to date.

make assumes that thetest recipe produces a file calledtest. Since thisfile exists and the recipe has no other dependencies,make thinks that itdoesn't have anything to do and exits.

To be fair, this behavior is desirable when usingmake as a build system, butnot when using it as a command runner. You can disable this behavior forspecific targets usingmake's built-in.PHONY target name,but the syntax is verbose and can be hard to remember. The explicit list ofphony targets, written separately from the recipe definitions, also introducesthe risk of accidentally defining a new non-phony target. Injust, allrecipes are treated as if they were phony.

Other examples ofmake's idiosyncrasies include the difference between=and:= in assignments, the confusing error messages that are produced if youmess up your makefile, needing$$ to use environment variables in recipes,and incompatibilities between different flavors ofmake.

cargo build scripts have a prettyspecific use, which is to control howcargo builds your Rust project. Thismight include adding flags torustc invocations, building an externaldependency, or running some kind of codegen step.

just, on the other hand, is for all the other miscellaneous commands youmight run as part of development. Things like running tests in differentconfigurations, linting your code, pushing build artifacts to a server,removing temporary files, and the like.

Also, althoughjust is written in Rust, it can be used regardless of thelanguage or build system your project uses.

I personally find it very useful to write ajustfile for almost everyproject, big or small.

On a big project with multiple contributors, it's very useful to have a filewith all the commands needed to work on the project close at hand.

There are probably different commands to test, build, lint, deploy, and thelike, and having them all in one place is useful and cuts down on the time youhave to spend telling people which commands to run and how to type them.

And, with an easy place to put commands, it's likely that you'll come up withother useful things which are part of the project's collective wisdom, butwhich aren't written down anywhere, like the arcane commands needed for somepart of your revision control workflow, to install all your project'sdependencies, or all the random flags you might need to pass to the buildsystem.

Some ideas for recipes:

• Deploying/publishing the project

• Building in release mode vs debug mode

• Running in debug mode or with logging enabled

• Complex git workflows

• Updating dependencies

• Running different sets of tests, for example fast tests vs slow tests, orrunning them with verbose output

• Any complex set of commands that you really should write down somewhere, ifonly to be able to remember them

Even for small, personal projects it's nice to be able to remember commands byname instead of ^Reverse searching your shell history, and it's a huge boon tobe able to go into an old project written in a random language with amysterious build system and know that all the commands you need to do whateveryou need to do are in thejustfile, and that if you typejust somethinguseful (or at least interesting!) will probably happen.

For ideas for recipes, check outthis project'sjustfile,or some of thejustfilesout in the wild.

Anyways, I think that's about it for this incredibly long-winded README.

I hope you enjoy usingjust and find great success and satisfaction in allyour computational endeavors!

😸