How to Install Jujutsu on Debian: A Git-Compatible Version Control System

Jujutsu, whose binary is jj, is a version control system that keeps the ecosystem you already rely on while replacing the mental model that trips people up. It uses Git as a storage backend, so it works with existing repositories and remotes on GitHub, GitLab, and anywhere else, but it presents a cleaner, more forgiving interface built around changes rather than the staging area.

The two ideas that make Jujutsu click are the working-copy-as-a-commit and the operation log. Your working directory is always a real commit that Jujutsu amends automatically as you edit, so there is no separate git add step and no stashing dance. Every command you run is recorded in an operation log, which means jj undo can reverse almost anything, including operations Git would consider destructive.

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

What Makes Jujutsu Special?

  • 🔄 Git-compatible backend - Works directly with Git repositories and remotes, so you can adopt it incrementally.
  • 📸 Working copy is a commit - Changes are recorded automatically; there is no separate staging area.
  • ↩️ Undo anything - The operation log lets jj undo reverse any prior operation, including rebases.
  • 🌿 Anonymous branches - Work without naming a branch for every small change; bookmarks are optional.
  • 🧩 First-class conflicts - Conflicts are stored in commits, so you can resolve them whenever you like.
  • 🔍 Powerful revsets - A query language for selecting commits, inspired by Mercurial.
  • ✂️ Effortless history editing - jj split, jj squash, and jj rebase reshape history safely.
  • ⚡ Fast Rust implementation - A single, self-contained binary.

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 Jujutsu versions 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)
  • git installed if you plan to work with existing Git repositories

Step 1: Add the deb.griffo.io Repository

Add the signing key and the 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 each command does:

  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 bound to that key, auto-detecting your Debian codename.
  4. Update the package list - Refreshes APT so the new packages become 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 Jujutsu

Install the package with APT:

sudo apt install jujutsu

This installs the latest packaged Jujutsu along with any dependencies. The command you will use day to day is jj.

Step 4: Verify the Installation

Check the version, remembering the binary is jj:

jj --version

You should see output similar to:

jj 0.28.0

Before doing anything else, set your name and email so commits are attributed correctly:

jj config set --user user.name "Your Name"
jj config set --user user.email "you@example.com"

Getting Started with Jujutsu

Starting a Repository

You can begin a brand-new project or, more commonly, adopt Jujutsu inside an existing Git repository. The --colocate flag keeps a normal .git directory alongside jj, so both tools work side by side:

# Use jj inside an existing Git repository
cd my-existing-repo
jj git init --colocate

# Or start a completely new project
mkdir new-project && cd new-project
jj git init

You can also clone a remote directly:

jj git clone https://github.com/owner/repo.git

The Everyday Cycle

There is no staging area. You edit files, and your working copy is already a commit. Describe it and start the next one:

# See what has changed
jj st

# View the change graph
jj log

# Give the current change a message
jj describe -m "Add login form validation"

# Start a new change on top of the current one
jj new

jj new finalises the current change and opens a fresh working-copy commit, so you move forward one logical change at a time.

Editing History

Because every change is a commit, rewriting history is routine and safe:

# Split the current change into two
jj split

# Squash the current change into its parent
jj squash

# Move a change onto a different base
jj rebase -d main

# Undo the last operation, whatever it was
jj undo

The operation log underpins all of this. Inspect it with jj op log and restore an earlier state with jj op restore <id>.

Bookmarks and Pushing to Git

Jujutsu does not require a named branch for every change. When you are ready to publish, attach a bookmark (Jujutsu’s term for a Git branch) and push:

# Create a bookmark pointing at the current change
jj bookmark create my-feature

# Push it to the Git remote
jj git push --bookmark my-feature

# Fetch updates from the remote
jj git fetch

Anyone using plain Git sees my-feature as an ordinary branch.

Selecting Commits with Revsets

Revsets are a compact query language for choosing commits, used by many commands:

# Show only your own changes not yet on main
jj log -r 'mine() & ~::main'

# Describe a specific commit by its change id
jj describe -r abcde -m "Refine error handling"

Keeping Jujutsu Updated

Because Jujutsu 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 complement a version-control workflow:

  • lazygit - A terminal UI for Git that pairs well with a colocated jj repo.
  • helix - A modal editor that makes a great $EDITOR for commit messages.
  • fzf - A fuzzy finder for quickly locating files and revisions.
  • zellij - A terminal multiplexer for juggling multiple working views.

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

Git Tools Do Not See My Changes

If you initialised without --colocate, there is no visible .git directory for Git commands to use. Either run Git operations through jj git, or re-initialise with colocation to keep both tools in sync:

jj git init --colocate

Remember, too, that unpushed changes only reach the remote after jj git push.

Uninstalling

To remove Jujutsu:

sudo apt remove jujutsu

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

Jujutsu keeps everything you value about the Git ecosystem while replacing the parts that cause friction: no staging area, safe and undoable history editing, and conflicts you can resolve on your own schedule. On Debian, the deb.griffo.io repository is the easiest way to install a current build and keep it aligned with your system updates.

Colocate it into a repository you already have, and you can try Jujutsu without giving up Git for a single moment.

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 Jujutsu project.