How To Install Lazygit on Manjaro

Managing Git repositories through command-line interfaces can be challenging, especially when dealing with complex operations like interactive rebasing, cherry-picking, or resolving merge conflicts. Lazygit transforms this experience by providing an intuitive terminal-based user interface that simplifies Git workflows without sacrificing the power and flexibility of command-line operations. This comprehensive guide walks you through multiple installation methods for Lazygit on Manjaro Linux, complete with configuration tips and troubleshooting solutions to get you started quickly.

Understanding Lazygit

What is Lazygit?

Lazygit is an open-source terminal user interface designed to make Git operations more accessible and efficient. Created by Jesse Duffield and released in August 2018, this powerful tool has become a favorite among developers who prefer keyboard-driven workflows. Unlike traditional Git GUI applications that consume significant system resources, Lazygit operates entirely within your terminal while providing visual representations of branches, commits, and file changes.

The tool functions as a wrapper around standard Git commands, replacing repetitive typing with intuitive keyboard shortcuts. You can stage files, commit changes, push to remote repositories, manage branches, and perform advanced operations like interactive rebasing—all through a clean, text-based dashboard. This approach combines the efficiency of command-line tools with the clarity of graphical interfaces.

Why Use Lazygit on Manjaro?

Manjaro’s Arch-based architecture makes it an ideal platform for running Lazygit. The official Arch repositories maintain up-to-date packages, ensuring you receive the latest features and security updates promptly. Terminal-centric workflows thrive on Manjaro, and Lazygit integrates seamlessly into this environment.

Performance is another compelling reason. Lazygit consumes minimal system resources compared to electron-based Git clients, making it perfect for both powerful workstations and lightweight systems. The tool’s keyboard-first design eliminates context switching between mouse and keyboard, significantly accelerating your development workflow.

Prerequisites and System Requirements

System Requirements

Before installing Lazygit on your Manjaro system, verify that your machine meets these basic requirements. Any Manjaro edition—XFCE, KDE Plasma, GNOME, or even minimal installations—supports Lazygit without issues. Your system should have at least 1 GB of RAM, though 2 GB is recommended for smoother performance when working with large repositories.

Disk space requirements are modest. Reserve approximately 100-200 MB of free space for the installation and its dependencies. You’ll also need access to a terminal emulator, which comes pre-installed with all Manjaro editions.

Required Software Dependencies

Git version control must be installed on your system before you can use Lazygit. Most Manjaro installations include Git by default, but you can verify its presence with the command git --version. If Git is missing, install it using sudo pacman -S git.

For AUR installations, you’ll need the base-devel package group, which provides essential build tools. An active internet connection is necessary for downloading packages during installation.

User Permissions and Knowledge

Administrative access through sudo privileges is required for system-wide installations. Familiarity with basic terminal commands helps, though this guide provides detailed instructions for each step. Understanding fundamental Git concepts enhances your Lazygit experience, though the tool’s transparency actually helps users learn Git commands by showing exactly what commands it executes.

Pre-Installation Checklist

Update your Manjaro system before proceeding with the installation. Check your available disk space with df -h. Ensure your internet connection is stable, particularly if you’re installing from AUR, which requires downloading source files and compiling packages. Verify that Git is properly configured with your username and email address, as these settings are essential for making commits through Lazygit.

Method 1: Installing Lazygit via Pacman (Official Repository)

Understanding Pacman Installation

Pacman, Manjaro’s default package manager, offers the most straightforward installation method for Lazygit. This approach downloads verified packages from official Arch repositories, ensuring stability and compatibility with your system. Automatic updates through regular system maintenance keep your Lazygit installation current without manual intervention.

Official repository installations benefit from extensive testing by the Arch community. Security vulnerabilities are patched quickly, and dependency conflicts are resolved automatically during installation. This method is recommended for most users, especially those new to Manjaro or Linux in general.

Step 1: Update System Packages

Open your terminal and synchronize your package databases with the latest versions available in the repositories. Execute the following command:

sudo pacman -Syu

This command performs two operations simultaneously. The -S flag synchronizes packages, while -y refreshes your local package database. The -u flag upgrades all installed packages to their newest versions. Depending on how long since your last update, this process may take several minutes. You’ll see download progress bars and installation confirmations as packages are updated.

Wait for the process to complete before proceeding. A fully updated system prevents potential compatibility issues during the Lazygit installation.

Step 2: Install Lazygit

