How to Install Git on Debian Linux

Git is a distributed version control system that tracks changes in your codebase, enabling you to collaborate with other developers, revert to previous states, and manage multiple project branches simultaneously. Whether you need to contribute to open-source projects on GitHub, deploy applications to production servers, or maintain version history for personal projects, Git provides the foundation for modern development workflows. By the end of this guide, you will have Git installed and configured on your Debian system, ready to initialize repositories and sync with remote services.

Choose Your Git Installation Method

Debian provides Git through its default repositories, while compiling from source gives you access to the latest release. The following table summarizes both approaches to help you decide which fits your needs.

Method	Channel	Version	Updates	Best For
APT (Default Repository)	Debian packages	Distribution default	Automatic via apt upgrade	Most users who want stability and easy maintenance
Source Compilation	GitHub releases	Latest stable	Manual recompilation required	Users who need cutting-edge features or specific build options

For most users, the APT method is recommended because it provides automatic security updates and requires no manual maintenance. However, compile from source if you specifically need features unavailable in the repository version.

The Git version in Debian repositories varies by release: Debian 13 (Trixie) includes Git 2.47.x, Debian 12 (Bookworm) provides Git 2.39.x, and Debian 11 (Bullseye) offers Git 2.30.x. For most workflows, these versions work identically.

Update Debian Before Git Installation

Before installing any software, first update your package lists and upgrade existing packages to avoid dependency conflicts:

sudo apt update && sudo apt upgrade

As a result, your system will have the latest security patches and package metadata.

Method 1: Install Git with APT

The APT method installs Git from Debian’s official repositories. Additionally, this version receives security updates automatically and integrates with your system’s package management.

Install Git from Default Repository

Install Git using the APT package manager:

sudo apt install git

APT resolves all dependencies automatically and configures Git for immediate use.

Verify Git Installation

Next, confirm the installation succeeded by checking the version:

git --version

Expected output on Debian 13:

git version 2.47.3

The version number varies depending on your Debian release; however, any output confirms Git is installed correctly.

Method 2: Compile Git from Source

Alternatively, compiling from source provides the latest Git release with all new features. This method requires manual updates when new versions are released, but in return gives you complete control over the build configuration.

Install Build Dependencies

Git requires several development libraries and build tools. Install them with:

sudo apt install build-essential libssl-dev zlib1g-dev libcurl4-gnutls-dev libexpat1-dev gettext

Specifically, this installs the C compiler, make utility (included in build-essential), and development headers for SSL encryption, compression, HTTP transfers, and XML parsing that Git needs during compilation.

Download Git Source Code

Next, download the latest stable release. You can use an automated command that always fetches the current version, or alternatively download manually if you prefer a simpler approach:

curl -s https://api.github.com/repos/git/git/tags | grep -oP '"name": "v\K[0-9]+\.[0-9]+\.[0-9]+' | head -1 | xargs -I{} wget https://github.com/git/git/archive/refs/tags/v{}.tar.gz

This automated approach saves you from manually checking version numbers each time Git updates. Specifically, here is how it works:

• curl -s: Silently fetches Git’s release tags from the GitHub API
• grep -oP: Extracts version numbers using regex (e.g., 2.52.0)
• head -1: Takes the first match (latest stable version)
• xargs -I{}: Passes the version number to wget, constructing the download URL

If the piped command syntax seems confusing, you can download manually instead: visit the Git releases page, find the latest stable version tag, and run wget https://github.com/git/git/archive/refs/tags/vX.XX.X.tar.gz with the actual version number. The automated command above simply does this lookup step for you.

Extract the Source Archive

Once downloaded, extract the tarball:

tar -xvf v*.tar.gz

Then navigate into the extracted directory:

cd git-*/

Compile Git

Now compile the source code using make. The prefix=/usr/local option installs Git to /usr/local/bin, keeping it separate from system-managed packages:

make prefix=/usr/local all

Compilation takes a few minutes depending on your system. During this process, you will see compiler output scrolling as each component builds.

Install Compiled Git

After compilation completes, install the compiled binaries to your system:

sudo make prefix=/usr/local install

This command copies Git executables, documentation, and support files to /usr/local/.

Verify Source Installation

Finally, confirm the newly compiled version is active:

git --version

Expected output:

git version 2.52.0

If instead the version shows an older number, your shell may be finding the APT-installed Git first. Run which git to check the path—it should show /usr/local/bin/git for the source-compiled version.

Configure Git After Installation

After installing Git, you need to configure your identity. Git attaches your name and email to every commit, which is required before you can commit changes.

Set Your Name and Email

Configure your Git identity with these commands, replacing the placeholders with your actual information:

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

The --global flag applies these settings to all repositories on your system. Alternatively, omit it to configure settings for a single repository only.

