Installatie en eerste Go programma: start in 15 minuten

Go leren begint bij één ding: een werkende installatie en een programma dat draait. Deze handleiding voor de installatie en eerste Go programma leidt je in zes duidelijke stappen van lege machine naar een werkend "Hello, World!" en een klein vervolgprogramma dat je direct uitbreidt.

Je werkt met de officiële Go-toolchain, leert de basisstructuur van een Go-project en zet meteen Go modules op. Geen omwegen, geen verouderde GOPATH-configuratie, gewoon de manier waarop moderne Go-projecten in 2026 worden opgezet.

Als je nog twijfelt of Go de juiste keuze is voor jouw project, lees dan eerst waarom Go populair is voor backends in 2026. Voor de rest: laptop open, terminal klaar, en we beginnen.

Stap 1: Kies de juiste Go versie

Ga naar de officiële Go download pagina en kies de laatste stabiele release. In 2026 is dat Go 1.24 of hoger. Go volgt een release-cyclus van twee versies per jaar, en het Go-team ondersteunt elke versie ongeveer twaalf maanden.

Voor productiewerk installeer je altijd een stabiele release, nooit een release candidate. De downloadpagina detecteert automatisch jouw besturingssysteem en architectuur.

Let op het verschil tussen amd64 (Intel/AMD 64-bit) en arm64 (Apple Silicon, moderne ARM-chips). Kies de juiste variant, anders crasht de installatie of draait Go traag.

Stap 2: Installeer Go op jouw systeem

De installatie verschilt per besturingssysteem. Volg de stappen die bij jouw machine horen.

Windows

1. Download het .msi-bestand van go.dev.
2. Dubbelklik het bestand en doorloop de installer.
3. De installer voegt Go automatisch toe aan je PATH.
4. Open een nieuwe PowerShell-sessie en controleer de installatie.

macOS

Je hebt twee opties. De makkelijkste is het .pkg-bestand van go.dev dat je via dubbelklik installeert. Ervaren developers gebruiken vaak Homebrew:

brew install go

Homebrew is handig omdat je Go later makkelijk bijwerkt met brew upgrade go.

Linux

Download het tarball en pak het uit in /usr/local:

rm -rf /usr/local/go
tar -C /usr/local -xzf go1.24.0.linux-amd64.tar.gz

Voeg daarna deze regel toe aan je ~/.bashrc of ~/.zshrc:

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

Herstart je terminal of draai source ~/.zshrc om de wijziging actief te maken.

Stap 3: Controleer de installatie

Open een nieuwe terminal en draai:

go version

Je ziet iets als go version go1.24.0 darwin/arm64. Zie je deze output niet, dan is Go niet correct aan je PATH toegevoegd. Sluit de terminal volledig, open een nieuwe sessie en probeer het opnieuw.

Draai daarna go env om de volledige configuratie te zien. Let vooral op GOROOT (waar Go zelf staat) en GOPATH (waar Go dependencies en binaries cachet). In moderne Go-projecten hoef je deze waarden bijna nooit handmatig aan te passen.

Stap 4: Kies een editor

Go werkt met elke teksteditor, maar een goede setup scheelt uren frustratie.

• Visual Studio Code met de officiële Go-extensie is de populairste keuze. Installeer de extensie en VS Code vraagt automatisch om gopls, delve en andere tools te installeren. Accepteer allemaal.
• GoLand van JetBrains is een betaalde IDE met uitstekende Go-ondersteuning, refactoring en een ingebouwde debugger. De moeite waard als je professioneel met Go werkt.
• Neovim met de gopls LSP is populair onder terminal-liefhebbers.

Voor deze handleiding maakt het niet uit welke editor je kiest. Je hebt alleen een terminal nodig om de commando's uit te voeren.

Stap 5: Schrijf je eerste Go programma

Maak een nieuwe map voor je project. Geef de map geen spaties of hoofdletters:

mkdir hello-go
cd hello-go

Initialiseer vervolgens een Go module. Dit vertelt Go dat deze map een project is en waar dependencies bijgehouden worden:

go mod init example.com/hello-go

De naam example.com/hello-go is de module-pad. Voor lokaal oefenen maakt het niet uit, maar bij een echt project gebruik je vaak github.com/jouw-username/projectnaam.

Maak nu een bestand main.go met de volgende inhoud:

package main

import "fmt"

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

Draai het programma:

go run main.go

Je ziet Hello, World! in je terminal. Gefeliciteerd, je hebt net je eerste Go programma gedraaid.

Wat gebeurt er precies?