With your system updated, install Lazygit using this simple command:

sudo pacman -S lazygit

Pacman automatically resolves any required dependencies and displays a list of packages that will be installed. Press Enter to confirm the installation when prompted. The download size is relatively small, typically around 10-15 MB, depending on which dependencies are already present on your system.

The installation process extracts files, sets appropriate permissions, and integrates Lazygit into your system PATH. You’ll see progress indicators as files are processed. The entire installation usually completes within one to two minutes on a standard internet connection.

Step 3: Verify Installation

Confirm that Lazygit installed correctly by checking its version:

lazygit --version

A successful installation displays the version number, which should be 0.56.0 or later as of November 2025. If you receive a “command not found” error, log out and back in to refresh your shell environment, or open a new terminal window.

Understanding Package Details

Lazygit resides in Arch’s Extra repository, specifically compiled for x86_64 architecture. The package maintainers keep it synchronized with upstream releases from the official GitHub repository. Future updates arrive automatically when you run sudo pacman -Syu during routine system maintenance, ensuring you always have access to the latest features and bug fixes.

Method 2: Installing Lazygit via AUR (Advanced Users)

Understanding AUR Installation

The Arch User Repository (AUR) provides community-maintained packages not available in official repositories. While the official Pacman repository typically offers the most recent stable release, AUR can provide access to development versions with cutting-edge features. This installation method requires additional steps but offers greater flexibility.

AUR packages compile from source code, giving you control over build options and allowing you to verify exactly what’s being installed. However, this approach demands more technical knowledge and slightly longer installation times due to compilation.

Installing AUR Helper (If Not Present)

Most Manjaro installations include pamac, which supports AUR access. Alternatively, yay is a popular AUR helper that simplifies package installation. To install yay if it’s not present:

sudo pacman -S --needed git base-devel
git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si

After installation, verify yay works by running yay --version. Other AUR helpers like paru or trizen work similarly, so choose based on your preference.

Step 1: Install Lazygit Stable from AUR

With your AUR helper ready, install Lazygit using:

yay -S lazygit

The helper searches AUR, displays package information, and asks for confirmation. It downloads the PKGBUILD file, which contains instructions for building the package, along with any necessary source files. After reviewing the build process, yay compiles the software and installs it on your system.

This process takes longer than Pacman installation because it compiles from source. Expect three to five minutes depending on your CPU speed and internet connection.

Step 2: Install Development Version (Optional)

For bleeding-edge features, install the development version instead:

yay -S lazygit-git

This package pulls the latest code from the GitHub repository’s main branch. Development versions may include experimental features and recent bug fixes not yet available in stable releases. However, they can occasionally introduce instability or bugs. Use development versions only if you need specific unreleased features or want to help test upcoming changes.

Step 3: Verify AUR Installation

Check the installation succeeded with:

lazygit --version

The version output confirms proper compilation and installation. If you installed the development version, you’ll see a version identifier that includes the Git commit hash.

AUR Installation Best Practices

Always review PKGBUILDs before installation to understand what the package will do. Run yay -Pg lazygit to view the build script. Look for suspicious commands or unexpected network access. The AUR community flags malicious packages quickly, but exercising caution protects your system.

Keep AUR packages updated separately from official repository packages. Run yay -Syu periodically to update both official and AUR packages simultaneously. Remember that AUR maintainers may take time to update packages after upstream releases, so version delays are normal.

Method 3: Installing from Binary Package

When to Use Binary Installation

Manual binary installation provides maximum control over your Lazygit version. This method works well when you need a specific version for compatibility reasons, want to avoid compilation time, or prefer minimal dependencies. It’s also useful when official repositories lag behind upstream releases and you need the latest features immediately.

Binary installations don’t integrate with your package manager’s update system, meaning you’ll handle updates manually. This trade-off suits users who prefer explicit control over their software versions.

Step 1: Download Latest Binary Release

Visit the official Lazygit GitHub repository to identify the latest release version. Then download it directly using wget or curl:

export VER="0.56.0"
wget https://github.com/jesseduffield/lazygit/releases/download/v${VER}/lazygit_${VER}_Linux_x86_64.tar.gz

Replace the version number with the current release. The export command creates an environment variable that simplifies the download URL. This approach makes it easy to update the command for newer versions by changing only one line.

Step 2: Extract Archive

Decompress the downloaded archive with:

tar xf lazygit_${VER}_Linux_x86_64.tar.gz

