mrkeyoor.com_
Wed 16 Sept 06:28 UTC
Dev Toolsevaluationupdated 27 Aug 2026

lazygit review

Lazygit is a keyboard-driven terminal interface for Git. It puts files, branches, commits, stashes, diffs, rebases, worktrees, and common remote actions into panels, so developers can inspect and change a repository without recalling every command flag.

+191stars / 7d
Verdict

Our lazygit build took 38 seconds and all 33 detected tests passed, making it the cleanest source run in this group. Use it if you already understand Git and want staging, rebase, worktree, and history tasks kept in one terminal view. Keep command-line Git nearby for hooks, unusual recovery, and checking exactly what a destructive action will do.

We ran it

Lab card: what happened when we ran lazygitScreenshot of lazygit (github.com/jesseduffield/lazygit)
Install✓ · 27s0 packages
Build✓ · 38s
Tests✓ · 193s33 passed · 0 failed of 33 (go test)
Repo1213 files~143,156 lines of source · 5.9 MB · 6 CI workflows · Dockerfile · tests dir

Answers from our run

Does lazygit build from source?

Dependencies installed in 27 seconds (0 packages), and the build succeeded in 38 seconds. We cloned commit ea91639 into a clean Debian container with 3 CPUs and no project-specific setup.

Do lazygit's tests pass?

Yes: 33 of 33 passed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use lazygit?

New Git users who may treat menu actions as harmless: the README includes reset and nuke operations that can discard working-tree changes.

What are the alternatives to lazygit?

GitUI, tig, GitButler. Our lazygit build took 38 seconds and all 33 detected tests passed, making it the cleanest source run in this group.

Setup5/5Release binaries are simple; source build and all 33 tests passed
Docs5/5README demos cover actions, keys, config, installs, and recovery
Community5/581,665 stars with active August 2026 fixes and discussion
Maturity5/5MIT licensed, frequent releases, and a passing measured suite

Discussed on

  1. hnShow HN: I made a tool that made me faster at Git551 points
  2. hnLazygit: A simple terminal UI for Git commands395 points
  3. hnLazygit: Simple terminal UI for Git commands239 points
  4. hnLazygit Turns 5: Musings on Git, TUIs, and open source211 points
  5. hn1M Lazygit downloads, one embarrassment at a time67 points

Who it’s for

Developers who live in a terminal but want Git state visible while they work.
Frequent users of interactive rebase, selective staging, cherry-pick, bisect, stash, and worktrees.
Teams willing to teach a shared keyboard workflow while keeping plain Git available.
Developers who want custom commands and diff renderers inside a terminal UI.

Who it’s NOT for

New Git users who may treat menu actions as harmless: the README includes reset and nuke operations that can discard working-tree changes.
Teams whose commit workflow depends on prepare-commit-msg: open issue 4995 says that hook is ignored by the commit popup and editor mode.
NixOS users with read-only managed configuration unless they test upgrades first: issue 4595 reports that automatic config migration can prevent startup.
Developers who want a mouse-first desktop client or a visual merge tool; lazygit is designed around terminal panels and keybindings.

Setup reality

Our Go sandbox needed no package installation and completed the install step in 27 seconds. The build passed in 38 seconds, then all 33 detected tests passed in 193 seconds. The checkout at commit ea91639 had 1,213 files, about 143,156 source lines, and used 5.9 MB.

Most users can install a release binary or use a package manager. Git must already be configured for identity, remotes, signing, hooks, and credentials; GitHub pull-request indicators also require the gh command and an authenticated login.

Terminal fonts, color, shell commands, and key conflicts can affect daily use. Configuration supports custom commands and diff tools, which also means a shared config can execute local shell commands. Keep ordinary Git available for unsupported hooks and recovery.

Panels make Git state easier to read before acting

Lazygit opens a repository as linked views of changed files, branches, commits, stashes, and command output. Moving the cursor changes the diff or history shown beside it, so the user gets context without chaining status, diff, log, and branch commands. Space stages a file, hunk, or selected lines. Other keys open menus for rebase, cherry-pick, bisect, reset, worktrees, and custom actions. Help is available inside the interface when a binding is forgotten.

This speed depends on knowing what Git is doing underneath. A menu can make an interactive rebase easier to arrange, but squash, drop, amend, force push, and reset still rewrite or remove history. The README even documents a nuke option that discards everything reported by git status, including dirty submodules. Experienced users gain a quick control surface. Beginners can execute a dangerous command before they understand the repository state that makes it dangerous.

The 5.9 MB checkout built without dependency installation

