wheat prototype
Install
Distributed version control

Version control for many hands at once.

Wheat gives every agent its own workspace and a stable change. Work commits privately, revises in place, and integrates only when you ask. Conflicts are kept as data, not raised as errors.

Install the CLI See it next to git

Three agents, one repository, one afternoon.

In git, each agent builds its own isolation from worktrees, branches and an index. Whenever main moves, someone rebases, and whoever hits the conflict has to stop. In Wheat, isolation is the default: each agent starts from one exact view, owns one stable change and commits privately. Integration is a separate step, and any conflicts it finds are recorded rather than blocking anyone.

start
work
commit
main moves
integrate
publish
git
agent 1
worktree add ../a
edit
commit on a
merge → main
agent 2
worktree add ../b
edit
commit on b
rebase onto main
CONFLICT · agent stops, resolves by hand, re-tests
agent 3
worktree add ../c
edit
rebase again
CONFLICT · stops
waiting on 2
Two of three agents stopped. What blocked them was the order the others finished in.
wheat
agent 1
change A · base M
edit
A1
A2 · same change
agent 2
change B · base M
edit
B1
keeps working
agent 3
change C · base M
edit
C1
you
compose A2 B1 C1 → 1 conflict stored
publish main
No agent stopped. When main moved, nobody had to act. The overlap was found once, recorded, and resolved by one person.

Three directories. One repository. The same second.

Each agent works in its own directory, and all three are attached to the same Wheat repository. They commit at the same moment. Nobody takes a lock, nobody waits on an index, and no commit overwrites another. Each commit lands as its own change.

agent-1~/src/app-1
$ wheat change new -m "parse config" # edits config.rs $ wheat add --all committed A@1 14:02:07.204
agent-2~/src/app-2
$ wheat change new -m "default port" # edits server.rs $ wheat add --all committed B@1 14:02:07.206
agent-3~/src/app-3
$ wheat change new -m "retry on 503" # edits client.rs $ wheat add --all committed C@1 14:02:07.211
the repository
A@1 parse config B@1 default port C@1 retry on 503 main unchanged
in git
In one checkout, three agents would share an index and race on index.lock. With three worktrees they'd be on three branches, and each one would have to be rebased before it could land.
what you type
wheat change new wheat add wheat log wheat conflicts

Bring your history. Keep your remote.

Wheat doesn't depend on git, but git is always reachable. Import an existing repository into a new Wheat store, work in changes and revisions, then convert that history back into commits and push it to any git branch. Your CI, reviewers and forge don't need to change.

Workspaces follow your existing .gitignore rules.

# import a local git repository
wheat import ~/src/my-repo
# work natively…
wheat change new -m "parse config"
wheat add --all -m "handle empty sections"
# project history back to git
wheat push ../my-repo.git --to refs/heads/main

We treat performance as correctness.

Any work that grows with repository size comes with a benchmark and a budget. The numbers below come from release builds, and every result is committed to the repo.

1.17 s
Reapply 500 changes after an edit placed beneath them, 50 of which touch a 1 MB file
deep_stack
≤ 5.5 s
wheat add across 20,000 files
add_scale
194,543
Files in the largest TypeScript repository commit, captured as a single revision
max revision edits
8.3 s
Repack planning at one million content IDs, using 157 MiB
content repack
Measured on one machine, 2026-09. Run the benchmarks yourself with: just bench

Install the CLI.

Wheat is written in Rust and is built from source. It installs a single wheat binary into ~/.cargo/bin.

The design docs explain the model in depth: docs/design.

install
git clone https://github.com/serialexp/wheat cd wheat && just install
first five minutes
wheat init
wheat change new -m "first change"
# edit files
wheat add --all -m "revise it"
wheat log
wheat conflicts