How to Install Go on Debian Linux

Go (often called Golang) is a compiled programming language designed for building web servers, command-line tools, and networked services. If you need to develop APIs, microservices, or system utilities, Go provides fast compilation, built-in concurrency through goroutines (lightweight threads managed by Go’s runtime), and a comprehensive standard library that reduces external dependencies. By the end of this guide, you will have Go installed on Debian with environment variables configured and a working test project to confirm everything runs correctly.

Choose Your Go Installation Method

Debian provides Go through its default repositories, but these versions lag behind the official releases. The table below compares your options so you can choose the approach that fits your needs.

Method	Channel	Version	Updates	Best For
APT	Debian Repos	1.15–1.24 (varies by release)	Automatic via apt upgrade	Users who prioritize stability over latest features
Official Tarball	go.dev	Latest stable	Manual reinstall	Developers needing current Go features and security patches
Source Compilation	go.dev/doc	Any release tag	Manual recompile	Contributors and users needing custom build flags

For most users, the official tarball method is recommended because Debian repository versions are often several major releases behind. Go 1.24+ includes significant performance improvements and security fixes not available in older repository packages. Source compilation is available for contributors who want to modify Go internals or need specific build configurations.

Update Debian System Packages

Before installing Go, update your package lists and upgrade existing packages to ensure your system has the latest security patches and avoid potential conflicts during installation.

sudo apt update && sudo apt upgrade

Next, install the required utilities for downloading and extracting the Go archive. These packages are typically pre-installed, but minimal Debian installations may lack them.

sudo apt install curl wget tar

Install Go from APT Repository (Stable Option)

If you prefer automatic updates through your package manager and can work with an older Go version, install from the Debian repositories. This method requires no manual maintenance but provides versions that trail the official releases.

sudo apt install golang-go

Verify the installation by checking the version:

go version

Expected output varies by Debian release:

go version go1.24.x linux/amd64   # Debian 13 (Trixie)
go version go1.19.x linux/amd64   # Debian 12 (Bookworm)
go version go1.15.x linux/amd64   # Debian 11 (Bullseye)

If the repository version meets your requirements, skip ahead to the verification section. Otherwise, continue with the official tarball installation below for the latest Go release.

Install Go from Official Tarball (Recommended)

The official tarball from go.dev provides the latest stable Go release with all current features and security patches. This method works identically across Debian 11, 12, and 13.

Check System Architecture

First, confirm your system architecture to download the correct package:

dpkg --print-architecture

amd64

The commands below automatically detect your system architecture. Most systems use amd64 (64-bit Intel/AMD), but the commands also support arm64 (Apple Silicon, ARM servers).

Download Latest Go Release

The following command automatically detects your architecture and downloads the latest stable Go release from the official website:

