Tuicr: The Terminal Code Review Tool With Vim Keybindings and AI Agent Integration — 2,000 GitHub Stars

If you've ever felt that reviewing pull requests in a browser breaks your flow, you're not alone. Switching between your terminal, IDE, and a browser tab to leave line-level comments creates constant context-switching friction. Tuicr solves this by bringing the entire code review workflow into the terminal — with vim keybindings, persistent sessions, and seamless GitHub/GitLab integration.

Built in Rust and gaining rapid traction on GitHub (approaching 2,000 stars with 167 forks), tuicr represents a new generation of developer tools designed for the age of AI-assisted coding. It doesn't just display diffs — it understands your review workflow.

What Makes Tuicr Different From Other Diff Tools?

The terminal already has several diff viewers — git diff, delta, diff-so-fancy — but tuicr goes far beyond viewing differences. It's a complete code review environment that lives in your terminal.

GitHub-Style Continuous Diff

Unlike traditional terminal diffs that show one file at a time, tuicr renders a continuous scroll of every changed file — exactly like GitHub's pull request diff view. You scroll through the entire changeset in one stream, seeing every file's modifications in context.

# Review uncommitted changes
tuicr -w

# Review a specific commit range
tuicr -r main..HEAD

# Review a GitHub PR directly
tuicr pr 125

# Review a GitLab MR
tuicr mr 42

The diff supports both unified and side-by-side views, configurable through ~/.config/tuicr/config.toml:

diff_view = "side-by-side"  # or "unified"
ignore_whitespace = false
mouse = true

Vim Keybindings That Actually Work

Tuicr doesn't just add j/k and call it a day. It implements a genuine vim navigation model including visual mode, {N}G jumps, Ctrl-d/Ctrl-u half-page scrolling, and leader-key shortcuts. This matters because code review is fundamentally a navigation task — you're jumping between files, hunks, and lines constantly.

# Inside tuicr:
j/k        - Navigate lines
gg/G       - Jump to top/bottom
Ctrl-d/u   - Half-page scroll
c          - Add comment at current line
y          - Copy review to clipboard
:submit    - Push review to GitHub/GitLab

PR-Style Commenting at Every Level

Tuicr supports comments at multiple granularity levels, matching the GitHub/GitLab review model:

• Line comments — Comment on a specific line of code
• Range comments — Comment on a span of lines (e.g., "this block could be refactored")
• File-level comments — General feedback about an entire file
• Review-level comments — Overall summary of the review

You can also define custom comment types with colors and definitions:

# ~/.config/tuicr/config.toml
[[comment_types]]
id = "issue"
color = "red"
definition = "must fix before merge"

[[comment_types]]
id = "nit"
color = "yellow"
definition = "minor style preference"

[[comment_types]]
id = "question"
color = "blue"
definition = "needs clarification"

AI Agent Integration: The Killer Feature

Here's where tuicr truly shines for modern development teams. When you copy a review to clipboard with y, tuicr generates structured markdown that's specifically designed for AI coding agents:

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 this directly into Claude, Codex, Cursor, or any AI coding assistant, and it will understand the exact file locations and context of each comment. No more copy-pasting code snippets and explaining where they are — the agent gets file paths, line numbers, and your feedback in a format it can act on immediately.

Agent-Driven Review Workflows

Tuicr also exposes a Rust library API and CLI for programmatic access, enabling agent-driven workflows where your AI assistant can open tuicr in a tmux or Zellij split pane:

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"),
    },
)?;

You can also pipe reviews to stdout for integration with other tools:

# Pipe review to a file
tuicr --stdout > review.md

# Pipe to clipboard
tuicr --stdout | pbcopy

# Feed to an AI agent
tuicr --stdout | claude "Address these code review comments"

Multi-VCS Support: Git, Jujutsu, and Mercurial

One of tuicr's most impressive features is its version control system agnosticism. It auto-detects whether you're working with git, jj (Jujutsu), or mercurial, and adapts accordingly.

# Works in any git repo
cd ~/projects/my-app
tuicr

# Works with Jujutsu repos
cd ~/projects/jj-project
tuicr

# Works with Mercurial repos
cd ~/projects/hg-project
tuicr

This is particularly valuable for teams transitioning between VCS systems or working across multiple projects with different tools. Your review workflow stays consistent regardless of the underlying version control.

