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

Jujutsu, used through the jj command, is a version control system that layers a simpler, safer workflow on top of Git’s storage format. Because it speaks Git under the hood, it interoperates seamlessly with existing repositories and remotes on GitHub, GitLab, Forgejo, and beyond, yet it drops the concepts that most often confuse newcomers, chiefly the staging area and the fear of losing work.

Two design choices define the experience. First, your working copy is itself a commit that Jujutsu updates automatically as you type, so there is no git add and no stashing. Second, an operation log records every command you run, which makes jj undo able to reverse practically anything, even a rebase that would be irreversible in Git.

Ubuntu does not include Jujutsu in its default archives, and building it from source pulls in the Rust toolchain. The unofficial deb.griffo.io repository removes that hurdle with a current prebuilt package you can install using apt.

What Makes Jujutsu Special?

🔄 Built on Git - Reads and writes Git repositories and remotes, so adoption can be gradual.
📸 No staging area - The working copy is a commit that records your edits automatically.
↩️ Reversible operations - The operation log lets jj undo roll back any command you ran.
🌿 Optional branch names - Bookmarks are only needed when you publish, not for every change.
🧩 Conflicts stored in commits - Rebases never block; resolve conflicts on your own schedule.
🔍 Revset queries - Select commits precisely with an expressive query language.
✂️ Safe history rewriting - jj split, jj squash, and jj rebase reshape history without fear.
⚡ Rust binary - Fast and distributed as a single executable.

Why Use the deb.griffo.io Repository?

Simple installs and upgrades through APT, just like any Ubuntu package.
Automatic dependency management handled by the packaging.
Tracks upstream releases closely, so updates land promptly.
No source builds and no Rust toolchain to install or 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)
git installed if you intend to work with existing Git repositories

Step 1: Add the deb.griffo.io Repository

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

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

Step 2: Update the Package List

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

sudo apt update

Step 3: Install Jujutsu

Install with APT:

sudo apt install jujutsu

APT downloads the latest packaged Jujutsu and resolves any dependencies. The binary is jj.

Step 4: Verify the Installation

Confirm the install, keeping in mind the command is jj:

jj --version

Expect output similar to:

jj 0.28.0

Set your identity before recording any changes:

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

Getting Started with Jujutsu

Adopting an Existing Repository

The most common way to start is to layer Jujutsu onto a repository you already have. The --colocate flag keeps a working .git directory next to jj, so Git commands continue to function:

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

To begin fresh or clone from a remote instead:

# A brand-new project
mkdir new-project && cd new-project
jj git init

# Clone an existing remote
jj git clone https://github.com/owner/repo.git

Recording Changes

There is no staging step. You edit files and the working copy is already a commit; you simply describe it and move on:

# Inspect the current change
jj st

# Look at the graph of changes
jj log

# Set the message for the current change
jj describe -m "Implement pagination"

# Finish it and open the next change
jj new

jj new closes off the current change and starts a fresh working-copy commit on top of it.

Reshaping History Safely

With every change stored as a commit, editing history is a normal, reversible activity:

# Break the current change into two
jj split

# Fold the current change into its parent
jj squash

# Re-base the current change onto main
jj rebase -d main

# Undo whatever you just did
jj undo

Everything is backed by the operation log: browse it with jj op log and jump back with jj op restore <id>.

Publishing with Bookmarks

Jujutsu keeps most changes on anonymous branches. When you want to share work, create a bookmark (a Git branch) and push it:

# Point a bookmark at the current change
jj bookmark create feature/pagination

# Push the bookmark to the remote
jj git push --bookmark feature/pagination

# Pull down remote updates
jj git fetch

Collaborators on plain Git simply see feature/pagination as a regular branch.

Querying with Revsets

Many commands accept a revset, a small query language for selecting commits:

# Your changes that are not yet on main
jj log -r 'mine() & ~::main'

# Target a specific change by id
jj rebase -s xyz -d main

Keeping Jujutsu Updated

Since Jujutsu 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 complement version control:

lazygit - A terminal UI for Git alongside a colocated jj repo.
helix - A modal editor that works well as your commit-message $EDITOR.
fzf - A fuzzy finder for locating files and revisions fast.
zellij - A multiplexer for managing several working views.

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 find the jujutsu package:

Re-run sudo apt update to refresh the index.
Verify your Ubuntu release is supported (Jammy, Noble, or newer).
Check the sources entry:

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

Git Does Not See jj Changes

If you ran jj git init without --colocate, there is no ordinary .git directory for Git tools to read. Either use jj git subcommands, or re-initialise with colocation so both tools stay in step:

jj git init --colocate

Also remember that changes reach a remote only after jj git push.

Uninstalling

To remove Jujutsu:

sudo apt remove jujutsu

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

Jujutsu preserves your investment in the Git ecosystem while smoothing away its rough edges: no staging area, an undo that actually undoes, and conflicts that never block a rebase. On Ubuntu, installing it from deb.griffo.io gives you a current build that upgrades cleanly through apt upgrade.

Colocate it into an existing project and you can explore Jujutsu risk-free, with every Git tool you already use still at your side.

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.