Set Default Branch Name

Modern Git repositories typically use main as the default branch name instead of master. Therefore, configure this preference:

git config --global init.defaultBranch main

As a result, new repositories you create will use main as the initial branch, matching GitHub and GitLab defaults.

Verify Configuration

To verify your settings, review your Git configuration:

git config --list

Expected output:

user.name=Your Name
user.email=your.email@example.com
init.defaultbranch=main

Alternatively, you can view the configuration file directly:

cat ~/.gitconfig

Essential Git Commands

With Git installed and configured, here are the fundamental commands for daily use.

Initialize a New Repository

Create a new Git repository in a project directory:

mkdir my-project
cd my-project
git init

As a result, this creates a hidden .git directory that stores all version history and configuration for the repository.

Check Repository Status

View the current state of your working directory and staging area:

git status

This output shows which files are modified, staged for commit, or untracked.

Stage and Commit Changes

Add files to the staging area and create a commit:

git add .
git commit -m "Initial commit"

Here, the git add . command stages all changes in the current directory, while the -m flag provides a commit message describing your changes.

Connect to a Remote Repository

Link your local repository to a remote service like GitHub or GitLab:

git remote add origin https://github.com/username/repository.git

Replace the URL with your actual repository address. The name origin is the conventional name for the primary remote.

Push and Pull Changes

Upload your commits to the remote repository:

git push -u origin main

The -u flag sets up tracking, so consequently future pushes only require git push.

Similarly, download changes from the remote repository:

git pull origin main

This fetches remote changes and merges them into your current branch.

Cache Credentials

Avoid re-entering credentials for HTTPS remotes by enabling credential caching:

git config --global credential.helper cache
git config --global credential.helper "cache --timeout=18000"

This caches credentials for 5 hours (18000 seconds). For permanent storage, instead consider using SSH keys rather than HTTPS authentication.

Troubleshoot Common Git Issues

The following solutions address problems you may encounter when using Git on Debian.

SSL Certificate Errors

If Git fails to connect to HTTPS repositories, you may see an error like this:

fatal: unable to access 'https://github.com/user/repo.git/': SSL certificate problem: unable to get local issuer certificate

This typically indicates outdated or missing CA certificates. Reinstall them to fix the issue:

sudo apt install --reinstall ca-certificates

Additionally, for corporate networks with custom certificates, you may need to add your organization’s CA to the system trust store.

Permission Denied Errors

When pushing or pulling over SSH, you may encounter this error:

git@github.com: Permission denied (publickey).
fatal: Could not read from remote repository.

This means your SSH key is not configured or not loaded. Test your SSH authentication:

ssh -T git@github.com

If authentication fails, you need to generate an SSH key and add it to your GitHub/GitLab account. See the SSH installation guide for Debian for detailed instructions.

If you encounter permission errors on local repository files owned by root, fix the ownership:

sudo chown -R $(whoami):$(whoami) .git

Verify the ownership change:

ls -la .git

You should see your username as the owner instead of root.

Wrong Git Version After Source Install

If git --version shows the old APT version after compiling from source, your shell PATH may prioritize /usr/bin over /usr/local/bin. Check the active Git path:

which git

If it shows /usr/bin/git, either remove the APT package (sudo apt remove git) or add /usr/local/bin to the front of your PATH. To make this change permanent, append the export to your shell configuration file:

echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.bashrc

Subsequently, reload your shell configuration to apply the change immediately:

source ~/.bashrc

Now verify that the correct Git version is active:

git --version

The output should show your source-compiled version instead of the APT version.

Remove Git from Debian

If you need to uninstall Git, the removal process depends on how you installed it.

Remove APT-Installed Git

Remove Git and its unused dependencies:

sudo apt remove git
sudo apt autoremove

Verify removal:

git --version

Expected output:

-bash: git: command not found

Remove Source-Compiled Git

If you compiled Git from source, navigate to the source directory and run the uninstall target:

cd ~/git-*/
sudo make prefix=/usr/local uninstall

Alternatively, if you no longer have the source directory, manually remove the installed files:

sudo rm -rf /usr/local/bin/git*
sudo rm -rf /usr/local/libexec/git-core
sudo rm -rf /usr/local/share/git-core

Remove Git Configuration Files

The following commands permanently delete your Git configuration, including saved credentials and aliases. Back up ~/.gitconfig first if you want to preserve these settings.

Remove user-level Git configuration:

rm -rf ~/.gitconfig ~/.git-credentials

Conclusion

You now have Git installed on Debian with your identity configured and the default branch set to main. The APT method provides automatic updates for stable usage, while source compilation gives you access to the latest features. From here, you can explore GitHub Desktop on Debian for a graphical interface, or alternatively set up GitLab on Debian to host your own repositories.