This command extracts the lazygit binary into your current directory. Verify the extraction succeeded by listing directory contents with ls -lh lazygit. You should see an executable file with appropriate permissions.

Step 3: Install Binary System-Wide

Move the binary to a directory in your system PATH:

sudo mv lazygit /usr/local/bin/

The /usr/local/bin directory contains locally installed programs that aren’t managed by your package manager. This location takes precedence over /usr/bin, where package managers install software. If necessary, make the file executable:

sudo chmod +x /usr/local/bin/lazygit

For user-specific installations without administrative access, move the binary to ~/.local/bin/ instead. Ensure this directory exists in your PATH by adding export PATH="$HOME/.local/bin:$PATH" to your ~/.bashrc or ~/.zshrc file.

Step 4: Verify Binary Installation

Test the installation:

lazygit --version

The command should display the version you downloaded. If you receive a “command not found” error, verify the binary location and check your PATH configuration with echo $PATH.

Manual Update Process

To update manually installed versions, repeat the download and installation process with the new version number. Remove old archive files to conserve disk space. Check the GitHub releases page periodically for updates. Consider setting a calendar reminder to check for new releases monthly, as manual installations don’t provide automatic update notifications.

Method 4: Installing via Snap (Alternative Method)

Understanding Snap Packages

Snap packages provide universal Linux software distribution through containerization. Each snap includes all its dependencies, ensuring consistent behavior across different Linux distributions. This approach increases disk usage but eliminates dependency conflicts.

On Manjaro, snaps are not the primary package format. However, they offer an alternative when other methods fail or when you need isolation between applications.

Step 1: Enable Snap Support on Manjaro

Manjaro doesn’t include Snap support by default. Install snapd from AUR:

yay -S snapd

After installation, enable the snapd socket service:

sudo systemctl enable --now snapd.socket
sudo systemctl enable --now snapd.apparmor

These commands start the snap daemon and configure AppArmor for snap security policies. Create a symbolic link to enable classic snap support:

sudo ln -s /var/lib/snapd/snap /snap

Log out and back in for all changes to take effect.

Step 2: Install Lazygit via Snap

Install the Lazygit snap package:

sudo snap install lazygit-gm

Note the package name is “lazygit-gm” rather than simply “lazygit”. The snap downloads a containerized version of Lazygit along with its runtime environment. This process takes longer than Pacman installation due to the larger download size.

Step 3: Verify Snap Installation

Test the snap installation:

lazygit-gm --version

Snap packages may require using the full package name as the command. If PATH issues prevent running the command, use the full path: /snap/bin/lazygit-gm.

Snap Considerations for Manjaro

Snap packages consume significantly more disk space than native installations—often 200-300 MB instead of 10-15 MB. They receive automatic updates through snapd, independent of your system update schedule. Containerization can cause permission issues when accessing files outside your home directory. Snaps may have slightly slower startup times due to containerization overhead.

For Manjaro users, Pacman remains the preferred installation method. Use snaps only when necessary for specific use cases.

Post-Installation Configuration

Initial Configuration

Launch Lazygit for the first time by navigating to any Git repository and running:

lazygit

The application creates its configuration directory at ~/.config/lazygit/. A default config.yml file generates automatically with standard settings. Lazygit also creates a state.yml file to remember UI preferences like panel sizes and window layouts.

If you run Lazygit outside a Git repository, it displays an error message explaining that it must be executed within a repository directory.

Customizing Lazygit Settings

Edit your configuration file to customize Lazygit’s behavior:

nano ~/.config/lazygit/config.yml

The configuration file uses YAML format. Common customizations include changing the default text editor, modifying color schemes, adjusting keyboard shortcuts, and configuring Git command arguments. For example, to set your preferred editor:

os:
  edit: 'vim {{filename}}'
  editAtLine: 'vim +{{line}} {{filename}}'

Repository-specific configurations override global settings. Create a .lazygit.yml file in your repository root or .git/lazygit.yml for repository-specific configurations that aren’t version-controlled.

Creating Aliases for Quick Access

Speed up Lazygit access by adding an alias to your shell configuration:

echo "alias lg='lazygit'" >> ~/.bashrc

For zsh users, modify ~/.zshrc instead. Source your configuration file or open a new terminal for the alias to take effect. Now you can launch Lazygit by simply typing lg.

Integration with Text Editors