• package main vertelt Go dat dit een uitvoerbaar programma is, geen library.
• import "fmt" importeert het fmt-pakket uit de standard library voor geformatteerde I/O.
• func main() is het startpunt van elk uitvoerbaar Go-programma.
• fmt.Println schrijft een regel naar stdout.

Deze vier regels zijn de basis van bijna elk Go-programma dat je gaat schrijven.

Stap 6: Bouw een executable

go run is handig tijdens ontwikkeling, maar voor productie wil je een losse binary. Draai:

go build

Go maakt nu een executable in dezelfde map (hello-go of hello-go.exe op Windows). Draai het bestand direct:

./hello-go

Deze binary is volledig self-contained, geen Go-runtime, geen dependencies. Je kunt hem kopiëren naar een server en hij draait. Dit is één van de redenen dat Go zo populair is voor deployment, zoals we bespraken in ons artikel over waarom Go populair is voor backends.

Wil je cross-compileren naar Linux vanaf je Mac? Eén regel:

GOOS=linux GOARCH=amd64 go build -o hello-go-linux

Geen toolchain-trucs, geen Docker. Go regelt het.

Breid je programma uit

Een echt "Hello, World!" is saai. Pas main.go aan naar iets interactiefs:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Hoe heet je? ")
    naam, _ := reader.ReadString('\n')
    naam = strings.TrimSpace(naam)
    fmt.Printf("Hallo %s, welkom bij Go!\n", naam)
}

Draai opnieuw met go run main.go. Het programma vraagt nu om je naam en groet je persoonlijk. Je gebruikt drie extra standard library pakketten, bufio, os en strings, zonder ook maar één externe dependency.

Dit is typisch Go: de standard library is zo compleet dat je voor kleine tools zelden iets extern nodig hebt.

Veelgemaakte fouten bij je eerste Go programma

• go: command not found, Go staat niet in je PATH. Open een nieuwe terminal of controleer je shell-configuratie.
• package main is not in std, je hebt go mod init overgeslagen. Draai het alsnog in de projectmap.
• Niet-gebruikte imports, Go compileert niet als je een pakket importeert zonder het te gebruiken. Dit is geen bug, maar een bewuste ontwerpkeuze voor schone code.
• Niet-gebruikte variabelen, zelfde verhaal. Een gedeclareerde variabele moet gebruikt worden, anders krijg je een compile error.

Deze strictheid voelt in het begin streng, maar zorgt voor leesbare codebases waar je later dankbaar voor bent.

Veelgestelde vragen

Welke Go versie moet ik installeren in 2026?

Installeer altijd de laatste stabiele release van go.dev. In 2026 is dat Go 1.24 of nieuwer. Oudere versies missen belangrijke performance- en security-updates en worden na een jaar niet meer ondersteund.

Heb ik een IDE nodig om Go te schrijven?

Nee, Go werkt met elke teksteditor. Voor de beste ervaring raden we Visual Studio Code met de officiële Go-extensie aan, of GoLand van JetBrains. Beide bieden autocomplete, debugging en linting out of the box.

Wat is het verschil tussen go run en go build?

Met go run compileer en draai je een programma in één stap zonder dat er een bestand achterblijft. Met go build maak je een losse executable die je later opnieuw kunt draaien of kunt distribueren zonder dat Go geïnstalleerd hoeft te zijn.

Moet ik GOPATH nog handmatig instellen?

Nee, sinds Go 1.16 werken projecten standaard met Go modules en is GOPATH niet meer nodig voor nieuwe projecten. Je initialiseert een project simpelweg met go mod init en Go regelt de rest.

Kan ik Go leren zonder ervaring met andere programmeertalen?

Ja, Go is ontworpen om simpel en leesbaar te zijn. De syntax is minimaal en de standard library is uitgebreid. Beginners pakken de basis meestal binnen enkele dagen op, zeker met een gestructureerde handleiding.

Volgende stappen

Je hebt Go geïnstalleerd, een module opgezet en twee programma's gedraaid. De volgende logische stappen:

• Leer de basissyntax: variabelen, types, functies en control flow.
• Verdiep je in Go modules en dependency management.
• Bouw een eerste HTTP-server met het net/http pakket.
• Ontdek goroutines, de killer feature die Go uniek maakt, zoals behandeld in ons artikel over waarom Go populair is voor backends.

De officiële Go Tour is een uitstekende interactieve vervolgstap die je in een uur of twee door de kernconcepten van de taal leidt. Daarna ben je klaar om echte projecten te bouwen.

Veel succes met Go, en welkom bij een taal die je productiviteit snel zal verrassen.