TOVIO vs Git in one page

The differences that change how you work, not a feature table.

Written By Dustin

Last updated 30 minutes ago

If you know Git, five differences account for nearly all the surprise. Everything else transfers.

1. There is no staging area

No git add. Your working copy is continuously snapshotted into the current change, so tovio commit -m "…" records what is already there. Typing tovio add is harmless — it prints a note explaining this and does nothing else.

2. Branches are called lanes, and they merge instead of colliding

A lane is a conflict-free replicated reference ordered by a hybrid logical clock, not a pointer one side can clobber. Two people advancing the same lane converge. You will never see "diverged history" and you will never be told to pull before you push — that class of error is designed out rather than worded better.

3. Changes have stable identities

A change keeps its chg: id through rebase, amend, cherry-pick, split, and absorb. In Git, rewriting history produces new commit hashes and orphans everything attached to the old ones. In TOVIO a review or a dependency stays attached — which is also why resolving a backport conflict once makes it re-apply rather than recur.

4. Conflicts do not break your tree

A conflict becomes an object in the repository. Your files are never filled with marker lines, your build still runs, and you resolve when you are ready. tovio resolve with no flags walks each open conflict interactively, one region at a time; with a strategy flag (--ours, --theirs, --base) it resolves in one shot for scripts.

5. Some files are encrypted, and permissions are real

A path covered by a policy is encrypted at snapshot time. Someone without the key sees ciphertext, and read surfaces such as tovio review and tovio grep mark what they could not decrypt instead of pretending it is not there. This has no Git equivalent, and it is the reason TOVIO exists.

The commands, roughly mapped

GitTOVIO
git addNothing — tracking is automatic. tovio add prints a note.
git commit -mtovio commit -m (--amend folds into the last one, keeping the change id)
git statustovio status (--conflicts also reports whether the lane lands cleanly)
git branch / git checkouttovio lane / tovio switch — branch, br, and checkout are recognized aliases
git mergetovio land (default target main; two or more lanes fold into one N-way land)
git pull + git pushtovio sync — both directions in one, and divergence merges
git stashNothing — your work is already a tracked change. tovio stash prints a note.
git resettovio undo (and tovio restore <path> for a single file's uncommitted edits)
git reflogThe op-log, which tovio undo and tovio redo walk — every operation, not just commits
git log -S / -Gtovio log -S / -G, same meaning
git blametovio blame — attributes to the logical change, so it survives rewriting

Five Git verbs are recognized so muscle memory does not punish you, and they split into two kinds. checkout and branch (and br) do the real thing — tovio checkout -b feature creates the lane and switches to it, tovio branch -d feature deletes one — and print a note on the side naming the native verb. add, stash, and reset change nothing at all: they explain why TOVIO has no equivalent and point you at status, at the fact that your work is already a tracked change, and at undo.

You do not have to leave Git today

tovio git import ingests a Git repository with its history and branches, every imported commit getting a stable change id. tovio git bridge keeps a TOVIO repository exchanging work with a GitHub, GitLab, Gitea, or bare Git remote through conflict-safe namespaces, with no force pushes on either side, while you evaluate. tovio git export writes a fresh local Git repository back out — a lossy interop view, not a round trip, and protected paths export as ciphertext, never decrypted.