How to Install just on Ubuntu: A Handy Command Runner for Your Projects

just is a lightweight command runner for the commands you keep re-typing on every project: build, test, lint, deploy, seed the database, tail the logs. You record them as recipes in a justfile and then invoke them by name with just <recipe>. It deliberately looks like make so the syntax feels familiar, but it strips out the build-system machinery that makes Makefiles awkward for plain task running.

The payoff is that each repository gains a small, self-documenting catalogue of commands. Anyone can run just --list to discover what a project supports, and the whole team ends up running identical commands rather than slightly different ad-hoc scripts.

Ubuntu does not carry just in its default archives, and compiling it means installing the Rust toolchain. The unofficial deb.griffo.io repository removes that friction by offering a current prebuilt package installable with apt.

Install the Latest just on Ubuntu: The Short Version

If you only came for the commands, this adds the repository and installs the latest just .deb package on Ubuntu:

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null
sudo apt update
sudo apt install just

The rest of this guide explains what each command does, how to verify the install, how to keep just up to date, and what to check when something goes wrong.

What Makes just Special?

  • 📝 Readable recipes - Named recipes in a plain justfile that reads like a task list.
  • 🔧 A runner, not a builder - Focused on executing commands, without make’s incremental-build surprises.
  • 🔤 Arguments and defaults - Recipes take positional parameters, defaults, and variadic arguments.
  • 🌐 Portable - Works on Ubuntu, macOS, and Windows and can call any interpreter.
  • 📋 Discoverable - just --list shows every recipe and its documentation comment.
  • 🧬 Variables and helpers - Interpolation, environment access, and string functions built in.
  • 📂 Polyglot recipes - Write a recipe body in Python, Node, Ruby, or any shebang language.
  • ⚡ Single fast binary - Compiled in Rust with no runtime dependencies.

Why Use the deb.griffo.io Repository?

  • Simple installs and upgrades through APT, exactly like any other Ubuntu package.
  • Automatic dependency management provided by the packaging.
  • Tracks upstream releases closely, so new just versions arrive promptly.
  • No source builds and no Rust toolchain to maintain.
  • Supports current Ubuntu releases (Jammy, Noble, and newer).

Prerequisites

Make sure the following are in place first:

  • An Ubuntu system (Jammy 22.04 LTS, Noble 24.04 LTS, or newer)
  • sudo privileges
  • curl installed (sudo apt install curl if needed)

Step 1: Add the deb.griffo.io Repository

Register the key and repository with APT:

# Create the keyrings directory
sudo install -d -m 0755 /etc/apt/keyrings

# Download and install the repository GPG key
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg

# Add the repository (auto-detects your distro codename)
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null

# Update the package list
sudo apt update

Step by step:

  1. Creates /etc/apt/keyrings with sensible permissions for repository keys.
  2. Downloads and de-armours the GPG key so APT can verify package signatures.
  3. Adds the sources entry bound to that key, auto-detecting your Ubuntu codename.
  4. Updates the package index so APT knows about the new packages.

Step 2: Update the Package List

If you skipped the final command above, run it now:

sudo apt update

Step 3: Install just

Install with APT:

sudo apt install just

APT downloads the latest packaged just and resolves any dependencies.

Step 4: Verify the Installation

Confirm the install by printing the version:

just --version

Expect output similar to:

just 1.34.0

Getting Started with just

Writing a justfile

Create a file called justfile at the top of your project. Each recipe is a name followed by indented commands:

# List available recipes when run with no arguments
default:
    @just --list

# Install dependencies
setup:
    npm install

# Run the dev server
dev:
    npm run dev

# Run tests
test:
    npm test

Run any recipe by name from anywhere inside the project:

just setup
just dev

Running just alone executes the first recipe, and just --list prints the full menu with descriptions.

Passing Arguments

Recipes take parameters, and parameters can have defaults:

