Setup und Installation

Welche Go-Version brauche ich?

Go kennt kein offizielles LTS-Konzept. Stattdessen gilt eine schlanke Regel:

• Es gibt immer eine aktuelle stabile Version (zum Zeitpunkt dieses Artikels: Go 1.26.2).
• Jede 1.X-Hauptversion erhält Sicherheits- und Critical-Bugfixes, bis die übernächste Version erschienen ist — in der Praxis also etwa ein Jahr Support pro Release.
• Neue Major-Releases erscheinen ungefähr alle sechs Monate (typischerweise Februar und August).

Empfehlung für Einsteiger: Installiere die aktuelle stabile Version. Go ist dank seines Compatibility Promise so stabil, dass du dir um Breaking Changes selten Gedanken machen musst. Wer eine bestimmte Version pinnen muss (Build-Reproduzierbarkeit, Library-Anforderungen), nutzt die go-Direktive in go.mod plus die offizielle toolchain-Direktive, die seit Go 1.21 existiert — dazu mehr im Artikel zu go.mod.

Installation auf macOS

Auf dem Mac gibt es zwei vernünftige Wege: den offiziellen .pkg-Installer von go.dev/dl oder Homebrew.

Offizieller Installer (empfohlen für Anfänger):

1. Lade go1.X.Y.darwin-arm64.pkg (Apple Silicon) bzw. darwin-amd64.pkg (Intel) herunter.
2. Doppelklick, dem Assistenten folgen.
3. Installation landet unter /usr/local/go, das bin-Verzeichnis wird automatisch dem PATH hinzugefügt (über /etc/paths.d/go).
4. Terminal neu öffnen.

Homebrew (komfortabler bei häufigen Updates):

brew install go
# später aktualisieren:
brew upgrade go

Homebrew installiert Go nach /opt/homebrew/bin/go (Apple Silicon) bzw. /usr/local/bin/go (Intel). Der Vorteil: ein einziges Tool für alle Updates. Der Nachteil: Homebrew hängt manchmal ein paar Tage hinter dem offiziellen Release.

Wichtig: Nutze entweder den .pkg-Installer oder Homebrew, nicht beides. Sonst hast du zwei go-Binaries im PATH und es ist unklar, welches gewinnt.

Installation auf Linux

Auf Linux ist der offizielle Tarball der Goldstandard. Distributions-Pakete (apt, dnf) hängen oft mehrere Minor-Versionen hinterher.

# Alte Installation entfernen, neue auspacken
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.26.2.linux-amd64.tar.gz

# PATH ergänzen (Bash/Zsh)
echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.profile
source $HOME/.profile

Wichtig: Nicht in ein bestehendes /usr/local/go extrahieren — die offizielle Doku warnt explizit davor, weil sich dann Dateien aus alter und neuer Version vermischen. Erst löschen, dann auspacken.

Paketmanager:

• apt install golang-go (Debian/Ubuntu) — schnell, aber oft veraltet.
• dnf install golang (Fedora/RHEL) — etwas aktueller, immer noch nicht state-of-the-art.
• snap install go --classic — relativ aktuell, dafür Snap-Eigenheiten (Confinement, Mount-Pfade).

Für ernsthafte Entwicklung: offiziellen Tarball nehmen oder den golang.org/dl/...-Mechanismus aus Sektion 06 nutzen.

Installation auf Windows

Auf Windows ist der MSI-Installer der einfachste Weg.

1. go1.X.Y.windows-amd64.msi von go.dev/dl herunterladen.
2. Doppelklick, Assistent durchklicken.
3. Default-Pfad: C:\Program Files\Go. Der Installer ergänzt PATH und GOPATH automatisch.
4. Cmd oder PowerShell neu öffnen, damit die Variablen geladen werden.

Alternative Paketmanager:

# Scoop
scoop install go

# Chocolatey
choco install golang

Beide sind solide, aktualisieren Go aber leicht zeitversetzt zum offiziellen Release. Wenn du auf Windows mit WSL2 arbeitest, behandle die WSL-Distribution wie ein normales Linux (Sektion 03) — Go im WSL ist meist die bessere Entwickler-Erfahrung als nativ.

Verifikation

Egal welcher Pfad: nach der Installation prüfst du drei Dinge.

go version
go env GOROOT
go env GOPATH

go version go1.26.2 darwin/arm64
/usr/local/go
/Users/dein-name/go