Integrate Lazygit with Neovim, Vim, or other editors for seamless workflow transitions. Many developers configure their editors to open Lazygit in a terminal split or floating window. For Neovim, plugins like toggleterm.nvim enable quick Lazygit access without leaving your editing session.

Configure which editor Lazygit uses for commit messages and file editing through the config.yml file. Set editInTerminal: true for terminal-based editors or false for GUI applications.

Performance Optimization

For large repositories, optimize Lazygit’s performance by adjusting diff algorithms and limiting the number of commits loaded initially. Configure custom pagers to handle massive diffs more efficiently. These optimizations become important when working with repositories containing thousands of commits or files.

Getting Started with Lazygit

Launching Lazygit

Navigate to any Git repository directory and execute:

cd /path/to/your/repository
lazygit

The interface appears immediately, displaying your repository’s current state. If launched outside a Git repository, Lazygit exits with an informative error message prompting you to run it within a repository.

Understanding the Interface

Lazygit divides the screen into multiple panels, each serving a specific purpose. The left side contains five main sections: Status, Files, Local Branches, Commits, and Stash. The right panel displays preview information and detailed diffs for the currently selected item.

The Status section shows your current branch, upstream tracking information, and whether your working directory has uncommitted changes. Files displays modified, staged, and untracked files. Local Branches lists all branches in your repository. Commits shows your commit history with messages and authors. Stash contains any stashed changes.

Additional tabs provide access to Worktrees, Submodules, and other Git features. Navigate between these views using keyboard shortcuts explained in the next section.

Essential Keyboard Shortcuts

Lazygit’s power comes from its comprehensive keyboard shortcuts. Use j and k to move down and up within lists, mirroring Vim navigation. Press h and l to switch between left panels. Number keys (1-5) jump directly to specific panels, while Tab cycles through them sequentially.

The Space bar toggles staging and unstaging for files and individual lines. Press Enter to expand folders or view detailed information about the selected item. Press ? at any time to display a complete keybindings reference. The q key exits Lazygit.

The Escape key cancels actions or closes popup windows. Press / to search within the current view. Use [ and ] to switch between tabs in the left sidebar.

Basic Operations Walkthrough

Stage changes by navigating to the Files section with 2 and pressing Space on modified files. Stage all files by pressing a. Commit staged changes by pressing c, which opens your configured editor for the commit message. After saving and closing the editor, Lazygit creates the commit.

Push commits to your remote repository by pressing P (uppercase). Pull updates from the remote with p (lowercase). View commit history in the Commits panel by pressing 4. Each commit shows its message, author, and date.

Status Section Features

The Status panel provides an at-a-glance overview of your repository’s state. It displays your current branch name, how many commits you’re ahead or behind the upstream branch, and whether you have uncommitted changes. This information helps you quickly assess whether you need to pull updates before starting work or push your changes to share with your team.

Core Lazygit Features and Operations

File Management

Navigate to the Files panel to manage changes with precision. Press Space on individual files to stage or unstage them entirely. For more granular control, press Enter on a file to view its diff in the right panel. Within the diff view, enter multi-line selection mode by pressing v, then use j and k to select specific lines. Press Space to stage only the selected lines.

This hunk staging capability mirrors git add -p but with a more intuitive interface. You can craft precise commits containing only related changes, even when multiple unrelated modifications exist in the same file. Press Tab while viewing unstaged changes to move to staged changes, allowing you to review what will be included in your next commit.

Discard unwanted changes by pressing d on files or hunks. Lazygit prompts for confirmation before discarding to prevent accidental data loss.

Branch Operations

Switch to the Local Branches panel with 3. Create new branches by pressing n and entering a branch name. Switch branches by selecting one and pressing Space or Enter. Delete branches with d, though Lazygit prevents deletion of the current branch or branches with unmerged changes.

Merge branches by selecting a branch and pressing Shift+M. Lazygit offers merge options including fast-forward and no-fast-forward strategies. For rebasing workflows, press r on a branch to rebase the current branch onto the selected one.

Fetch updates from remote repositories by pressing f in the Branches panel. This downloads new commits and branch information without modifying your local branches. Push your current branch to remote with P, or pull and merge remote changes with p.

Commit Management

The Commits panel excels at commit history manipulation. Select a commit and press Enter to view its full diff. Press A to amend the most recent commit with currently staged changes. For older commits, use interactive rebase features.