# Tag a release, defaulting to patch
release level="patch":
    npm version {{level}}

# Run a single test file
test-file file:
    npx vitest run {{file}}

Invoke them with positional arguments:

just release minor
just test-file src/app.test.ts

Variables and dotenv

Declare variables and toggle settings at the top of the file:

# Load variables from a .env file
set dotenv-load

registry := "ghcr.io/acme"

publish:
    docker push {{registry}}/app:latest

set dotenv-load pulls values from a local .env, and {{registry}} interpolates the variable into the command.

Recipes in Any Language

Thanks to shebang support, a recipe can be written in a different interpreter entirely:

# A Node recipe embedded in the justfile
report:
    #!/usr/bin/env node
    const pkg = require("./package.json");
    console.log(`${pkg.name} v${pkg.version}`);

Useful Flags

These flags help in everyday use:

just --list                 # show every recipe
just --show dev             # print a recipe's source
just --choose               # pick a recipe interactively (pairs with fzf)
just --set registry local   # override a variable at runtime

Keeping just Updated

Since just comes from the repository, it updates with the rest of the system:

sudo apt update && sudo apt upgrade

Other Tools from deb.griffo.io

The repository ships several tools that slot neatly into a project workflow:

  • fzf - A fuzzy finder that backs just --choose for interactive selection.
  • lazygit - A terminal UI for Git alongside your recipes.
  • zoxide - A smarter cd for hopping between projects.
  • zellij - A multiplexer for running tasks side by side.

Troubleshooting

GPG or Key Errors

If APT reports the repository is not signed, re-import the key:

sudo rm -f /etc/apt/keyrings/deb.griffo.io.gpg
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
sudo apt update

Package Not Found

If APT cannot locate the just package:

  1. Re-run sudo apt update to refresh the index.
  2. Verify your Ubuntu release is supported (Jammy, Noble, or newer).
  3. Check the sources entry:
cat /etc/apt/sources.list.d/deb.griffo.io.list

just Cannot Find a justfile

just searches the current directory and every parent for a file named justfile or .justfile (case-insensitive). If it reports none found, confirm your location or point at one explicitly:

ls -la justfile
just --justfile ./ops/justfile deploy

Uninstalling

To remove just:

sudo apt remove just

To also remove the repository:

sudo rm -f /etc/apt/sources.list.d/deb.griffo.io.list
sudo rm -f /etc/apt/keyrings/deb.griffo.io.gpg
sudo apt update

Conclusion

just replaces scattered helper scripts and forgotten one-liners with a single, discoverable command menu per project, and it keeps everyone on the team running the same tasks the same way. On Ubuntu, installing it from deb.griffo.io gives you a current build that upgrades cleanly with apt upgrade.

Write a justfile once, and your project’s common commands are always just a just away.

Frequently Asked Questions

How do I install the latest just on Ubuntu?

Add the deb.griffo.io APT repository and its signing key, then run sudo apt install just. The repository tracks upstream just releases, so you get the latest packaged version rather than a build frozen when your distribution was released.

Is there a .deb package for just?

Yes. deb.griffo.io publishes just as a signed .deb for Ubuntu. You could download that .deb and install it by hand, but adding the repository is the better option: APT then resolves dependencies and picks up new versions on its own.

How do I update just to the latest version?

Run sudo apt update && sudo apt upgrade. Once just is installed from APT there is no separate updater to remember, since new releases arrive with the rest of your system updates.

How do I install just on Debian?

Exactly the same way; lsb_release -sc simply resolves to a different codename. There is a companion guide with the Debian specifics: How to install just on Debian.

Which Ubuntu releases are supported?

Jammy 22.04 LTS, Noble 24.04 LTS and newer. Because the repository line is built from lsb_release -sc, the matching suite is selected for you.

Resources

Disclaimer: The deb.griffo.io repository is an unofficial community project and is not affiliated with the official Debian or Ubuntu projects, or with the upstream just project.