We tested commit ea91639 in a fresh Go 1.24 Debian container. The repository contained 1,213 files, roughly 143,156 source lines, and occupied 5.9 MB. Its install step succeeded in 27 seconds without adding packages, and the build completed in 38 seconds. Six CI workflow files, a Dockerfile, and a tests directory were present. This is a modest source tree compared with many developer tools that bundle a browser runtime.

Most users do not need to compile it. The README lists binary releases and installation through Homebrew, MacPorts, Scoop, Arch packages, Fedora COPR, Debian and Ubuntu routes, Nix, FreeBSD, Termux, Go, Chocolatey, and Winget. Many packages are maintained by third parties, so their release may lag upstream. Downloading the project binary or using a trusted operating-system repository is the easiest way to keep installation responsibility clear.

What happened when we ran it

Our run completed the install step in 27 seconds with 0 packages added. Building lazygit took 38 seconds. The test step then succeeded in 193 seconds, with 33 passed and 0 failed out of 33 detected Go tests. The sandbox had 3 CPUs, 8 GB of RAM, no secrets, and no elevated privileges. Nothing in the supplied run showed a missing compiler dependency, build failure, or test error.

Those figures measure source health, not interactive correctness in every terminal. We did not exercise a real signing key, Git LFS, submodules, a remote host, or a rebase conflict through the UI. Terminal emulators also disagree on color, clipboard behavior, and modifier keys. The passing 33-test result is a strong reason to try this commit, while a disposable repository remains the right place to learn reset, force push, and rebase bindings.

Rebase and worktree tools go well beyond basic staging

Lazygit handles line staging, commit graph browsing, comparisons, cherry-picks, stashes, and branch cleanup, but history editing is where it stands apart from a basic status viewer. Users can reorder commits, squash or fix them up, drop commits, amend an older commit, and build custom patches. Worktree commands create another working directory from a selected branch, which helps when two changes need to remain checked out at once. Undo and redo cover commit and branch actions through Git's reflog.

Undo has a boundary the README states plainly: working-tree changes and stash operations are outside it. That matters because the interface puts reversible history actions near operations that can remove uncommitted work. Version 0.64.1, released August 12, 2026, fixed a race in stashing staged changes, stale pull-request indicators, Git directories outside the working tree, and a hang on quit. Several fixes concern edge conditions around state, which is exactly where a Git client must be judged.

Hooks and managed configuration still need plain Git

Lazygit runs the real Git command beneath its interface, but it does not mirror every command-line path. Issue 4995 reports that prepare-commit-msg is ignored when committing through both the popup and editor mode. A team that inserts ticket identifiers, templates, or policy text with that hook should verify its workflow before adopting the UI. The reporter's fallback is the raw terminal, which remains a sensible escape hatch for any unsupported behavior.

Configuration migration has another specific edge. Issue 4595 shows lazygit trying to rewrite a managed NixOS config on a read-only filesystem, then refusing to open after the write fails. Custom commands deserve review as well because they can invoke arbitrary shell commands with repository context. Personal configuration is convenient; copying a large shared config into every developer machine should receive the same scrutiny as a collection of shell scripts.

GitHub support needs gh, while core Git stays host-neutral

For github.com branches, lazygit can show pull-request state and open the request in a browser. The README says this requires GitHub's gh tool plus gh auth login. GitHub Enterprise needs another host login and a service entry in lazygit's configuration. Core staging, history, branch, rebase, and remote operations still use Git, so the application is not tied to GitHub for its main job.

GitHub showed 81,665 stars, 1,025 combined issues and pull requests, and a last push on August 26, 2026. That queue includes years of feature requests as well as current work, so it is not a defect count. The 33 passing tests and v0.64.1 regression fixes point to active maintenance. For developers who already know Git's recovery tools, lazygit removes keystrokes without hiding the repository. For everyone else, learning reflog, status, and safe branching first will pay off.

Alternatives

ProjectWhat it isPick it when
GitUIA fast terminal interface for Git written in Rust.pick this instead when you prefer its tighter interface and Rust implementation over lazygit's larger action set.
tigA long-running text interface focused on browsing Git history and diffs.pick this instead when inspection and log navigation matter more than guided write operations.
GitButler gh↗A desktop Git client built around parallel branches and visual change management.pick this instead when a graphical workflow and branch organization are more useful than terminal speed.

What people are saying

  1. [github-trending] jesseduffield/lazygit

Sources

  1. lazygit repository and README
  2. lazygit v0.64.1 release notes
  3. prepare-commit-msg hook issue
  4. NixOS config migration issue

More dev tools reviews

IKONA-Security · noty · forward-implementation-first · breakscale · black · ASC · the whole board →