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 syntax inspired 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 along with their source context.

• Recipes can acceptcommand line arguments.

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

• justloads.env files, making it easy to populate environment 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 that contains thejustfile.

• Andmuch more!

If you need help withjust please feel free to open an issue or ping me onDiscord. Feature requests and bug reports are always 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 the shell 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 use PowerShell, launchjust with--shell powershell.exe --shell-arg -c.

(PowerShell is installed by default on Windows 7 SP1 and Windows Server 2008 R2 S1 and later, andcmd.exe is quite fiddly, so PowerShell is recommended for most 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 the latest 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.

Withextractions/setup-just:

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

Withtaiki-e/install-action:

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

AnRSS feed ofjust releases is availablehere.

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

just is a great, more robust alternative to npm scripts. If you want to includejust in the dependencies of a Node.js application,just-install will install a local, platform-specific binary as part of thenpm install command. This removes the need for every developer to installjust independently using one of the processes mentioned above. After installation, thejust command will work in npm scripts or with npx. It's great for teams who 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 to backwards compatibility and stability.

Future releases will not introduce backwards incompatible changes that make existingjustfiles stop working, or break working invocations of the command-line interface.

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

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

Features that aren't yet ready for stabilization are gated behind the--unstable flag. Features enabled by--unstable may change in backwards incompatible ways at any time.

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

Thevim-just plugin provides syntax highlighting 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

vim-just is also available fromvim-polyglot, a multi-language Vim plugin.

tree-sitter-just is anNvim Treesitter plugin for Neovim.

Vim's built-in makefile syntax highlighting isn't perfect forjustfiles, but it'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 a per-file basis:

# vim: set ft=make :

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

justl provides commands for executing and listing recipes.

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

# Local Variables:# mode: makefile# End:

An extension for VS Code byskellock isavailable here (repository), but is no longer actively developed.

You can install it from the command line by running:

code --install-extension skellock.just

An more recently active fork bysclu1034 is availablehere.

A plugin for JetBrains IDEs bylinux_china isavailable here.

Kakoune supportsjustfile syntax highlighting out of the box, thanks to TeddyDD.

TheJust package bynk9 withjust syntax and some other tools is available onPackageControl.

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

Seethe installation section for how to installjust on your computer. Try runningjust --version to make sure that it's installed correctly.

For an overview of the syntax, check outthis cheatsheet.

Oncejust is installed and working, create a file namedjustfile in the root 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 directory and 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 the name.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 starting with@, 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 command line:

$ 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 that depends on them:

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

A variety of examplejustfiles can be found in theexamples directory.

Whenjust is invoked without a recipe, it runs the first recipe in thejustfile. 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:lintbuildtestbuild:  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 yourjustfile that lists the available recipes:

default:  just --list

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

$ just --listAvailable recipes:    buildtest    deploy    lint

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, you can use this as your default recipe:

default:@just --list

Note that you may need to add--justfile {{justfile()}} to the line above above. Without it, if you executedjust -f /some/distant/justfile -d . orjust -f ./non-standard-justfile, the plainjust --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 aNo justfile found error.

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 newline following it, so it should contain a newline if non-empty. It works this way so you can suppress the heading line entirely by passing the empty string:

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

Aliases allow recipes to be invoked with alternative names:

aliasb:=buildbuild:  echo'Building!'

$ just bbuildecho'Building!'Building!

Settings control interpretation and execution. Each setting may be specified at most 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 with the 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

Ifdotenv-load istrue, a.env file will be loaded if present. Defaults tofalse.

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

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

$ just foo goodbyehellogoodbye

Ifpositional-arguments istrue, 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:

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

Will produce the following output:

$ just foo hellofoohello

When using ansh-compatible shell, such asbash orzsh,$@ 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:

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

Running it withtwo arguments:

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

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

# 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 need an 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.just for a justfile that uses PowerShell on all platforms.

set windows-powershell uses the legacypowershell.exe binary, and is no longer recommended. See thewindows-shell setting above for a more flexible way 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, andhas cross-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

Ifdotenv-load is set,just will load environment variables from a file named.env. This file can be located in the same directory as yourjustfile or in a parent directory. These variables are environment variables, notjust variables, and so must 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

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

tmpdir:=`mktemp`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 not supported 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 an interpolation:

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 by triple single- or triple double-quotes, are supported. Indented string lines are stripped of leading whitespace common to all non-blank lines:

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

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.

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

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 writing recipes.

• arch() — Instruction set architecture. Possible values are:"aarch64","arm","asmjs","hexagon","mips","msp430","powerpc","powerpc64","s390x","sparc","wasm32","x86","x86_64", and"xcore".
• 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-platformjustfiles that work on various operating systems. For an example, seecross-platform.just file.

• env_var(key) — Retrieves the environment variable with namekey, aborting if 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 with namekey, returningdefault if it is not present.

• 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 the currentjustfile.

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

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

• just_executable() - Absolute path to thejust executable.

For example:

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

$ justThe executable is at: /bin/just

• quote(s) - Replace all single quotes with'\'' and prepend and append single quotes tos. This is sufficient to escape special characters for many shells, including most Bourne shell descendants.
• replace(s, from, to) - Replace all occurrences offrom ins toto.
• replace_regex(s, regex, replacement) - Replace all occurrences ofregex ins toreplacement. Regular expressions are provided by theRustregex crate. See thesyntax documentation for usage examples.
• 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 uppercase and 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 working directory.absolute_path("./bar.txt") in directory/foo is/foo/bar.txt.
• extension(path) - Extension ofpath.extension("/foo/bar.txt") istxt.
• file_name(path) - File name ofpath with any leading directory components removed.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 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. 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 entity andfalse otherwise. Traverses symbolic links, and returnsfalse if the path is inaccessible or points to a broken symlink.

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

• sha256(string) - Return the SHA-256 hash ofstring as a hexadecimal string.
• sha256_file(path) - Return the SHA-256 hash of the file atpath as a hexadecimal string.
• uuid() - Return a randomly generated UUID.

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:

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

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 same manner 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 future upgrade.

if/else expressions evaluate different branches depending on if two expressions 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 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.

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 will be 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 as environment 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 environment variables.

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

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

$ justHOME is'/home/myuser'

just will load environment variables from a.env file ifdotenv-load is set. The variables in the file will be available as environment variables to the recipes. Seedotenv-integration for more information.

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 with the 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 in parentheses 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 joins must 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+ or a* before the argument name:

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

Variadic parameters prefixed with+ acceptone or more arguments and expand to 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 and expand to a string containing those arguments separated by spaces, or an empty string if no arguments are present:

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

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

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

{{…}} substitutions may need to be quoted if they contain spaces. For example, 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, which will 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

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

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 you can 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 invocation ofjust: Assignments will be recalculated, dependencies might run twice, and command 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. Keep in mind that different operating systemssplit shebang lines differently.

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.

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 useful features 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 from Unix-style paths to Windows-style paths usingcygpath, a utility that ships withCygwin.

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 without being translated. This is useful ifcygpath is not available, or you wish to pass a Windows-style path to the interpreter.

Recipe lines are interpreted by the shell, notjust, so it's not possible to setjust 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. Every recipe line is run by a new shell instance, so variables set in one line won't be 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 recipe bodies are extracted and run as scripts, so a single shell instance will run the 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 to share environment variables between recipes.

Some tools, likePython's venv, require loading environment variables in order to work, making them challenging to use withjust. As a workaround, you can execute the virtual environment binaries 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 working directory 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 as the command you want to run:

foo:  cd bar&& pwd

The other is to use a shebang recipe. Shebang recipe bodies are extracted and run 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 of a recipe's lines must have the same indentation, but different recipes in the samejustfile may use different indentation.

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

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

The extra leading whitespace before the second line of theconditional recipe will 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 newlines with slashes, or add a shebang to your recipe. Some examples of multi-line constructs 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

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

$ 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

Runjust --help to see all the options.

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 or aliases 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 as dependencies of other recipes.

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

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

Now only the lines starting with@ will be echoed:

$ j quiethellogoodbye# all done!

Shebang recipes are quiet by default:

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

$ just fooFoo!

Adding@ to a shebang recipe name makesjust print the recipe before executing 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] attribute. You may findthis especially useful with a recipe that recipe 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 recipes to run. Choosers should read lines containing recipe names from standard input and 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 and aliases are also skipped.

