Best Git TUIs
Compare lazygit, gitui, tig and gitu: terminal Git interfaces for staging hunks and lines, committing, and managing branches.
Updated
short verdict
Pick lazygit if you want the broadest set of Git operations in panels, including rebase, merge conflicts and stashing. Pick gitui for large repositories and a single Rust binary with keyboard-only control. Pick gitu if you come from Magit, and tig if you mostly browse history and stage by chunk.
A Git TUI shows status, diffs, commits and branches in one terminal screen so you can stage, commit and switch branches without typing each git command. The four tools here differ in scope and interaction model. Lazygit and gitui are panel-based and cover the full workflow. Gitu copies Magit's key-driven menus. Tig is primarily a repository browser and pager with staging added.
this page is for
- Developers who stage individual lines or hunks from the terminal
- Teams working in large repositories where load time matters
- Magit users who want the same workflow outside Emacs
- Readers who mainly review history and diffs in the terminal
Panel-based Git TUI covering staging, commits, branches, merging, rebasing, stashing and merge conflict resolution, with mouse support.
best for
- A default Git TUI for daily work
- Rebasing and conflict resolution without leaving the terminal
strengths
- Separate staged and unstaged panels with line and hunk staging
- Covers merge, rebase, stash, push and pull from one interface
- Keyboard shortcuts plus mouse interaction
- Installs with brew install lazygit
weaknesses
- Slower and heavier on the Linux kernel repository in gitui's benchmark (57 seconds, 2.6GB vs 24 seconds, 0.17GB)
- Go binary with its own panel layout, so no Magit-style key menus
Rust Git TUI with keyboard-only control and the best benchmark numbers on very large repositories.
best for
- Large repositories with hundreds of thousands of commits
- Users who want themes, custom key bindings and Git hooks support
strengths
- Parsed the Linux kernel repository in 24 seconds using 0.17GB in the project's benchmark
- Stages files, hunks and lines; supports amend, stash and push/fetch
- GPG commit signing and pre-commit, commit-msg, post-commit and prepare-commit-msg hooks
- Context-based help, themes and custom key bindings; installs via brew, cargo or pacman
weaknesses
- Overview lists no merge conflict resolution or rebase workflow, which lazygit and gitu document
- Benchmark figures come from the project's own comparison
Magit-inspired Git TUI with Vim-like navigation, interactive and autosquash rebase, and fixup commits.
best for
- Magit users moving to a terminal workflow
- Keyboard-driven rebase, fixup and reset operations
strengths
- Stages files, hunks or individual lines
- Interactive, autosquash, abort and continue rebase
- Soft, mixed and hard reset plus stash save, pop, apply and drop
- TOML configuration and commit messages through VISUAL, EDITOR or GIT_EDITOR
weaknesses
- Magit-style keymap takes learning if you have not used Magit; help opens with the h key
- Smallest user base of the four, so fewer community resources
ncurses repository browser and pager that also stages changes at chunk level.
best for
- Browsing commit history and reviewing diffs
- Use as a pager for Git command output
strengths
- Multiple full-screen views for commits, branches and repository structure
- Acts as a pager for output from other Git commands
- Written in C on ncurses, suited to environments without GUI tools
- Chunk-level staging
weaknesses
- Staging is at chunk level; line-level staging is not documented
- Slowest in the project-published Linux kernel benchmark (4 minutes 20 seconds)
- Browser-first design, with less emphasis on rebase and stash workflows than lazygit or gitu
How to choose
The deciding factor is usually how much of Git you want to drive from the TUI and how large your repository is.
- Breadth of operations: lazygit wins, with merge, rebase, stash and conflict resolution in panels
- Large repository speed: gitui wins, at 24 seconds on the Linux kernel repository in its benchmark
- Magit-style workflow: gitu wins, with Magit-like keys, Vim-like navigation and fixup or autosquash
- History browsing and pager use: tig wins, since it pages Git command output and has multiple views
- Hooks and commit signing: gitui wins, with GPG signing and four supported Git hooks
When not to use these
- You only make occasional commits and already know the git CLI commands you need
- You need a graphical client with windows and mouse-first interaction outside the terminal
FAQ
- Which Git TUI is fastest on large repositories?
- Gitui's project benchmark shows it parsing the Linux kernel repository in 24 seconds with 0.17GB of memory, against 57 seconds and 2.6GB for lazygit and 4 minutes 20 seconds for tig. These are the project's own numbers.
- Can these tools stage individual lines?
- Lazygit, gitui and gitu can stage individual lines or hunks. Tig stages at chunk level.
- Which Git TUI is closest to Magit?
- Gitu. It uses Magit-style keyboard shortcuts with Vim-like navigation and supports amend, fixup, rebase and stash operations.
- Is tig a full Git client?
- Tig is mainly a repository browser and pager with chunk-level staging. Lazygit, gitui and gitu cover more of the commit, branch and rebase workflow.