explaingit

jj-vcs/jj

📈 Trending★ 28,583RustAudience · developerComplexity · 3/5ActiveLicenseSetup · moderate

TLDR

A version control system that works like Git but with a simpler interface, automatic commits, no staging, anonymous branches, and automatic rebasing when you edit history.

Mindmap

mindmap
  root((repo))
    What it does
      Git alternative
      Tracks file changes
      Automatic commits
      Auto-rebasing
    Key features
      No staging area
      Anonymous branches
      Conflict tracking
      Operation log
    Tech stack
      Rust
      Git storage
      CLI tool
    Use cases
      Solo developers
      Large teams
      Complex histories
    Workflow
      Simpler than Git
      GitHub compatible
      Undo mistakes easily

Things people build with this

USE CASE 1

Replace Git as your daily version control tool with a simpler command-line interface and automatic commit tracking.

USE CASE 2

Manage complex project histories where commits are automatically rebased when you edit older changes.

USE CASE 3

Work on large team projects while keeping your code on GitHub or GitLab without changing your hosting platform.

USE CASE 4

Undo mistakes easily by reviewing and replaying actions from the operation log instead of manually fixing history.

Tech stack

RustGit

Getting it running

Difficulty · moderate Time to first run · 30min

Rust compilation required; no external services needed but build time may vary by system.

Use freely for any purpose including commercial. Keep the notice and disclose changes to the patent grant.

In plain English

Jujutsu (command: jj) is a version control system, software that tracks changes to files in a project over time, lets you collaborate with others, and lets you go back to earlier versions of your code. It is an alternative to Git, the most widely used version control tool, but with a different and friendlier interface. The key difference is in how Jujutsu rethinks the workflow. In Git, you must explicitly "stage" changes before committing them, and managing branching can become complex. Jujutsu simplifies this: your working directory is always automatically recorded as a commit so you never lose work; there is no staging area; branches are anonymous so you don't need to name every small change; and when you modify an older commit, every newer commit built on top of it is automatically rebased so your history stays consistent. Conflicts are tracked as first-class objects, meaning they can be resolved automatically as changes propagate. Jujutsu stores its data in a regular Git repository as the underlying storage layer, so it is compatible with Git-hosting platforms and can be used alongside existing Git-based workflows. You keep the ecosystem (GitHub, GitLab, etc.) but interact through jj's cleaner interface. There is also an operation log that records every action performed, making it easy to undo mistakes. The tool is written in Rust and is installed as a single command-line binary called jj. It is suitable for individual developers who want a simpler daily experience than Git, as well as teams working on large projects. The full README is longer than what was provided.

Copy-paste prompts

Prompt 1
How do I install jj and initialize a new project, and what are the first commands I should learn?
Prompt 2
Show me how to make changes, commit them, and push to GitHub using jj instead of git commands.
Prompt 3
Explain how jj's automatic rebasing works when I edit an older commit, what happens to commits built on top of it?
Prompt 4
How do I undo a mistake in jj using the operation log, and can I go back to any previous state?
Prompt 5
Can I use jj alongside Git in the same repository, and how does it store data in a Git repo?
Open on GitHub → Explain another repo

Generated 2026-05-21 · Model: sonnet-4-6 · Verify against the repo before relying on details.