Glossary — Jujutsu (jj)

#

@ (at symbol)

The revset symbol representing the current working-copy commit, usable in any jj command wherever a revision is expected.

A

absorb

A command (jj absorb) that automatically analyzes changed lines in your working copy, determines which prior commit introduced each line, and squashes each hunk into the appropriate ancestor commit.

auto-rebase

jj's behavior of automatically rebasing all descendant commits whenever an ancestor commit is modified, eliminating the need for manual rebase propagation.

B

bookmark

jj's equivalent of a git branch — a named pointer to a commit that exists solely for remote interaction (pushing/fetching) and is not required for local work.

C

change ID

A stable identifier assigned to each commit that survives amends, rebases, and rewrites, unlike the commit hash which changes whenever content changes.

colocated mode

A repository configuration where jj's .jj/ directory exists alongside an existing .git/ directory, allowing both jj and git commands to operate on the same repo simultaneously.

commit ID

The content-addressable SHA hash of a commit (same concept as git), which changes every time the commit's content is modified.

conflicts as data

jj's approach of storing merge conflicts inside the commit itself rather than blocking operations, allowing you to defer resolution and continue working.

D

describe

The command (jj describe) that sets or updates a commit message on an already-existing commit, replaceable at any time since commits exist before their messages are written.

E

edit

The command (jj edit) that moves your working copy into an existing commit so that any file changes amend that commit in place, with descendants auto-rebasing.

I

immutable commit

A commit marked with ◆ in jj log that cannot be edited, typically because it has already been pushed to a remote or is otherwise protected.

J

jj new

The command that creates a fresh empty commit on top of the current working-copy commit, signaling "I'm done with this change" and providing a clean canvas for the next one.

O

operation

An atomic, recorded mutation to the repository state — every jj command that changes the repo creates one, forming the basis for undo and time-travel restoration.

operation log

An immutable, human-readable history of every repository mutation (jj op log), replacing git's per-ref reflog with a single atomic timeline that never expires.

R

revset

jj's composable query language for selecting commits (e.g., @, @-, trunk()..@), unifying what git splits across HEAD~N, branch names, ranges, and reflog syntax.

root commit

An empty commit at the bottom of every jj repository's history that serves as the universal ancestor of all other commits, anchoring the DAG.

S

split

The command (jj split) that breaks a single commit into two sequential commits by letting you choose which changes go in each, workable on any commit in the stack.

squash

The command (jj squash) that moves changes from the current commit into its parent (or any specified ancestor with --into), optionally discarding the source commit if it becomes empty.

staging area

Git's index/staging concept that is entirely eliminated in jj — all file changes are immediately part of the working-copy commit with no intermediate step.

T

trunk()

A revset expression that refers to the main branch tip (usually main@origin), used as the standard anchor point for rebasing local work.

W

working-copy commit

The single commit (marked with @) that you are currently editing — in jj, the working copy IS a commit, and all file changes automatically amend it without any add or stage step.