The chooser can be overridden with the--chooser flag. If--chooser is not given, thenjust first checks if$JUST_CHOOSER is set. If it isn't, then the 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 the chooser isfzf, it will be invoked withsh -cu 'fzf', and if the shell, or the shell arguments are overridden, the chooser invocation will respect those overrides.

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

default:@just --choose

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

1. The argument is split at the last/.

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

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

This may seem a little strange, but it's useful if you wish to run a command in ajustfile 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 the default 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.

The!include directive, currently unstable, can be used to include theverbatim text of another file.

If you have the followingjustfile:

!include foo/bar.justa: 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 --unstable bB$ just --unstable aBA

The!include directive path can be absolute or relative to the location ofthe justfile containing it.!include directives must appear at the beginningof a line.

Justfiles are insensitive to order, so included files can reference variablesand recipes defined after the!include directive.

!include directives are only processed before the first non-blank,non-comment line.

Included files can themselves contain!include directives, which areprocessed recursively.

just looks forjustfiles namedjustfile and.justfile, which can be used 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 the script 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 the location 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. The previous examples have only been tested on macOS. On Linux, you may need to pass the-S flag toenv:

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

The--dump command can be used with--dump-format json to print a JSON representation of ajustfile. The JSON format is currently unstable, so the--unstable flag is required.

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 quotes are not preserved, andtouch will receive two arguments.

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

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 want if the value ofargument contains single quotes.

