Jujutsu (jj) is a modern, Git-compatible distributed version control system designed to offer a simpler and more powerful alternative to Git. Developed in Rust, jj aims to address many of the common pain points and complexities associated with Git, particularly around managing local history and iterative development. Its core philosophy revolves around a more intuitive mental model where local history is mutable by default, empowering developers to easily refine and reorganize their work without fear of losing changes.

A fundamental departure from Git is Jujutsu's treatment of history. Unlike Git, where history is largely considered immutable once committed, jj embraces mutable history as a first-class concept. Operations like rebasing, amending, and squashing are not just possible but are central to its workflow, often performed implicitly or with simpler commands. This is facilitated by an "operation log," which meticulously records every action taken, providing a robust safety net similar to Git's reflog but for all operations, allowing users to undo or revisit any past state. This design encourages a cleaner, more linear commit history, as developers can continuously refine their changes before sharing them.

Jujutsu also redefines the concept of the working directory. In jj, the working copy itself is treated as an *uncommitted* commit, making it a natural part of the commit graph. This allows for consistent commands across the entire history, whether you're interacting with committed changes or your current work in progress. For instance, `jj diff` can compare your working copy against any other commit, and `jj restore` can revert specific files or the entire working copy to a previous state with ease. This unified model simplifies many common tasks and eliminates the conceptual distinction between "staged" and "unstaged" changes, often a source of confusion in Git.

Another significant feature is Jujutsu's approach to branches and stacked changes. Branches in jj are simply named pointers to commits, much like tags, rather than special objects with complex behaviors. This minimalist view simplifies branch management. Furthermore, jj excels at managing "stacked changes," where a developer works on multiple, dependent features simultaneously. Its design makes it straightforward to rebase a child commit onto a modified parent, or to split and merge commits, without the manual intervention often required in Git. Conflict resolution is also built-in and designed to be more user-friendly, providing clear guidance when merging divergent histories.

Jujutsu is designed to be Git-compatible, meaning it can operate directly on existing Git repositories. This allows for a gradual adoption path, where developers can use jj for their local workflow while still pushing and pulling from remote Git repositories. This interoperability is crucial for its adoption, enabling teams to experiment with jj without a full migration. By rethinking fundamental VCS concepts like mutable history, the working copy, and branch management, Jujutsu offers a compelling alternative for developers seeking a more intuitive, flexible, and powerful version control experience, particularly for those who frequently iterate and refine their local work.