lazygit vs tig
lazygit vs tig: a Go panel-based Git UI for staging and rebasing compared with a C ncurses browser and pager for history.
Updated
short verdict
Pick lazygit if you want to run Git operations from the terminal: line-level staging, rebase, merge, stash and conflict resolution, with mouse support. Pick tig if you mostly read history and diffs, want chunk-level staging, or want to pipe Git command output through an ncurses pager.
Both tools put a full-screen terminal interface on top of Git, but they cover different jobs. lazygit is a panel-based interface for carrying out Git workflows, written in Go and licensed MIT. tig is an ncurses repository browser, written in C and licensed GPL-2.0, that also stages changes and works as a pager.
this page is for
- Developers deciding between a Git action interface and a Git history browser
- Terminal users who want to stop typing individual Git commands
- Users working in text-only environments who need to review and stage changes
The better pick when you want to commit, branch, merge, rebase, stash and resolve conflicts from one interface.
best for
- Daily Git work done from keyboard shortcuts or mouse
- Staging individual lines out of a larger change
strengths
- Stages individual lines or hunks from a separate unstaged and staged panel layout
- Covers commit, push, pull, branch, merge, rebase and stash in the interface
- Resolves merge conflicts without leaving the interface
- Supports both keyboard shortcuts and mouse interaction
weaknesses
- No documented role as a pager for output from other Git commands
- Panel layout is built around performing actions, with less emphasis on browsing history as a standalone viewer
The better pick when you mainly browse commits, branches and diffs, or want Git output paged interactively.
best for
- Reviewing code changes and exploring commit history
- Environments where a GUI Git client is not available
strengths
- Acts as a repository browser with multiple full-screen views
- Works as a pager for output from various Git commands
- Stages changes at the chunk level for preparing commits
- Written in C on ncurses, with keyboard navigation throughout
weaknesses
- Staging stops at chunks; line-level staging is not documented
- Documented scope is browsing and staging, not a full set of workflows such as rebase or conflict resolution
- No mouse interaction documented
Key differences
- Scope: lazygit runs full Git workflows; tig is a repository browser with staging.
- Staging: lazygit stages single lines or hunks; tig stages at the chunk level.
- Pager: tig can page output from Git commands; lazygit documents no pager mode.
- Input: lazygit documents keyboard shortcuts and mouse; tig documents keyboard navigation.
- Language: lazygit is written in Go; tig is written in C on ncurses.
- License: lazygit is MIT; tig is GPL-2.0.
Choose lazygit when
- You want merge, rebase, stash, push and pull available in the same interface.
- You need to stage individual lines, not only whole chunks.
- You want to resolve merge conflicts from the terminal UI.
- You want to use the mouse alongside keyboard shortcuts.
Choose tig when
- Your main task is reading commit history, branches and diffs.
- You want an interactive pager for output from Git commands.
- Chunk-level staging is enough for preparing commits.
- You work in a terminal-only environment and prefer an ncurses full-screen viewer.
When not to use these
- You are happy with plain git commands and scripts, and do not want a full-screen interface.
- You need a graphical client with windows and mouse-driven diff views outside the terminal.
FAQ
- Which is faster, lazygit or tig?
- Neither project documents performance figures or benchmarks, so there is no sourced answer. lazygit is written in Go and tig in C, but the projects make no speed claims.
- Can I use lazygit and tig together?
- Both operate on Git repositories from the terminal, so nothing stops you installing both. Neither project documents an integration between them. A common split is lazygit for actions and tig as a history browser or pager.
- Which is easier to configure?
- Neither project documents its configuration format, so this page does not compare them on configuration.
- Which one stages partial changes?
- Both stage partial changes. lazygit stages individual lines or hunks, while tig stages at the chunk level.