Review Tracking Across Sessions

Tuicr persists review state between sessions. When you open a GitHub PR or GitLab MR that you've previously reviewed, tuicr automatically preselects commits newer than your last submitted review. Commits you've already covered are marked with ✓ in the commit selector, so you never re-review the same code.

Real-World Example: A Complete Review Workflow

Here's how a typical code review session looks with tuicr:

# 1. Open a PR for review
tuicr pr 125

# 2. Inside the TUI:
#    - Scroll through the continuous diff with j/k
#    - Jump to specific files with /
#    - Press 'c' on line 42 of src/auth.rs
#    - Type: "This magic number should be a named constant"
#    - Press 'c' on lines 50-55 (visual mode: v, then select range)
#    - Type: "This block could be refactored into a helper function"
#    - Press 'c' at the file level for src/utils.rs
#    - Type: "Consider adding unit tests for the new utility functions"

# 3. Submit the review
:submit
# Choose: Comment | Approve | Request Changes | Draft

# 4. Your inline comments land on the exact right lines
#    as a real GitHub PR review

The entire workflow happens without leaving your terminal. No browser tabs, no context switching, no copy-pasting code snippets into comment boxes.

How Tuicr Compares to Alternatives

Let's see how tuicr stacks up against other terminal diff and review tools:

Key Benefits

• Zero context switching — Review code, write comments, and submit reviews without leaving your terminal
• Native vim navigation — Full vim keybinding support including visual mode, jumps, and leader shortcuts
• AI agent integration — Export structured markdown reviews that Claude, Codex, and Cursor can act on directly
• Multi-VCS support — Works seamlessly with git, Jujutsu, and Mercurial
• Persistent sessions — Never re-review the same commits; tuicr tracks what you've already covered
• Real PR reviews — Push inline comments as actual GitHub PR reviews or GitLab MR discussions
• Single binary — Written in Rust, no runtime dependencies, instant startup
• 22+ built-in themes — From Catppuccin to Tokyo Night, find a theme that matches your terminal

Getting Started

Installation is straightforward with multiple package managers:

# macOS with Homebrew
brew install agavra/tap/tuicr

# Quick install script
curl -fsSL tuicr.dev/install.sh | sh

# Rust developers
cargo install tuicr

# Nix users
nix run github:agavra/tuicr

Then start reviewing:

# In any git repo
tuicr

# Or review a specific PR
tuicr pr 125

Configure to your liking in ~/.config/tuicr/config.toml:

theme = "catppuccin-mocha"
diff_view = "side-by-side"
mouse = true
leader = ";"

FAQ

What is tuicr and how is it pronounced?

Tuicr is a terminal-based code review tool with vim keybindings. It's pronounced "tweaker." It provides GitHub-style continuous diffs in the terminal with the ability to write PR-style comments and push them directly to GitHub or GitLab.

Does tuicr work with GitHub pull requests?

Yes. Run tuicr pr 125 to review a specific GitHub PR. When you're done, use :submit to push your review with inline comments as a real GitHub PR review. It requires gh (GitHub CLI) to be authenticated.

Can I use tuicr with GitLab merge requests?

Absolutely. Use tuicr mr 42 to review a GitLab MR. Comments are posted as discussion notes, and you can approve or request changes. It requires glab (GitLab CLI) to be authenticated.

How does tuicr integrate with AI coding agents?

Press y to copy your review as structured markdown with file paths and line numbers. Paste this into Claude, Codex, Cursor, or any AI coding assistant, and it will understand exactly where each comment applies and what changes to make.

What version control systems does tuicr support?

Tuicr supports git, Jujutsu (jj), and Mercurial (hg). It auto-detects which VCS you're using and adapts accordingly. You can review uncommitted changes, commit ranges, or remote PRs/MRs.

Is tuicr free and open source?

Yes. Tuicr is fully open source, written in Rust, and distributed as a single static binary with no runtime dependencies. It's available on crates.io, Homebrew, and as pre-built binaries from GitHub Releases.

Can tuicr remember which commits I've already reviewed?

Yes. Tuicr persists review sessions across invocations. When you reopen a PR or MR, it marks previously reviewed commits with ✓ and preselects only the new commits since your last review.