/projects/rewind   //   local-only version control

development history without the Git ceremony.

A local-only version control system built around the development process itself: exact checkpoints, clean finished history, named Moments, provenance, integrity, and recovery when the experiment goes sideways.

REWIND // SESSION 0042
$ rewind note "parser working"
Noted 8f31a42  parser working
$ rewind finish "parser diagnostics"
Finished 19ca770  parser diagnostics
Next     2d1b9e4
$ rewind moment parser-v1
Moment parser-v1  2d1b9e4

Install Rewind.
Start remembering.

The installer downloads the current Linux x86_64 release, verifies its SHA-256 checksum, and installs rewind to ~/.local/bin by default. The installer can also choose a custom destination.

$ curl -fsSL https://rewind.apoetic.com/install.sh | sh

Requires curl or wget, tar, and sha256sum or shasum. Rewind currently supports Linux x86_64.

Rewind in
five minutes.

You do not need to learn a branching model or staging area. Start a repository, work normally, leave Notes when a state is worth remembering, and Finish when that piece of work is complete.

01

Start the repository

Run this once from the project directory. Rewind creates .rewind/ and remembers the initial baseline.

$ cd my-project
$ rewind new
02

See what changed

Edit files normally. status summarizes everything changed since the last Finish. diff shows the actual content changes.

$ rewind status
$ rewind diff
03

Remember progress with a Note

When the current state is useful but the work is not finished, leave a Note. The checkpoint becomes recoverable, while status still shows the whole unfinished change set since the last Finish.

$ rewind note "parser handles nested groups"
04

Finish the work

When the piece of work is complete, Finish it. This records the completed work and establishes the new baseline. With no further edits, rewind status is clean.

$ rewind finish "nested group parsing"
$ rewind status
05

Read the history

log keeps the normal view focused on finished work. Add --revisions when you want the detailed checkpoints underneath it.

$ rewind log
$ rewind log --revisions
06

Name an important point

A Moment gives an exact Chronicle state a memorable name. It does not create another copy or branch.

$ rewind moment before-refactor
$ rewind diff before-refactor
07

Go back when needed

undo returns unfinished work to the last Finish. recover restores recorded history without deleting the history that came later.

$ rewind undo
$ rewind recover before-refactor
THE MENTAL MODEL // note means “remember this while I keep working.” finish means “this piece of work is complete; make it the new baseline.”

Commits preserve milestones.
Rewind preserves development.

Between two clean commits may be dozens of meaningful states: experiments, partial implementations, debugging attempts, refactors, generated changes, AI-assisted edits, mistakes, and working versions you later wish you had kept.

Rewind treats those intermediate states as useful history without forcing every checkpoint to pretend it is a finished unit of work.

“Make history follow the work instead of making the work follow the history.”

Detailed history.
One small vocabulary.

Notes preserve checkpoints inside unfinished work. Finishes establish completed-work baselines. Moments give exact Chronicle states human names. You get readable project history without throwing away how you got there.

01 // NOTErewind note "validation works"

Remember the exact current state while keeping the last finish as the status baseline.

02 // FINISHrewind finish "add validation"

Close the work as a completed piece while retaining its revisions underneath.

03 // MOMENTrewind moment parser-v1

Name an exact Chronicle state without creating a duplicate snapshot or branch.

$ rewind log
19ca770  parser diagnostics  [parser-v1]
18b64a1  lexer cleanup
17de920  source spans

$ rewind log --revisions
19ca770  parser diagnostics
  8f31a42  parser working
  8f32bc1  diagnostics cleaned up

Built around history,
not around an inherited format.

Chronicle v3 is Rewind's authoritative storage model. Append-only segmented history records are the source of truth; indexes and acceleration structures are rebuildable and disposable. Optimization can change without changing what the repository means.

Chronicle uses a Rewind-owned binary wire representation, content-defined chunking, BLAKE3 identity, global deduplication, and compressed unique chunks. Historical trees are reconstructed lazily instead of eagerly materializing every state at startup.

SOURCE OF TRUTH

Chronicle frames preserve the history that actually happened.

REBUILDABLE STATE

Anchors, indexes, and acceleration data can be reconstructed from authoritative history.

Don't just keep history.
Know where code came from.

rewind trace -- <file> follows provenance through current and historical line attribution, revision-level history, and rename-following. The goal is to answer not only what changed, but where a piece of code originated and how it survived.

$ rewind trace -- src/parser.rs
42 │ 8f31a42 │ parser working
43 │ 8f32bc1 │ diagnostics cleaned up
44 │ 19ca770 │ parser diagnostics

rewind undo handles the immediate working state. rewind recover <id> handles recorded history. Current mistakes and historical recovery are deliberately different operations.

Checking history should
never rewrite history.

rewind check performs read-only reachable-history integrity verification. It validates reachable Chronicle history without rewriting it. Valid unreachable preparatory Chronicle records may be reported, but are not themselves corruption.

Integrity checking does not silently repair, migrate, prune, sync, or upgrade the repository. Torn final appends are handled by Chronicle crash-safety rules; interior corruption remains a hard failure. A verification command should be trustworthy precisely because it does not change the thing it is verifying.

Rewind remembers how.
Git can publish what mattered.

REWIND // DEVELOPMENT

Continuous checkpoints, experiments, detailed revisions, provenance, recovery, and local development history.

GIT // COLLABORATION

Clean commits, remotes, pull requests, collaboration, releases, and public project history.

Rewind does not need to recreate every Git command to be useful. Its core question is narrower: what should version control look like when development history itself is the primary object?

Every command needs
a reason to exist.

rewind newstart
rewind statuscurrent state
rewind diffwhat changed
rewind notecapture progress
rewind finishcomplete work
rewind loghistory
rewind undoundo current changes
rewind recoverrecover history
rewind traceprovenance
rewind checkintegrity
rewind migrateformat upgrades
rewind momentname history

Solid enough to
stop adding things.

Rewind v0.33 reached an intentional development pause after Chronicle hardening, crash-safe daily operations, long-history scaling, exact working-tree detection, divergence and reconciliation, provenance, migration, and Moments.

There is no artificial roadmap. Development resumes when real use exposes a bug, a bottleneck, or a feature worth earning its place in the command surface.

NOW

Use it

Let real repositories decide what Rewind needs next.

LATER

Possible directions

History search, richer Moment polish, recovery preview, shell completion, and further scale work only when actual usage justifies them.

/end_of_history

AND WHEN SOMETHING GOES WRONG — REWIND.