TUICR — Vim-Powered Code Review in the Terminal

Code review is where quality happens — but most of us review code in a web browser: scrolling through GitHub’s PR pages, clicking through diffs, hunting for the comment button. It works, but it’s slow, and it breaks your flow.

TUICR (pronounced “tweaker”) is a different approach: a code review TUI that runs in your terminal with vim keybindings. Built in Rust as a single static binary, it brings the GitHub-style diff experience into your terminal — and lets you push real reviews back to GitHub or GitLab without ever opening a browser.

What is TUICR?#

TUICR is a terminal UI for code review that gives you:

• GitHub-style continuous diff — scroll through every changed file in one stream
• PR-style comments at line, range, file, and review level
• Review tracking at file or hunk granularity, persisted across sessions
• Three export targets — push a real review to GitHub or GitLab, copy structured markdown to your clipboard, or pipe to stdout
• Works with git, jj, and mercurial — reviews uncommitted changes, commit ranges, or any GitHub PR or GitLab MR

Installation#

# One-liner
curl -fsSL tuicr.dev/install.sh | sh

# Homebrew
brew install agavra/tap/tuicr

# Cargo
cargo install tuicr

# Nix
nix run github:agavra/tuicr

Quick Start#

tuicr # Pick from a commit selector
tuicr -w # Uncommitted changes (skip selector)
tuicr -r main..HEAD # Commit range
tuicr pr 125 # GitHub PR
tuicr mr 125 # GitLab MR
tuicr --stdout # Pipe the review to stdout

Inside the TUI: navigate with j/k, press c to comment, y to copy the review, or :submit to push it to GitHub or GitLab.

Key Features#

GitHub-Style Diffs in the Terminal#

TUICR renders the diff the way GitHub does — a continuous stream of all changed files. Navigate hunks with [ and ], jump between files with { and }, and search the diff with /.

Comments at Every Level#

• Line comments (c) — comment on a specific line
• Range comments (v then comment) — visual mode for selecting a range
• File comments (C) — comment on a whole file
• Review comments — a summary-level comment for the whole review

Review Tracking Across Sessions#

TUICR tracks which files and hunks you’ve already reviewed — at file or hunk granularity — and persists this across sessions. When you reopen a PR you’ve reviewed before, it preselects commits newer than your latest submitted review. Commits already covered are marked with ✓ in the selector.

One-Command Export#

To GitHub: :submit opens a picker for Comment, Approve, Request changes, or Draft. Inline comments land on the right lines as a real PR review. Requires gh authenticated.

To GitLab: :submit offers Comment, Approve, or Request changes on a GitLab MR. Inline comments post as discussion notes. Requires glab authenticated.

To your coding agent: y copies a structured markdown block to your clipboard:

I reviewed your code and have the following comments. Please address them.
1. `src/auth.rs` - Consider adding unit tests
2. `src/auth.rs:42` - Magic number should be a named constant
3. `src/auth.rs:50-55` - This block could be refactored

Paste it into Claude, Codex, Cursor, or any coding agent.

To stdout: tuicr --stdout > review.md or tuicr --stdout | pbcopy.

Vim Keybindings#

VCS Support#

TUICR auto-detects git, jj, and mercurial. It can review:

• Uncommitted changes
• Commit ranges
• GitHub PRs
• GitLab MRs

This is rare — most review tools are tied to one VCS or one platform.

Configuration#

Configuration lives in ~/.config/tuicr/config.toml:

theme = "catppuccin-mocha"
diff_view = "side-by-side" # or "unified"
appearance = "system"      # or "dark" / "light"
mouse = true

Comes with 22 bundled themes (catppuccin, onedark, gruvbox, nord, solarized, tokyo-night, github, everforest…) plus support for custom local themes.

Library API#

Beyond the TUI, TUICR exposes a Rust library API for building tools on top of its persisted review sessions:

use tuicr::{AddCommentRequest, CommentTarget, CommentType, LineSide, ReviewStore};

let store = ReviewStore::new();
let sessions = store.list_sessions_for_repo("/path/to/repo")?;
let session = &sessions[0].session_ref;
store.add_comment(
    session,
    AddCommentRequest {
        target: CommentTarget::Line {
            path: "src/main.rs".into(),
            line: 42,
            side: LineSide::New,
        },
        content: "Handle the empty case here.".into(),
        comment_type: CommentType::from_id("issue"),
    },
)?;

How It Compares#

Why TUICR Matters#

Code review shouldn’t force you out of your terminal. TUICR brings the full review workflow — reading diffs, leaving comments, submitting reviews — into the tool you already live in, with keybindings you already know.

Its agent-ready markdown export is a particularly forward-thinking feature: paste a structured review into Claude Code or Cursor and the agent addresses each comment, numbered and anchored to specific files and lines.

For developers who live in the terminal, TUICR is the code review tool you’ve been waiting for.

References#

• TUICR GitHub Repository ↗
• TUICR Official Website ↗
• TUICR Documentation ↗