Skip to content
revision

Introduction

revision is a lazygit-style terminal UI for Subversion. It gives you a fast, keyboard-driven interface over the svn command line — review changes, stage with changelists, commit, update, and browse history without leaving your terminal.

╭─ [1] Status ─────────────────╮╭─ [0] Diff ───────────────────────────────────╮
│Root      /home/alice/work/wc ││changelist: (staged)                          │
│Source    /home/alice/work/wc ││                                              │
│CWD       /home/alice/work/wc ││Loading diff…                                 │
│Branch    trunk               ││                                              │
│Revision  r42                 ││                                              │
│HEAD      r50                 ││                                              │
╰──────────────────────────────╯│                                              │
╭─ [2] ─ Changes ─── Changelist╮│                                              │
│   ▾ /                        ││                                              │
│>    ● A added.txt            ││                                              │
│       M modified.go          ││                                              │
│       D gone.txt             ││                                              │
╰────────────────── 1 of 3 ────╯│                                              │
╭─ [3] Log ────────────────────╮│                                              │
│  Rev    Author Message       ││                                              │
│     r50                      │╰──────────────────────────────────────────────╯
│   * r42                      │╭─ Command Log ────────────────────────────────╮
│                              ││No svn commands run yet.                      │
╰────────────── 1 of 2 · 1 ────╯│                                              │
╭─ [4] Shelf ──────────────────╮│                                              │
│                              ││                                              │
╰──────────────────────────────╯╰──────────────────────────────────────────────╯
space stage · a add · v pick · n changelist · c commit · r revert · d delete · …
The default layout: Status, Files and Log down the left, the Main detail view and Command Log on the right.

Why

Section titled “Why”

SVN’s command line is powerful but verbose for day-to-day work. revision wraps it in a focused TUI — inspired by lazygit — so common tasks are a keystroke away.

It is a front end, not a reimplementation. Every action shells out to the svn binary already on your PATH, so it respects your working copy, your cached credentials, and your existing SVN configuration. Nothing is cached behind your back, and anything revision runs on your behalf is listed in the Command Log panel.

What it does

Section titled “What it does”

Layout and navigation

  • A left column of Status, Files, Log and Shelf panels beside a Main detail view, with a Command Log beneath it. Switch panels with the number keys or Tab, click the Command Log or show it with x, and scroll any panel on both axes.
  • Changed files as a collapsible directory tree, each change grouped under its folder.
  • A contextual hint bar at the bottom, plus a full ? help menu.
  • Optional mouse support: turn it on and the panels answer the pointer, as does the settings editor, with every gesture still on a key.
spacestageaaddnchangelistccommitrrevertddelete[ ]view?help

Reviewing changes

  • A colour-coded diff viewer that follows your selection, with the +/- gutter pinned as you scroll. Highlight a directory for the combined diff of everything beneath it.
  • Side-by-side reading with s — each removal opposite the addition that replaced it, every line numbered in its own revision.
  • Save any diff on screen to a file with w, then browse the saved patches from the Files panel’s Diffs view.
  • Compare revisions — pick one for what it changed, or two for everything between them, and browse the result as a file tree.

Making changes

  • Staging through an SVN changelist, so a git-like stage-then-commit flow maps onto native SVN. Stage one file or a whole directory subtree with a single keystroke.
  • Named changelists — group the staged set in a tabbed view, drill into any list, and commit it as a unit.
  • Shelving — the git stash SVN never shipped. Pick files with v, set them aside with z, and merge them back with enter or p. Shelves sit in an ignored directory beside the working copy, so there is nothing to configure and nothing for svn to trip over.
  • Adding an untracked file or a whole untracked directory with a. Commit through an inline message editor; revert and delete confirm first, since those are the destructive ones.
  • Update to HEAD, or to any revision picked in the Log panel.

Finding things

  • A read-only log viewer with per-revision detail and an asterisk marking where the working copy sits. Pick any two revisions to see what changed between them.
  • Filter or search any panel with / — the list panels filter, the detail panels highlight matches in place.

Living with it

Where to go next

Section titled “Where to go next”