Guide Complet Lazygit 2026 : Interface Terminal Git

Git is the backbone of modern software development, but its command-line interface remains notoriously difficult to use for complex operations. Interactive rebase, partial staging, conflict resolution, and cherry-picking all require memorizing arcane flags and multi-step sequences. Lazygit solves this by wrapping the full power of Git in an intuitive terminal user interface.

Created by Jesse Duffield in 2018, Lazygit has grown into one of the most popular developer tools on GitHub with over 55,000 stars. It runs on macOS, Linux, and Windows, requires no GUI framework, and works over SSH. In 2026, with its mature plugin system, custom commands, and deep editor integrations, Lazygit has become the standard Git interface for terminal-centric developers.

What Is Lazygit and Why It Matters

Lazygit is a terminal-based user interface for Git written in Go. It presents your repository state across five interactive panels: Status, Files, Branches, Commits, and Stash. Every Git operation — from staging individual lines to performing interactive rebases — is accessible through single-key shortcuts without typing any Git commands.

Why does a terminal UI for Git matter? GUI tools like GitKraken and Fork are powerful but require dedicated applications, consume significant resources, and cannot run over SSH. The raw Git CLI is universal but hostile to complex operations. Lazygit occupies the sweet spot: full visual feedback with the speed and portability of the terminal.

• Runs everywhere: local terminal, SSH, tmux, Docker containers, WSL
• Zero dependencies beyond Git itself — single binary distribution
• Keyboard-driven: every action is a single keypress away
• Full Git feature coverage: rebase, cherry-pick, bisect, worktrees, submodules, patches
• Fully customizable keybindings, themes, and custom commands via config.yml
• Active development with frequent releases and a responsive maintainer

Lazygit vs GitKraken vs Fork vs SourceTree vs tig

Each Git client serves different workflows. This comparison helps you choose the right tool.

Installation

Lazygit distributes as a single binary. Install it with your preferred package manager or build from source.

macOS (Homebrew)

brew install lazygit

# Verify installation
lazygit --version

Ubuntu / Debian (apt)