Thepositional-arguments setting causes all arguments to be passed as positional 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$2, but works for all possible values ofargument, including those 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 those with double quotes.

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

1. The--shell and--shell-arg command line options. Passing either of these 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 shell for all other platforms.

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

Tools that pair nicely withjust include:

• watchexec — a simple tool that watches a path and runs a command whenever it detects modifications.

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

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

complete -F _just -o bashdefault -o default j

Shell completion scripts for Bash, Zsh, Fish, PowerShell, and Elvish are available in thecompletions directory. Please refer to your shell's documentation for how to install them.

Thejust binary can also generate the same completion scripts at runtime, using the--completions command:

$ just --completions zsh> just.zsh

macOS Note: Recent versions of macOS use zsh as the default shell. If you use Homebrew to installjust, it will automatically install the most recent copy of the zsh completion script in the Homebrew zsh directory, which the built-in version of zsh doesn't know about by default. It's best to use this copy of the script if possible, since it will be updated whenever you updatejust via Homebrew. Also, many other Homebrew packages use the same location for completion scripts, and the built-in zsh doesn't know about those either. To take advantage ofjust completion in zsh in this scenario, you can setfpath to the Homebrew location before callingcompinit. Note also that Oh My 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

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 inextras/just.sh.

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

First, create ajustfile in~/.user.justfile with some recipes.

If you want to call the recipes in~/.user.justfile by name, and don't mind creating an alias for every recipe, add the following to your shell's initialization 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 like this. Notwithstanding my tardiness, I am very pleased to bring you this major advance 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, if you'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 module binaries, and makesjust recipe commands behave more likescript entries in Node.jspackage.json files:

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

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

• make: The Unix build tool that inspiredjust. There are a few different modern day descendents of the originalmake, includingFreeBSD Make andGNU Make.
• task: A YAML-based command runner written in Go.
• maid: A Markdown-based command runner written in JavaScript.
• microsoft/just: A JavaScript-based command runner written in JavaScript.
• cargo-make: A command runner for Rust projects.
• mmake: A wrapper aroundmake with a number of improvements, including remote includes.
• robo: A YAML-based command runner written in Go.
• mask: A Markdown-based command runner written in Rust.
• makesure: A simple and portable command runner written in AWK and shell.
• haku: A make-like command runner written in Rust.

just welcomes your contributions!just is released under the maximally permissiveCC0 public domain dedication and fallback license, so your changes must also be released under this license.

Janus is a tool that collects and analyzesjustfiles, and can determine if a new version ofjust breaks or changes the interpretation of existingjustfiles.

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

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

New releases ofjust are made frequently so that users quickly get access to new 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 man page- Update version references in readme

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

One example is that under some circumstances,make won't actually run the commands in a recipe. For example, if you have a file calledtest and the following 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 this file exists and the recipe has no other dependencies,make thinks that it doesn't have anything to do and exits.

To be fair, this behavior is desirable when usingmake as a build system, but not when using it as a command runner. You can disable this behavior for specific targets usingmake's built-in.PHONY target name, but the syntax is verbose and can be hard to remember. The explicit list of phony targets, written separately from the recipe definitions, also introduces the risk of accidentally defining a new non-phony target. Injust, all recipes 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 you mess up your makefile, needing$$ to use environment variables in recipes, and incompatibilities between different flavors ofmake.

cargo build scripts have a pretty specific use, which is to control howcargo builds your Rust project. This might include adding flags torustc invocations, building an external dependency, or running some kind of codegen step.

just, on the other hand, is for all the other miscellaneous commands you might run as part of development. Things like running tests in different configurations, 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 the language or build system your project uses.

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

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

There are probably different commands to test, build, lint, deploy, and the like, and having them all in one place is useful and cuts down on the time you have 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 with other useful things which are part of the project's collective wisdom, but which aren't written down anywhere, like the arcane commands needed for some part of your revision control workflow, install all your project's dependencies, or all the random flags you might need to pass to the build system.

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, or running them with verbose output

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

Even for small, personal projects it's nice to be able to remember commands by name instead of ^Reverse searching your shell history, and it's a huge boon to be able to go into an old project written in a random language with a mysterious build system and know that all the commands you need to do whatever you need to do are in thejustfile, and that if you typejust something useful (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 all your computational endeavors!

😸