cd /tmp
GO_ARCH=$(dpkg --print-architecture)
GO_TARBALL=$(curl -sL https://go.dev/dl/ | grep -oP "go[0-9]+\.[0-9]+\.[0-9]+\.linux-${GO_ARCH}\.tar\.gz" | head -1)
[ -z "$GO_TARBALL" ] && echo "Failed to detect Go version" && exit 1
wget "https://go.dev/dl/$GO_TARBALL"

• curl -sL — Fetches the download page silently and follows redirects
• grep -oP — Extracts the tarball filename using a Perl-compatible regex
• head -1 — Takes the first match (the latest stable release)
• [ -z "$GO_TARBALL" ] — Guards against empty variable if page parsing fails

Alternatively, visit go.dev/dl to manually download a specific version if you need to match a project’s Go version requirements.

Remove Previous Go Installation

If you have an existing Go installation in /usr/local/go, remove it before extracting the new version to prevent conflicts:

sudo rm -rf /usr/local/go

Extract Go Archive

Extract the downloaded archive to /usr/local, which creates the /usr/local/go directory containing the Go toolchain:

GO_ARCH=$(dpkg --print-architecture)
sudo tar -C /usr/local -xzf go*.linux-${GO_ARCH}.tar.gz
rm -f /tmp/go*.linux-${GO_ARCH}.tar.gz

Install Go from Source (Advanced)

Building Go from source gives you access to any release version and the ability to customize build flags. This method requires a bootstrap Go compiler since the Go toolchain is written in Go itself. The process works identically across Debian 11, 12, and 13.

Install Build Prerequisites

Update package lists and install Git for cloning the source repository. GCC enables cgo support, which allows Go programs to call C libraries (similar to how Python ctypes or Java JNI bridge to native code):

sudo apt update
sudo apt install git gcc

If you only need pure Go programs without C library integration, you can skip GCC and set CGO_ENABLED=0 during the build. However, GCC is recommended for full functionality.

Download Bootstrap Compiler

Go 1.24 and newer require Go 1.22 or later as a bootstrap compiler. Since Debian repository versions may be too old (Debian 11 ships 1.15, Debian 12 ships 1.19), download the official tarball as your bootstrap:

cd /tmp
GO_ARCH=$(dpkg --print-architecture)
curl -LO "https://go.dev/dl/go1.22.12.linux-${GO_ARCH}.tar.gz"
sudo tar -C /usr/local -xzf go1.22.12.linux-${GO_ARCH}.tar.gz
sudo mv /usr/local/go /usr/local/go-bootstrap
rm -f go1.22.12.linux-${GO_ARCH}.tar.gz

Verify the bootstrap compiler is available:

/usr/local/go-bootstrap/bin/go version

go version go1.22.12 linux/amd64

Clone Go Source Repository

Clone the Go source from the official repository and check out the release tag you want to build. The following command fetches only the specified version to minimize download size:

cd /tmp
GO_TAG=$(curl -sL https://go.dev/dl/ | grep -oP 'go[0-9]+\.[0-9]+\.[0-9]+\.src\.tar\.gz' | head -1 | sed 's/\.src\.tar\.gz//')
[ -z "$GO_TAG" ] && echo "Failed to detect Go version" && exit 1
echo "Cloning $GO_TAG..."
git clone --depth 1 --branch "$GO_TAG" https://go.googlesource.com/go goroot

The command above automatically detects the latest stable release. To build a specific version, replace the GO_TAG variable with your desired tag (e.g., GO_TAG=go1.24.9). See available tags at go.dev/dl.

Build Go from Source

Set the GOROOT_BOOTSTRAP environment variable to point to your bootstrap compiler, then run the build script:

export GOROOT_BOOTSTRAP=/usr/local/go-bootstrap
cd /tmp/goroot/src
./make.bash

The build takes approximately 2-5 minutes depending on your hardware. When complete, you see:

Building Go cmd/dist using /usr/local/go-bootstrap. (go1.22.12 linux/amd64)
Building Go toolchain1 using /usr/local/go-bootstrap.
Building Go bootstrap cmd/go (go_bootstrap) using Go toolchain1.
Building Go toolchain2 using go_bootstrap and Go toolchain1.
Building Go toolchain3 using go_bootstrap and Go toolchain2.
Building packages and commands for linux/amd64.
---
Installed Go for linux/amd64 in /tmp/goroot
Installed commands in /tmp/goroot/bin
*** You need to add /tmp/goroot/bin to your PATH.

Install Built Go to System Location

Move the compiled Go tree to the standard installation location and clean up the bootstrap compiler:

sudo rm -rf /usr/local/go
sudo mv /tmp/goroot /usr/local/go
sudo rm -rf /usr/local/go-bootstrap

Verify the source-built version is installed:

/usr/local/go/bin/go version

go version go1.x.x linux/amd64

The source-built Go installs to the same location as the tarball method (/usr/local/go), so the environment variable configuration in the next section applies to both methods.

Configure Go Environment Variables

Go requires the PATH environment variable to include its binary directory. Additionally, setting GOPATH defines where Go stores downloaded modules and compiled binaries for your projects.

Temporary Configuration (Current Session)

To test Go immediately without modifying any configuration files, export the variables directly in your terminal. These settings last only until you close the terminal:

export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
export GOPATH=$HOME/go

Permanent Configuration (Bash)

For permanent configuration with bash (the default shell on Debian), add Go to your shell profile. The ~/.profile file is sourced by login shells and works reliably across Debian 11, 12, and 13:

grep -q '/usr/local/go/bin' ~/.profile || cat >> ~/.profile << 'EOF'

# Go programming language
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
export GOPATH=$HOME/go
EOF

The grep -q check prevents duplicate entries if you run the command again. Load the updated configuration into your current terminal session:

source ~/.profile

Alternatively, add the exports to ~/.bashrc if you want the configuration loaded for interactive non-login shells as well. However, ~/.profile is the standard location for environment variables on Debian systems.

Permanent Configuration (Zsh)

If you use zsh instead of bash, add the configuration to ~/.zshrc:

grep -q '/usr/local/go/bin' ~/.zshrc || cat >> ~/.zshrc << 'EOF'

# Go programming language
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
export GOPATH=$HOME/go
EOF
source ~/.zshrc

System-Wide Configuration (All Users)

To make Go available for all users on the system, create a dedicated profile script in /etc/profile.d/:

sudo tee /etc/profile.d/golang.sh > /dev/null << 'EOF'
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
EOF

This script runs automatically for all users during login. Log out and back in, or source it manually to apply immediately:

source /etc/profile.d/golang.sh

Verify Environment Configuration

Regardless of which method you chose, verify Go is accessible and check the installed version:

go version

go version go1.x.x linux/amd64

Version numbers shown in this guide reflect the latest stable release at the time of writing. Your output may show a newer version, which is expected as Go releases updates regularly.

Confirm the environment variables are set correctly:

go env | grep -E '^GO(PATH|ROOT)='

GOPATH='/home/username/go'
GOROOT='/usr/local/go'

• GOROOT — Location of the Go installation itself (/usr/local/go), similar to C:\Go on Windows. You rarely need to modify this.
• GOPATH — Your personal workspace (~/go) where Go stores downloaded dependencies, compiled packages, and any tools you install with go install. Think of it like npm’s node_modules but user-wide rather than per-project.

Verify Installation with Hello World

Create a simple Go program to confirm the installation works correctly. This test verifies that the compiler runs, modules initialize properly, and the build process completes successfully.

Create a project directory and initialize a Go module:

mkdir -p ~/go-hello && cd ~/go-hello
go mod init hello

go: creating new go.mod: module hello

Create the main program file:

cat > hello.go << 'EOF'
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
EOF

Build and run the program:

go build -o hello
./hello

Hello, World!

If you see the output above, Go is correctly installed and configured. You can now develop Go applications on your Debian system.

Clean up the test project when finished:

cd ~ && rm -rf ~/go-hello

Update Go to a New Version

Go releases occur regularly with security patches and new features. To update your installation, repeat the download and extraction process with the new version.

Check your current version:

go version

Download and install the latest release:

cd /tmp
GO_ARCH=$(dpkg --print-architecture)
GO_TARBALL=$(curl -sL https://go.dev/dl/ | grep -oP "go[0-9]+\.[0-9]+\.[0-9]+\.linux-${GO_ARCH}\.tar\.gz" | head -1)
[ -z "$GO_TARBALL" ] && echo "Failed to detect Go version" && exit 1
wget "https://go.dev/dl/$GO_TARBALL"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go*.linux-${GO_ARCH}.tar.gz
rm -f /tmp/go*.linux-${GO_ARCH}.tar.gz

Verify the update completed successfully:

go version

go version go1.x.x linux/amd64

Your existing Go projects and installed packages in $GOPATH remain intact after updating. The Go toolchain maintains backward compatibility, so projects built with older versions typically compile without modification.

Update Script for Source-Compiled Go

If you installed Go from source and prefer an automated update process, save the following script to your home directory. The script detects the latest version, downloads and compiles it using your existing Go installation as the bootstrap compiler:

cat > ~/update-go-source.sh << 'SCRIPT'
#!/bin/bash
set -e

# Check prerequisites
for cmd in git curl; do
    if ! command -v $cmd &> /dev/null; then
        echo "Error: $cmd is required but not installed."
        exit 1
    fi
done

# Get current and latest versions
CURRENT_VERSION=$(go version 2>/dev/null | grep -oP 'go[0-9]+\.[0-9]+\.[0-9]+' || echo "none")
LATEST_TAG=$(curl -sL https://go.dev/dl/ | grep -oP 'go[0-9]+\.[0-9]+\.[0-9]+\.src\.tar\.gz' | head -1 | sed 's/\.src\.tar\.gz//')

if [ -z "$LATEST_TAG" ]; then
    echo "Error: Could not detect latest Go version from go.dev"
    exit 1
fi

echo "Current version: $CURRENT_VERSION"
echo "Latest version:  $LATEST_TAG"

if [ "$CURRENT_VERSION" = "$LATEST_TAG" ]; then
    echo "Already running the latest version."
    exit 0
fi

echo "Updating to $LATEST_TAG..."
cd /tmp

# Use current Go as bootstrap
export GOROOT_BOOTSTRAP=/usr/local/go

# Clone and build
rm -rf goroot
git clone --depth 1 --branch "$LATEST_TAG" https://go.googlesource.com/go goroot
cd goroot/src
./make.bash

# Install
sudo rm -rf /usr/local/go.bak
sudo mv /usr/local/go /usr/local/go.bak
sudo mv /tmp/goroot /usr/local/go
sudo rm -rf /usr/local/go.bak

echo "Successfully updated to $(/usr/local/go/bin/go version)"
SCRIPT
chmod +x ~/update-go-source.sh

Run the update script manually when you want to upgrade:

~/update-go-source.sh

Avoid automating this with cron. Source compilation can fail due to network issues, missing dependencies after system updates, or breaking changes between major versions. Run the script manually so you can monitor the output and address problems before they affect your development environment.

Troubleshoot Common Go Issues

Command Not Found After Installation

If you run go version and see “command not found,” your shell cannot locate the Go binary.

bash: go: command not found

This happens when the PATH environment variable does not include /usr/local/go/bin. First, confirm Go is actually installed by checking if the binary exists:

ls -la /usr/local/go/bin/go

A successful result shows the binary with its permissions and size:

-rwxr-xr-x 1 root root 16441344 Nov 12 18:02 /usr/local/go/bin/go

Seeing “No such file or directory” means Go is not installed. Return to the installation section and repeat the tarball extraction. When the file exists but the command still fails, check whether your shell profile includes the Go path:

grep "go/bin" ~/.profile

No output indicates the export line is missing. Add it:

echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.profile
source ~/.profile

Verify the fix worked:

go version

go version go1.x.x linux/amd64

Version Conflict with APT Package

If you previously installed Go via APT and then installed the official tarball, both versions may conflict. Remove the APT package first:

sudo apt purge golang-go golang-src
sudo apt autoremove

Verify only the tarball version remains:

which go
go version

/usr/local/go/bin/go
go version go1.x.x linux/amd64

GOPATH Permission Issues

If go install fails with permission errors, ensure GOPATH points to a user-writable directory:

go env GOPATH
ls -la $(go env GOPATH)

The GOPATH directory should be owned by your user. If it does not exist, Go creates it automatically on first use. If permissions are incorrect, fix them:

sudo chown -R $USER:$USER ~/go

Remove Go from Debian

The removal process differs depending on your installation method.

Remove APT Installation

If you installed Go via APT, remove it with the package manager:

sudo apt purge golang-go golang-src
sudo apt autoremove

Remove Tarball or Source-Compiled Installation

Both the official tarball and source compilation methods install Go to /usr/local/go, so the removal process is identical. Remove the installation directory:

sudo rm -rf /usr/local/go

If you built from source and the bootstrap compiler still exists, remove it as well:

sudo rm -rf /usr/local/go-bootstrap

Remove the environment variable exports from your shell profile. Edit the appropriate file based on your shell and configuration method:

• Bash users: Edit ~/.profile or ~/.bashrc
• Zsh users: Edit ~/.zshrc
• System-wide configuration: Remove /etc/profile.d/golang.sh

For user-level configuration, open your profile file:

nano ~/.profile

Delete the lines containing /usr/local/go/bin and GOPATH, then save and exit.

If you configured Go system-wide, remove the profile script:

sudo rm /etc/profile.d/golang.sh

Warning: The ~/go directory contains downloaded modules, compiled binaries, and build cache from your projects. This includes any Go tools you installed with go install. Back up any needed files before removing it.

Optional: Remove the Go workspace directory and build cache if you no longer need cached modules and installed binaries:

rm -rf ~/go
rm -rf ~/.cache/go-build

Verify Go is completely removed by starting a new terminal session and checking:

command -v go || echo "go not found"

go not found

Conclusion

You now have Go installed on Debian with environment variables configured for development. The Hello World test confirms the compiler, module system, and build process work correctly. From here, explore the official Go documentation to learn about packages, testing, and project structure, then set up Git for version control and consider Docker for containerized deployments.