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

just is a command runner that saves and runs the project-specific commands you would otherwise keep in a scratch file or a half-remembered shell alias. You write your recipes in a justfile, then run them by name with just <recipe>. It borrows the familiar look of make but drops the parts that make Makefiles painful for task running, so there is no .PHONY, no accidental incremental-build behaviour, and no tab-versus-space landmines.

The appeal is simple: every project ends up with a small, self-documenting menu of commands. New contributors run just --list and immediately see how to build, test, lint, and deploy, and everyone runs the same commands the same way.

just is not available in the official Debian repositories, and building it means bringing in a Rust toolchain. The unofficial deb.griffo.io repository provides an up-to-date prebuilt package you can install with apt.

What Makes just Special?

• 📝 Simple recipe syntax - Define named recipes in a plain justfile that reads like a to-do list.
• 🔧 Not a build system - Purpose-built for running commands, with none of make’s incremental-build baggage.
• 🔤 Parameters and defaults - Recipes accept arguments, defaults, and variadic parameters.
• 🌐 Cross-shell and cross-platform - Runs on Linux, macOS, and Windows, and can invoke any interpreter.
• 📋 Self-documenting - just --list prints every recipe with its doc comment.
• 🧬 Variables and functions - Interpolation, environment access, and built-in string helpers.
• 📂 Per-language recipes - Write a recipe body in Python, Node, or any shebang-supported language.
• ⚡ Fast Rust binary - A single dependency-free executable.

Why Use the deb.griffo.io Repository?

• Easy installation and updates through the standard APT workflow.
• Automatic dependency management handled by the package.
• Always tracks upstream releases, so new just features arrive quickly.
• No compiling from source and no Rust toolchain to install.
• Works across supported Debian releases (Bookworm, Trixie, and Sid).

Prerequisites

Before you begin, make sure you have:

• A Debian-based system (Bookworm 12, Trixie 13, or Sid)
• sudo privileges
• curl installed (sudo apt install curl if it is missing)

Step 1: Add the deb.griffo.io Repository

Add the signing key and repository to 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

What the commands do:

1. Create the keyrings directory - Ensures /etc/apt/keyrings exists with correct permissions.
2. Install the GPG key - Downloads and de-armours the signing key for signature verification.
3. Add the repository - Writes a sources entry tied to that key, auto-detecting your Debian codename.
4. Update the package list - Refreshes APT so the new packages are visible.

Step 2: Update the Package List

If you did not run the last command above, run it now:

sudo apt update

Step 3: Install just

Install the package with APT:

sudo apt install just

This installs the latest packaged just along with any dependencies.

Step 4: Verify the Installation

Check the version with:

just --version

You should see output similar to:

just 1.34.0

Getting Started with just

Your First justfile

Create a file named justfile in the root of your project. Recipes are defined by name, with their commands indented beneath:

# Show all available recipes
default:
    @just --list

# Build the project
build:
    cargo build --release

# Run the test suite
test:
    cargo test

# Format and lint
check:
    cargo fmt --check
    cargo clippy -- -D warnings

Run a recipe by name from anywhere in the project tree:

just build
just test

Running just with no arguments runs the first recipe (here default), and just --list prints the full menu with doc comments.

Recipes with Parameters

Recipes accept arguments, including defaults:

# Greet someone (defaults to "world")
greet name="world":
    echo "Hello, {{name}}!"

# Deploy to a named environment
deploy env:
    ./scripts/deploy.sh {{env}}

Call them with positional arguments:

just greet Debian
just deploy staging

Variables and Settings

You can declare variables and settings at the top of the justfile:

# Load a .env file if present
set dotenv-load

# A reusable variable
version := "1.0.0"

release:
    echo "Releasing version {{version}}"

set dotenv-load reads a .env file so recipes can use those values, and {{version}} interpolates the variable.

Recipes in Other Languages

Because recipes support shebangs, a recipe body can be written in any interpreter:

# A recipe written in Python
count-lines:
    #!/usr/bin/env python3
    import pathlib
    total = sum(len(p.read_text().splitlines()) for p in pathlib.Path("src").rglob("*.py"))
    print(f"{total} lines of Python")

Handy Command-Line Flags

A few flags make daily use smoother:

just --list                 # list every recipe
just --show build           # print the source of a recipe
just --choose               # pick a recipe interactively (needs a chooser like fzf)
just --justfile ../justfile # run a justfile from elsewhere

Keeping just Updated

Because just came from the repository, updates are part of routine maintenance:

sudo apt update && sudo apt upgrade

Other Tools from deb.griffo.io

The repository packages several tools that fit nicely into a project workflow:

• fzf - A fuzzy finder that powers just --choose for interactive recipe selection.
• lazygit - A terminal UI for Git to complement your just recipes.
• zoxide - A smarter cd to jump between project directories.
• zellij - A terminal multiplexer for running long tasks side by side.

Troubleshooting

GPG or Key Errors

If APT reports the repository is not signed, re-add 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 install just cannot find the package:

1. Run sudo apt update again to refresh the index.
2. Confirm your Debian release is supported (Bookworm, Trixie, or Sid).
3. Inspect the sources entry:

cat /etc/apt/sources.list.d/deb.griffo.io.list

“No justfile found”

If just complains it cannot find a justfile, remember that it searches the current directory and walks upward. Confirm you are inside the project and that the file is named justfile or .justfile (the name is case-insensitive):

ls -la justfile
just --justfile ./path/to/justfile build

Uninstalling

To remove just:

sudo apt remove just

To remove the repository as well:

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 gives every project a tidy, discoverable set of commands without the ceremony of a build system, and it quickly becomes the first place collaborators look to understand a codebase. On Debian, the deb.griffo.io repository is the cleanest route to a current build that updates with the rest of your system.

Add a justfile, add the repository, and your everyday project commands become a single just away.

Resources

• just Manual
• just GitHub Repository
• deb.griffo.io Repository

---

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.