# Add the PPA repository
LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | grep -Po '"tag_name": "v\K[^"]*')
curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/latest/download/lazygit_\${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
tar xf lazygit.tar.gz lazygit
sudo install lazygit /usr/local/bin

Windows (Scoop)

scoop install lazygit

# Or with Chocolatey
choco install lazygit

Go Install

go install github.com/jesseduffield/lazygit@latest

Docker

# Run lazygit in a Docker container with your repo mounted
docker run --rm -it \
  -v /path/to/repo:/repo \
  -w /repo \
  lazyteam/lazygit:latest

Arch Linux

pacman -S lazygit

Interface Overview: The 5 Panels

When you launch Lazygit by typing lazygit in a Git repository, you see five panels arranged in a split layout. Each panel is focused with Tab or number keys, and actions within each panel are context-sensitive.

The Status panel (1) shows the current branch, remote tracking status, and recent log. The Files panel (2) displays staged and unstaged changes similar to git status. The Branches panel (3) lists local and remote branches with checkout and merge options. The Commits panel (4) shows the commit log with interactive rebase capabilities. The Stash panel (5) manages your stash entries with preview.

# Launch lazygit in the current repository
lazygit

# Panel Layout:
# +------------------+----------------------------------+
# | 1. Status        |                                  |
# +------------------+        Main Panel                |
# | 2. Files         |     (diff / staging view)        |
# +------------------+                                  |
# | 3. Branches      |                                  |
# +------------------+                                  |
# | 4. Commits       |                                  |
# +------------------+                                  |
# | 5. Stash         |                                  |
# +------------------+----------------------------------+

Keyboard Shortcuts Cheat Sheet

Lazygit is entirely keyboard-driven. These are the most essential shortcuts organized by context.

Global Navigation

Files Panel

Branches Panel

Commits Panel

Staging: Files, Hunks, and Lines

One of Lazygit's most powerful features is granular staging. In the Files panel, press Space to stage or unstage an entire file. Press Enter on a file to open the staging view, where you can stage individual hunks or even individual lines.

In the staging view, use the arrow keys to navigate between hunks. Press Space to stage the current hunk. Press v to enter line-selection mode, then use arrows to select specific lines and Space to stage only those lines. This makes creating focused, atomic commits trivially easy.

# Staging workflow in lazygit:
#
# 1. Navigate to Files panel (press 2)
# 2. Press Enter on a file to open staging view
# 3. Use arrow keys to navigate between hunks
# 4. Press Space to stage a hunk
# 5. Press v to toggle line-selection mode
# 6. Select specific lines with arrow keys
# 7. Press Space to stage selected lines only
# 8. Press Escape to return to files panel
# 9. Press c to commit staged changes

Committing: Conventional Commits, Amend, Fixup

Press c in the Files panel to open the commit message editor. Type your message and press Enter to commit. For conventional commits, simply type the prefix directly: feat: add user login or fix: resolve null pointer.

Press A to amend the last commit (adds staged changes to the previous commit). Press shift+F on a commit in the Commits panel to create a fixup commit that will automatically squash into the target commit during the next interactive rebase with autosquash.

# Conventional commit examples in lazygit:
# Press c, then type:
#   feat: add user authentication
#   fix: resolve login redirect loop
#   refactor: extract validation logic
#   docs: update API reference
#   chore: upgrade dependencies
#   test: add unit tests for auth module
#   perf: optimize database queries
#   ci: add GitHub Actions workflow

# Amend last commit: press A in Files panel
# Create fixup commit: press Shift+F on target commit in Commits panel
# Autosquash fixup commits: perform interactive rebase

Branching: Create, Merge, Rebase, Cherry-Pick

In the Branches panel, press n to create a new branch from the current HEAD. Press Space to checkout a branch. Press M to merge the selected branch into the current branch. Press r to rebase the current branch onto the selected branch.

Cherry-picking is intuitive: navigate to the Commits panel, press C to copy a commit, switch to the target branch, and press V to paste (cherry-pick) the commit. You can copy multiple commits and paste them all at once.

# Branch operations in lazygit:
#
# Create branch: press n in Branches panel -> type name -> Enter
# Checkout: press Space on branch
# Merge: select branch -> press M -> confirm
# Rebase: select branch -> press r -> confirm
#
# Cherry-pick workflow:
# 1. Go to Commits panel
# 2. Press C on commit(s) to copy
# 3. Switch to target branch (Branches panel -> Space)
# 4. Press V to paste (cherry-pick) the commits

Interactive Rebase

Interactive rebase is where Lazygit truly shines. In the Commits panel, press e on any commit to start an interactive rebase from that point. Each commit shows its rebase action, and you can change them with single keys.

Press s to squash a commit into the one below it. Press f to fixup (squash without keeping the message). Press d to drop a commit. Press e to edit a commit (pauses rebase so you can make changes). Use ctrl+j and ctrl+k to reorder commits by moving them up and down. Press m to change the commit message during rebase.

# Interactive rebase actions in Commits panel:
#
# e  - edit: pause at this commit to amend
# s  - squash: merge into commit below, combine messages
# f  - fixup: merge into commit below, discard this message
# d  - drop: remove this commit entirely
# r  - reword: change commit message
# Ctrl+j - move commit down (later in history)
# Ctrl+k - move commit up (earlier in history)
#
# Example: squash last 3 commits into one
# 1. Press e on the commit 3 positions below HEAD
# 2. Press s on the 2nd commit
# 3. Press s on the 3rd commit
# 4. Edit the combined message
# 5. The rebase completes automatically

Stashing

Press s in the Files panel to stash all changes. You will be prompted for a stash message. Press S to open stash options where you can choose to stash only staged changes, include untracked files, or keep the index.

In the Stash panel, press Space to apply a stash entry (keeps the stash), press g to pop (apply and delete), or press d to drop a stash entry. Press Enter on any stash to preview its contents before applying.

# Stash operations:
#
# Files panel:
#   s     - stash all changes (prompted for message)
#   S     - stash options menu:
#           - Stash all changes
#           - Stash staged changes only
#           - Stash including untracked files
#           - Stash keeping index
#
# Stash panel:
#   Space - apply stash entry (keep in stash list)
#   g     - pop stash entry (apply and remove)
#   d     - drop stash entry (remove without applying)
#   Enter - preview stash contents before applying

Conflict Resolution

When merge conflicts occur, Lazygit highlights conflicted files in the Files panel. Press Enter on a conflicted file to open the merge conflict view, which displays both sides of the conflict.

In the conflict view, press up/down arrows to navigate between conflict markers. Press left arrow to pick the incoming change (theirs), right arrow to pick the current change (ours), or b to pick both. After resolving all conflicts in a file, press Space to mark it as resolved and continue the merge or rebase.

# Conflict resolution in lazygit:
#
# 1. Conflicted files appear with red markers in Files panel
# 2. Press Enter on a conflicted file
# 3. The merge view shows both sides:
#    <<<<<<< HEAD (ours / current)
#    const name = "Alice";
#    =======
#    const name = "Bob";
#    >>>>>>> feature-branch (theirs / incoming)
#
# Navigation:
#   Up/Down  - move between conflict blocks
#   Left     - pick incoming (theirs)
#   Right    - pick current (ours)
#   b        - pick both
#   Space    - mark file as resolved after all conflicts handled

Remote Operations

Press P (uppercase) to push the current branch to the remote. Press p (lowercase) to pull. Press f to fetch all remotes. If the push is rejected, Lazygit will offer to force push with lease, which is safer than a plain force push because it checks that the remote has not been updated since your last fetch.

For managing multiple remotes, switch to the Remotes sub-panel within the Branches panel. Here you can add, edit, and remove remotes, as well as fetch from specific remotes.

# Remote operations:
#
# P (uppercase) - Push to remote
# p (lowercase) - Pull from remote
# f             - Fetch all remotes
#
# If push is rejected (non-fast-forward):
#   Lazygit prompts: "Push rejected. Force push with lease?"
#   This runs: git push --force-with-lease
#   Safe because it checks remote hasn't been updated
#
# Managing remotes:
#   Navigate to Remotes sub-tab in Branches panel
#   n - add new remote
#   d - remove remote
#   e - edit remote URL

Worktrees and Submodules

Lazygit supports Git worktrees, allowing you to work on multiple branches simultaneously without stashing or switching. Press w in the Branches panel to create a new worktree for the selected branch. Lazygit will open a new instance in the worktree directory.

For submodules, Lazygit detects them automatically and displays them in the Files panel. Press Enter on a submodule to open a new Lazygit instance inside that submodule, giving you full control over its Git operations.

# Worktrees in lazygit:
#
# In Branches panel:
#   w  - create new worktree for selected branch
#        Lazygit opens a new instance in the worktree directory
#
# Equivalent git commands:
# git worktree add ../my-feature-worktree feature-branch
# git worktree list
# git worktree remove ../my-feature-worktree
#
# Submodules:
#   Automatically detected in Files panel
#   Press Enter on a submodule -> opens new lazygit instance
#   Full Git operations available within the submodule

Custom Commands and Keybindings

Lazygit's config.yml lets you define custom commands bound to any key. This is extremely powerful for project-specific workflows like deploying, running tests, or triggering CI pipelines directly from the Git interface.

Custom commands can access context variables like the current branch name, selected commit hash, and file path. They can run in the background, show output in a popup, or open a new terminal panel.

# ~/.config/lazygit/config.yml

customCommands:
  # Run tests for current project
  - key: "T"
    command: "npm test"
    context: "global"
    subprocess: true

  # Deploy current branch
  - key: "D"
    command: "git push origin \${BranchName}:deploy"
    context: "localBranches"
    loadingText: "Deploying..."
    description: "Deploy branch"

  # Create conventional commit with scope prompt
  - key: "<c-c>"
    command: >-
      git commit -m "{{.Form.Type}}({{.Form.Scope}}): {{.Form.Message}}"
    context: "files"
    prompts:
      - type: "menu"
        key: "Type"
        title: "Commit type"
        options:
          - name: "feat"
            value: "feat"
          - name: "fix"
            value: "fix"
          - name: "refactor"
            value: "refactor"
          - name: "chore"
            value: "chore"
      - type: "input"
        key: "Scope"
        title: "Scope (optional)"
      - type: "input"
        key: "Message"
        title: "Commit message"

  # Open PR for current branch on GitHub
  - key: "O"
    command: "gh pr create --web"
    context: "localBranches"
    description: "Open PR on GitHub"
    subprocess: true

  # Show commit in browser
  - key: "B"
    command: "gh browse \${CommitSha}"
    context: "commits"
    description: "Browse commit on GitHub"

Keybinding Customization

# ~/.config/lazygit/config.yml

keybinding:
  universal:
    quit: "Q"            # Change quit key
    togglePanel: "<tab>" # Default
    prevItem: "k"
    nextItem: "j"
    scrollUpMain: "<pgup>"
    scrollDownMain: "<pgdown>"
  files:
    commitChanges: "c"
    amendLastCommit: "A"
    stashChanges: "s"
  branches:
    createNewBranch: "n"
    checkoutByName: "N"
  commits:
    squashDown: "s"
    fixupCommit: "f"
    moveDownCommit: "<c-j>"
    moveUpCommit: "<c-k>"

Editor Integration: Neovim and VS Code

Lazygit integrates seamlessly with Neovim through the lazygit.nvim plugin by kdheepak. This plugin opens Lazygit in a floating terminal window inside Neovim, bound to a configurable keymap (commonly <leader>gg). When you edit a file in Lazygit, it opens in your existing Neovim instance.

For VS Code users, Lazygit runs in the integrated terminal. You can configure VS Code to launch Lazygit with a keyboard shortcut by adding a task or using the terminal profile feature. Some users bind it to Ctrl+Shift+G as a replacement for the built-in Source Control panel.

Neovim Setup (lazygit.nvim)

-- lazy.nvim plugin spec
{
  "kdheepak/lazygit.nvim",
  cmd = {
    "LazyGit",
    "LazyGitConfig",
    "LazyGitCurrentFile",
    "LazyGitFilter",
    "LazyGitFilterCurrentFile",
  },
  dependencies = {
    "nvim-lua/plenary.nvim",
  },
  keys = {
    { "<leader>gg", "<cmd>LazyGit<cr>", desc = "Open LazyGit" },
    { "<leader>gf", "<cmd>LazyGitFilter<cr>", desc = "LazyGit filter" },
  },
}

VS Code Integration

// .vscode/tasks.json — add a task to launch lazygit
{ "version": "2.0.0", "tasks": [{
  "label": "Open Lazygit", "type": "shell", "command": "lazygit",
  "presentation": { "reveal": "always", "panel": "dedicated", "focus": true },
  "problemMatcher": []
}]}

// keybindings.json — bind to Ctrl+Shift+G
{ "key": "ctrl+shift+g", "command": "workbench.action.tasks.runTask",
  "args": "Open Lazygit" }

Filtering, Searching, and Bisect

Press / in any panel to filter the list. In the Commits panel, this lets you search commit messages. In the Branches panel, you can quickly find a branch by name. In the Files panel, filter by filename. The filter is fuzzy, so partial matches work well.

Lazygit supports git bisect for finding the commit that introduced a bug. Press b in the Commits panel to start a bisect session. Mark commits as good or bad with g and b respectively. Lazygit will navigate the binary search automatically and highlight the culprit commit.

# Bisect workflow in lazygit:
#
# 1. Navigate to Commits panel (press 4)
# 2. Press b to start bisect
# 3. Mark the current commit as bad: b
# 4. Navigate to a known good commit: g
# 5. Lazygit checks out the midpoint automatically
# 6. Test your code, then mark as good (g) or bad (b)
# 7. Repeat until the culprit commit is found
# 8. Lazygit highlights the first bad commit
#
# Equivalent git commands:
# git bisect start
# git bisect bad HEAD
# git bisect good v1.0.0
# git bisect reset

Patch Management

Lazygit has a built-in patch building feature. In the Commits panel, press Enter on a commit to view its diff. Press Space on specific files or hunks to add them to a custom patch. Once you have built your patch, press ctrl+p to open the patch options menu where you can apply the patch to the index, create a new commit from it, or copy it to the clipboard.

# Patch building workflow:
#
# 1. Go to Commits panel -> Enter on a commit
# 2. Select specific files/hunks with Space
#    (adds them to the custom patch)
# 3. Press Ctrl+P to open patch options:
#    - Apply patch to index
#    - Apply patch in reverse
#    - Create new commit from patch
#    - Copy patch to clipboard
#    - Flatten patch into current index
#
# This is extremely useful for:
# - Extracting specific changes from a large commit
# - Moving changes between branches without cherry-pick
# - Creating partial reverts

Themes and Customization

Lazygit supports full theme customization through config.yml. You can set colors for every UI element including borders, selected lines, diff highlighting, and panel backgrounds. Lazygit ships with several built-in themes and can also inherit your terminal's color scheme.

# ~/.config/lazygit/config.yml

# Catppuccin Mocha theme
gui:
  nerdFontsVersion: "3"
  theme:
    activeBorderColor:
      - "#a6e3a1"  # green
      - bold
    inactiveBorderColor:
      - "#585b70"  # surface2
    optionsTextColor:
      - "#89b4fa"  # blue
    selectedLineBgColor:
      - "#313244"  # surface0
    cherryPickedCommitBgColor:
      - "#45475a"  # surface1
    cherryPickedCommitFgColor:
      - "#a6e3a1"  # green
    unstagedChangesColor:
      - "#f38ba8"  # red
    defaultFgColor:
      - "#cdd6f4"  # text
    searchingActiveBorderColor:
      - "#f9e2af"  # yellow

# Other popular themes: Dracula, Gruvbox, Tokyo Night, Nord
# See: https://github.com/jesseduffield/lazygit/wiki/Custom-Themes

Additional Configuration

# ~/.config/lazygit/config.yml

gui:
  showFileTree: true          # Show files as tree instead of flat list
  showRandomTip: false        # Disable startup tips
  showCommandLog: false       # Hide command log by default
  showBottomLine: true        # Show keybinding hints at bottom
  sidePanelWidth: 0.3333      # Side panel takes 1/3 of width
  expandFocusedSidePanel: true # Auto-expand focused panel
  mainPanelSplitMode: "flexible" # flexible, horizontal, vertical
  language: "auto"            # auto, en, zh, ja, ko, etc.
  timeFormat: "02 Jan 06"     # Go time format for dates
  shortTimeFormat: "3:04PM"

git:
  paging:
    colorArg: always
    pager: delta --dark --paging=never  # Use delta for diffs
  commit:
    signOff: false
    autoWrapCommitMessage: true
    autoWrapWidth: 72
  merging:
    manualCommit: false
    args: ""                  # Extra args for git merge
  log:
    order: "topo-order"       # topo-order, date-order, author-date-order
    showGraph: "when-maximised" # always, never, when-maximised
  autoFetch: true             # Automatically fetch in background
  autoRefresh: true           # Refresh UI after Git operations

Performance with Large Repos

Lazygit handles large repositories efficiently because it shells out to Git for all operations rather than reimplementing Git in Go. For very large repos (100k+ commits), you can configure the commit log limit in config.yml to reduce memory usage. Lazygit also supports sparse checkout and partial clone workflows.

# Performance tuning for large repos in config.yml

git:
  log:
    showGraph: "never"         # Disable graph for faster loading
  autoFetch: false             # Disable auto-fetch on large repos
  autoRefresh: false           # Disable auto-refresh

gui:
  showFileTree: false          # Flat list is faster than tree view

# For repos with 100k+ commits:
# - Use git log --max-count to limit commit history
# - Consider git sparse-checkout for monorepos
# - Use git clone --filter=blob:none for partial clones

Common Workflows

Here are three workflows that demonstrate Lazygit's power in daily development.

Feature Branch Workflow

# Feature Branch Workflow in lazygit:
#
# 1. Create branch:    Branches panel -> n -> "feature/auth"
# 2. Make changes:     edit files in your editor
# 3. Stage changes:    Files panel -> Enter -> Space (per hunk)
# 4. Commit:           c -> "feat: add JWT authentication"
# 5. Continue work:    repeat steps 2-4
# 6. Rebase on main:   Branches panel -> select main -> r
# 7. Squash commits:   Commits panel -> s on each commit to squash
# 8. Push:             P (force push after rebase)
# 9. Create PR:        Custom command -> gh pr create --web

Hotfix Workflow

# Hotfix Workflow in lazygit:
#
# 1. Stash current work:  Files panel -> s -> "WIP: feature work"
# 2. Checkout main:       Branches panel -> Space on main
# 3. Create hotfix:       n -> "hotfix/critical-fix"
# 4. Fix the bug:         edit files
# 5. Stage and commit:    Space -> c -> "fix: critical null check"
# 6. Push:                P
# 7. Checkout feature:    Branches panel -> Space on feature branch
# 8. Pop stash:           Stash panel -> g (pop)
# 9. Rebase on main:      Branches panel -> select main -> r

Release Workflow

# Release Workflow in lazygit:
#
# 1. Checkout main:        Branches panel -> Space on main
# 2. Pull latest:          p
# 3. Create release:       n -> "release/v2.1.0"
# 4. Bump version:         edit package.json / version file
# 5. Commit:               c -> "chore: bump version to 2.1.0"
# 6. Tag:                  Commits panel -> t -> "v2.1.0"
# 7. Merge to main:        Branches panel -> select main -> M
# 8. Push with tags:       P (push), then push tags separately
#
# Push tags via custom command:
# customCommands:
#   - key: "T"
#     command: "git push --tags"
#     context: "global"

Tips and Tricks for Power Users

• Press ? in any panel to see all available keybindings for that context
• Press + and - to expand and collapse the side panels for more diff space
• Press x to open the action menu showing all possible actions for the current context
• Use undo (z) and redo (ctrl+z) to revert accidental operations like commits or branch deletions
• Press @ to open the command log showing every Git command Lazygit executes — great for learning Git
• Create a branch-specific config by placing .lazygit.yml in your project root
• Press w to open the diff menu to compare any two refs side by side
• Navigate to the Reflog panel (accessible from the Commits panel tab) to recover lost commits

Frequently Asked Questions