# Installing Go on Debian 12

Go (Golang) is an open-source programming language designed for simplicity, reliability, and efficiency — a fast, statically typed compiled language suited to scalable web servers, cloud-native applications, and command-line tools. This guide installs Go on Debian 12 using APT, verifies the installation with a sample application, and manages multiple Go versions with both a manual source install and the Go Version Manager (GVM). By the end, you'll have a working Go installation with the ability to switch between multiple Go versions on demand, following Go environment setup practices documented in [**Vultr Docs**](https://docs.vultr.com/how-to-install-go-on-debian-12).

> **Prerequisites:** a Debian 12 server, SSH access, and a non-root user with sudo privileges.

* * *

## Install Go on Debian 12

Go is available in the default APT package repositories on Debian 12.

**1\. Update the server's package information index:**

```console
sudo apt update
```

**2\. Install Go:**

```console
sudo apt install golang -y
```

**3\. View the installed Go version:**

```console
go version
```

Output:

```plaintext
go version go1.19.8 linux/amd64
```

## Test the Go Installation

Create a sample application to verify that Go runs correctly on the server.

**1\. Create a new** `go-sample` **project directory:**

```console
mkdir go-sample
```

**2\. Switch to the** `go-sample` **directory:**

```console
cd go-sample
```

**3\. Initialize a new** `example.com/hello` **Go module in the directory:**

```console
go mod init example.com/hello
```

**4\. Create a new** `main.go` **application file using a text editor like** `nano`**:**

```console
nano main.go
```

**5\. Add the following contents to the** `main.go` **file:**

```go
package main

import "fmt"

func main() {
    fmt.Println("Hello from Go")
}
```

Save and close the file. The application prints a greeting message when you run it.

**6\. Run the** `main.go` **application file:**

```console
go run main.go
```

Output:

```plaintext
Hello from Go
```

## Install Multiple Go Versions

Maintaining multiple Go versions on your system lets you meet different project requirements. You can install specific versions manually from source, or use the Go Version Manager (GVM).

### Install Multiple Go Versions From Source

**1\. Visit the** [**Go releases webpage**](https://go.dev/dl/) **and download a specific Go version's archive file. For example, Go version** `1.23.0`**:**

```console
wget https://go.dev/dl/go1.23.0.linux-amd64.tar.gz
```

**2\. Download another Go version, such as** `1.21.0`**:**

```console
wget https://go.dev/dl/go1.21.0.linux-amd64.tar.gz
```

**3\. Create a new** `/usr/local/go1.23.0` **directory to store the** `1.23.0` **Go version files:**

```console
sudo mkdir -p /usr/local/go1.23.0
```

**4\. Create another** `/usr/local/go1.21.0` **directory to store the** `1.21.0` **Go version files:**

```console
sudo mkdir -p /usr/local/go1.21.0
```

**5\. Extract the** `1.23.0` **Go archive files to the** `/usr/local/go1.23.0` **directory:**

```console
sudo tar -C /usr/local/go1.23.0 -xzf go1.23.0.linux-amd64.tar.gz
```

**6\. Extract the** `1.21.0` **Go archive files to the** `/usr/local/go1.21.0` **directory:**

```console
sudo tar -C /usr/local/go1.21.0 -xzf go1.21.0.linux-amd64.tar.gz
```

**7\. Create a new** `PATH` **environment variable and set the** `1.23.0` **Go version to activate it as the default on the server:**

```console
export PATH=/usr/local/go1.23.0/go/bin:$PATH
```

**8\. Verify the active Go version:**

```console
go version
```

Output:

```plaintext
go version go1.23.0 linux/amd64
```

**9\. Create a new** `go123` **alias for the** `1.23.0` **Go version to access it using a single command:**

```console
echo "alias go123='/usr/local/go1.23.0/go/bin/go'" >> ~/.bashrc
```

**10\. Create another** `go121` **alias for the** `1.21.0` **Go version to access it using a single command:**

```console
echo "alias go121='/usr/local/go1.21.0/go/bin/go'" >> ~/.bashrc
```

**11\. Reload your shell configuration to apply the changes:**

```console
source ~/.bashrc
```

**12\. Run the alias command associated with the installed Go version. For example, run** `main.go` **using the** `1.23.0` **Go version:**

```console
go123 run main.go
```

Output:

```plaintext
Hello from Go
```

**13\. Run the** `main.go` **application file using the** `go121` **alias command:**

```console
go121 run main.go
```

Output:

```plaintext
Hello from Go
```

> Repeat this process for each Go version you want to install and run on the server.

### Install Multiple Go Versions Using GVM

The Go Version Manager (GVM) lets you install and use specific Go versions without manually setting up a `PATH` variable or downloading binary packages.

**1\. Update the server's package information index:**

```console
sudo apt update
```

**2\. Install all required GVM dependency packages:**

```console
sudo apt install -y curl git make binutils bison gcc
```

**3\. Download and install GVM using the latest installation script:**

```console
bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
```

**4\. Reload your shell configuration to apply the changes:**

```console
source ~/.gvm/scripts/gvm
```

**5\. Use GVM to install a specific Go version. For example, Go version** `1.20.8`**:**

```console
gvm install go1.20.8
```

Output:

```plaintext
go1.20.8 successfully installed!
```

**6\. Set the** `1.20.8` **Go version as the default:**

```console
gvm use go1.20.8 --default
```

Output:

```plaintext
Now using version go1.20.8
```

**7\. View the active Go version:**

```console
go version
```

Output:

```plaintext
go version go1.20.8 linux/amd64
```

**8\. Install another Go version. For example, Go version** `1.21.5`**:**

```console
gvm install go1.21.5
```

**9\. List all installed Go versions:**

```console
gvm list
```

Output:

```plaintext
gvm gos (installed)

    go1.20.8
    go1.21.5
    system
```

**10\. Switch to a specific Go version, such as** `go1.21.5`**, in your shell environment:**

```console
gvm use go1.21.5
```

## Next Steps

*   Explore Go modules and popular frameworks like Gin or Echo for building web services
    
*   Set up a CI pipeline that builds and tests your Go application on every commit
    
*   Cross-compile your Go application for other operating systems and architectures
    
*   Package your Go binary as a systemd service for production deployment
    

For the full guide with additional tips, visit the original article on [**Vultr Docs**](https://docs.vultr.com/how-to-install-go-on-debian-12).