Edit like Docs.
Version like Git.
Fabric stores your repo as a single append-only operation log: every edit appends to the end, and you only ever work at the latest point. The full history stays, readable but never rewritten. People and agents edit live; conflicts surface as separate, reviewable items, never markers in your code. Install the CLI and the whole loop is in your terminal.
$
Installs fabric to ~/.fabric/bin. macOS & Linux · no account? run fabric signup.
# fork an isolated change off the trunk
$ fabric change create "fix login bug"
$ fabric clone && cd login-fix
# …edit files with your editor or an agent…
$ fabric push # append your tree as ops (idempotent)
$ fabric propose # draft → proposed
$ fabric accept # integrate the tip into trunk
✓ change accepted: trunk advanced, nothing rewritten
# Fabric
A version-control system you edit like a document.
Every keystroke is an operation. Two people and an agent can type in this same paragraph at once: the merge is automatic, and history never forks.
How it works
One loop, start to finish, from the terminal
Work happens on a change: an isolated set of ops forked from the trunk. You edit, push, and take it through propose → review → accept. Every command takes its input as flags and never stops to prompt, so the same loop runs whether you type it or an agent does.
Fork a change
fabric change create forks an isolated op-set off the current trunk frontier. No branch to name, no remote to configure.
Clone & edit
fabric clone materializes the change as a real directory. Edit with any tool, or let an agent do it. Others can edit the same files live.
Push ops
fabric push appends your working tree to the change as ops. It's idempotent and append-only: it never touches trunk and never rewrites a thing.
Propose & accept
fabric propose opens it for review; fabric accept integrates the tip into trunk. The only path in is reviewed.
One append-only log: you only ever work at the end
Every edit is a content-addressed op appended to a single log. You only ever write at the latest point (the frontier) and add forward. Nothing is rebased, amended, or force-pushed, so nothing is lost; the full history stays and you can replay any past point, read-only.
Why Fabric
Everything good about Git, without the foot-guns
You keep changes, review, and a single source of truth. You lose force-pushes, rebase hell, merge conflicts, and "I lost my work." Here's the mapping if you already think in Git.
| In Git | In Fabric | Why it's better |
|---|---|---|
| branch | change | An isolated op-set, not a movable ref. Unreviewed work physically can't land on trunk. |
| commit | op | Append-only and content-addressed, tracked at per-edit granularity instead of per-snapshot. |
| rebase · amend · --force | gone | History is forward-only. Nothing rewrites, so nothing gets clobbered or lost. |
| conflict markers in files | conflicts as separate items | Edits merge automatically; a genuine conflict surfaces as its own reviewable item, never spliced into your source. |
| pull request | propose → accept | The one and only path into trunk, so a half-finished change can't corrupt the base. |
| commit SHA | op-id actor:seq | A stable coordinate that carries authorship, so a rename rewrites nothing. |
Real-time & multiplayer
People and agents edit the same files at once with live cursors. Edits merge as they happen, the same path whether you're online or offline.
Agent-native by design
Hand an agent the repo and it can't make a mess you can't see or undo. Unreviewed ops can never land on trunk, so an agent can't bypass review even when it's wrong. Push is idempotent, so it can retry without corrupting state. status and diff run with no network, so it checks its own work between steps.
No lock-in
fabric import brings an existing Git repo in with its full history intact. Export back to a clean Git repo anytime. A door, not a cage.
Nothing gets lost
Append-only means your work lives on the change until it's accepted: no detached commits to drop, no force-push to overwrite a teammate. Replay any past frontier read-only to see exactly how it looked.
Install the CLI and start in your terminal
One command to install, one to sign in. The whole loop (create, clone, edit, push, propose, accept) lives in your terminal. No web UI required.
$
Installs fabric to ~/.fabric/bin. macOS & Linux · no account? run fabric signup.