• go version muss eine Versionszeile drucken. Kommt command not found, fehlt /usr/local/go/bin (oder das Homebrew-bin) im PATH.
• GOROOT zeigt, wo der Compiler selbst liegt — du musst diese Variable nicht setzen, Go ermittelt sie aus dem Pfad des go-Binaries.
• GOPATH ist der Workspace für go install-Tools und Modul-Cache. Default: ~/go (Linux/macOS) bzw. %USERPROFILE%\go (Windows).

Optional: go env ohne Argument zeigt alle Go-Umgebungsvariablen auf einmal — hilfreich beim Debuggen.

Mehrere Go-Versionen parallel

Für CI-Tests, Library-Entwicklung oder Migrationen brauchst du oft mehrere Go-Versionen gleichzeitig. Go bietet dafür einen offiziell unterstützten Mechanismus.

# Spezifische Version installieren
go install golang.org/dl/go1.22.10@latest
go1.22.10 download

# Verwenden
go1.22.10 version
go1.22.10 build ./...
go1.22.10 env GOROOT

Jeder dieser goX.Y.Z-Befehle ist ein Wrapper um eine separate Go-Installation unter ~/sdk/goX.Y.Z. Vorteil: keine externen Tools, alles offiziell. Nachteil: pro Version ein eigenes Binary im PATH.

Externe Versionsmanager:

• gvm (github.com/moovweb/gvm) — Bash-Skript, kennt jeder Go-Veteran.
• asdf (asdf-vm.com) mit Plugin asdf-golang — empfehlenswert, wenn du sowieso Node, Python und Ruby parallel managst.

Für die meisten Fälle reicht der eingebaute golang.org/dl/...-Weg.

PATH und Umgebungsvariablen

Die wichtigsten Variablen im Überblick:

Pflicht-PATH-Eintrag: Damit von dir installierte Go-Tools (gopls, staticcheck, golangci-lint, eigene CLIs) aufrufbar sind, muss $(go env GOPATH)/bin im PATH stehen.

export PATH=$PATH:$(go env GOPATH)/bin

GO111MODULE ist ein Relikt aus der Übergangszeit zwischen GOPATH-Mode und Modulen. Seit Go 1.16 ist on der Default; setze die Variable nur, wenn du genau weißt, warum.

Editor-Setup

Go hat mit gopls einen offiziellen Language Server. Er liefert Autocomplete, Goto-Definition, Refactoring, Find-References und Diagnostics — und ist die Grundlage für alle gängigen Editor-Integrationen.

go install golang.org/x/tools/gopls@latest

VS Code:

1. Extension „Go" (von Google) installieren.
2. Beim ersten Öffnen einer .go-Datei fragt VS Code, ob es gopls, dlv, staticcheck etc. nachinstallieren soll — bestätigen.
3. Format-on-save mit gofmt ist Default.

GoLand:

JetBrains' kommerzielle IDE bringt alles fertig mit — Debugger, Profiler, Refactorings. Kostenpflichtig, aber für ernsthafte Backend-Arbeit oft die produktivste Option.

Neovim:

Mit nvim-lspconfig und gopls als LSP-Backend, dazu null-ls/conform.nvim für gofmt und goimports. Wer nicht alles selbst zusammenstecken will, nimmt eine fertige Distribution wie LazyVim oder AstroNvim.

Egal welcher Editor: gopls ist der gemeinsame Nenner. Wenn der Language Server läuft, läuft auch die Tooling-Integration.

Erstes „Hello World" als Smoke-Test

Zum Abschluss ein Mini-Test, ob alles funktioniert. Ausführlich behandeln wir das im nächsten Artikel — hier nur als Verifikation.

mkdir hello && cd hello
go mod init example.com/hello

package main

import "fmt"

func main() {
    fmt.Println("Hallo, Welt!")
}

Hallo, Welt!

go run .

Hallo, Welt!

Wenn diese drei Befehle ohne Fehler durchlaufen, ist deine Installation komplett. Wenn nicht — ein Blick in die nächste Sektion.

Weiterführende Ressourcen

Externe Quellen

• Go – Offizielle Installations-Doku
• Managing Go installations
• Go Downloads
• Go Release History
• gopls – Go Language Server

Verwandte Artikel

• Was ist Go?
• Erstes Programm
• Projektstruktur und go.mod
• Pakete und Imports
• Tooling & Best Practices (Stub – Section-Übersicht)