Squash multiple commits by pressing s on commits during an interactive rebase. This combines them into a single commit, simplifying history. Reorder commits by pressing j or k while holding Ctrl to move them up or down in the rebase list. Drop unwanted commits by pressing d.

Undo the last commit while keeping changes in your working directory by pressing z. Cherry-pick specific commits to your current branch by selecting them and pressing c. This copies changes from one branch to another without merging entire branches.

Edit commit messages by pressing r for reword. Reset to a specific commit by pressing g and choosing reset options (soft, mixed, or hard).

Stash Operations

Access stashed changes in the Stash panel by pressing 5. Create a new stash of current changes by pressing s in the Files panel. This stores modifications without committing them, useful when switching contexts.

Apply and delete a stash simultaneously by pressing g on it. To apply without deleting, press Space. This leaves the stash available for applying to other branches. Delete stashes you no longer need by pressing d.

Rename stashes for better organization by pressing r and entering a descriptive name. Managing multiple stashes becomes easier when they have meaningful names describing their contents.

Advanced Features

Resolve merge conflicts efficiently through Lazygit’s conflict resolution interface. When conflicts occur, the Files panel highlights affected files. Select a conflicted file and press Space to cycle through resolution options: accept ours, accept theirs, or manual resolution.

Interactive rebase operations provide surgical control over commit history. Press e on a commit to edit it, pausing the rebase to make changes. Continue the rebase after making modifications. The interface shows rebase progress and status clearly.

View the actual Git commands Lazygit executes by observing the command log. This transparency helps users understand Git operations and learn command-line equivalents. Copy information to your clipboard using Ctrl+o – this copies filenames in Files view, branch names in Branches view, or commit hashes in Commits view.

Execute custom Git commands by pressing : to open a command prompt. This provides access to any Git operation not directly exposed through Lazygit’s interface.

Troubleshooting Common Issues

Installation Problems

If Pacman reports “package not found” errors, synchronize your package database with sudo pacman -Sy and try again. For AUR installations that fail during compilation, ensure base-devel is installed: sudo pacman -S base-devel. Review error messages carefully—they often indicate missing dependencies.

Binary installations encountering permission issues require proper file permissions. Verify with ls -l /usr/local/bin/lazygit. The file should be executable by all users. If not, run sudo chmod 755 /usr/local/bin/lazygit.

Snap installations occasionally fail due to snapd service issues. Restart the service with sudo systemctl restart snapd.socket and retry the installation.

Runtime Errors

The “Not a git repository” message appears when launching Lazygit outside a Git repository. Navigate to a repository directory before running the command. Alternatively, initialize a new repository with git init if starting a new project.

Git configuration errors prevent commits. Set your identity with:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Permission denied errors when accessing repositories usually stem from file ownership issues. Check repository ownership with ls -la and adjust with sudo chown -R $USER:$USER /path/to/repository if necessary.

Terminal compatibility problems rarely occur but may affect rendering. Ensure your terminal emulator supports UTF-8 encoding and has sufficient color depth. Most modern terminals work perfectly with Lazygit.

Performance Issues

Large repositories may load slowly. Configure Lazygit to limit initial commit loading in config.yml. Adjust the maxCommitsOnScreen setting to reduce memory usage. Disable expensive operations like detailed diff generation for binary files.

High memory usage in massive repositories benefits from periodic garbage collection: git gc --aggressive. This optimizes Git’s internal database and improves Lazygit’s performance.

Network timeout issues during fetch or push operations typically indicate connection problems or large transfer sizes. Increase Git’s timeout settings:

git config --global http.postBuffer 524288000
git config --global http.timeout 600

Configuration Problems

Config file syntax errors prevent Lazygit from starting. Validate your YAML syntax using online validators or by checking error messages carefully. Improper indentation commonly causes YAML parsing failures.

Keyboard shortcut conflicts occur when custom keybindings override default ones. Review your config.yml file’s keybinding section. Reset to defaults by deleting or renaming the config file, allowing Lazygit to regenerate it.

Custom themes not loading may indicate incorrect file paths or malformed theme definitions. Verify theme file locations and YAML formatting.

Shell aliases not working require sourcing your configuration file. Run source ~/.bashrc or open a new terminal window. Verify the alias exists with alias lg.

Congratulations! You have successfully installed Lazygit. Thanks for using this tutorial for installing Lazygit on your Manjaro Linux system. For additional or useful information, we recommend you check the official Lazygit website.