# Jujutsu

> Jujutsu (jj) is a Git-compatible version control system designed to be simple and powerful, featuring automatic working-copy commits, first-class conflict handling, and an operation log with undo.

Jujutsu (command-line tool: `jj`) is an open-source version control system started by Martin von Zweigbergk as a hobby project in late 2019 and now developed as his full-time project at Google, with several other Googlers contributing. It uses Git repositories as its default storage backend, making it interoperable with GitHub, GitLab, and other Git forges today. The project is hosted under the `jj-vcs` GitHub organization and is licensed under Apache 2.0.

## What It Is

Jujutsu is a CLI-based VCS that draws inspiration from Git, Mercurial/Sapling, and Darcs while introducing its own innovations. Its core design separates the user interface and version control algorithms from the underlying storage system, allowing multiple possible backends. The current production-ready backend stores data in Git repositories using the `gitoxide` Rust library, so commits created with `jj` look like regular Git commits and can be pushed to any Git remote.

## Key Design Choices

Several design decisions distinguish Jujutsu from Git:

- **Working copy as a commit**: File changes are automatically snapshotted as a real commit and amended on every subsequent change, eliminating the need for `git stash` or a staging area/index.
- **Operation log and undo**: Every repository operation—commits, pulls, pushes—is recorded with a snapshot of repo state, enabling easy undo of any past operation, not just the most recent.
- **Automatic rebase**: Modifying any commit automatically rebases all descendants onto the updated version, transparently combining the behavior of `git rebase --update-refs` and `git rerere`.
- **First-class conflicts**: Conflicts are stored as first-class objects in commits rather than as blocking textual diffs. Operations succeed even when conflicts exist, and conflict resolutions propagate automatically through descendants.
- **Revset language**: A Mercurial-inspired expression language for selecting sets of commits, enabling powerful history queries.
- **Anonymous branches**: Like Mercurial, branches are anonymous by default—no need to name every small change.

## Architecture and Storage Model

The internal architecture abstracts the VCS algorithms from the storage layer. While the Git backend is the only production-ready option today, the design explicitly supports alternative backends such as Mercurial, Breezy, or cloud-based systems like Google's Piper/CitC. Bookmarks (branches) and higher-level metadata are stored outside of Git in custom storage, while commits and file content live in the Git object store. An experimental feature supports safe concurrent replication via tools like rsync or Dropbox without risking repository corruption.

## Workflow and Commands

Jujutsu provides a rich set of history-rewriting primitives:

- `jj describe` — edit the commit message of any commit, not just HEAD
- `jj diffedit` — edit the diff of a commit without checking it out
- `jj split` — split one commit into two
- `jj squash -i --from X --into Y` — move part of a commit's changes to another commit
- `jj restore` — restore files from any commit into any commit
- `jj file annotate` — equivalent to `git blame` (added in v0.24)

Colocated workspaces allow `jj` and `git` commands to be used interchangeably in the same directory.

## Update: v0.41.0

The latest release is **v0.41.0**, published on May 7, 2026. The repository moved to the `jj-vcs` GitHub organization in December 2024. Version 0.24 (November 2024) added `jj file annotate`. The project is pre-1.0 and the README notes there will be backward-incompatible on-disk format changes before 1.0, though transparent upgrades are provided where possible. A mandatory CLA is required for contributors; it does not transfer copyright to Google. The README explicitly states this is not a supported Google product—support is community-provided.

## Features
- Git-compatible storage backend using gitoxide Rust library
- Working copy automatically committed as a real commit
- Operation log recording every repository action with undo support
- Automatic rebase of descendants on commit modification
- First-class conflict objects stored in commits
- Conflict resolution propagated automatically through descendants
- Revset language for selecting commits
- Anonymous branches (no mandatory branch naming)
- jj describe: edit commit message of any commit
- jj diffedit: edit commit diff without checkout
- jj split: split a commit into two
- jj squash: move partial changes between commits
- jj file annotate: equivalent to git blame
- Colocated workspaces supporting both jj and git commands
- Experimental safe concurrent replication via rsync/Dropbox
- Configurable template language for output formatting
- Immutable revsets to prevent accidental edits
- Bundled merge and diff editor for all platforms

## Integrations
Git, GitHub, GitLab, Gerrit, Mercurial (backend concept), Breezy (backend concept), Dropbox (experimental replication), rsync (experimental replication)

## Platforms
WINDOWS, MACOS, LINUX, API, CLI

## Pricing
Open Source

## Version
v0.41.0

## Links
- Website: https://jj-vcs.dev
- Documentation: https://docs.jj-vcs.dev/latest/
- Repository: https://github.com/jj-vcs/jj
- EveryDev.ai: https://www.everydev.ai/tools/jujutsu-jj