Setup, your first program, and the toolchain

Install Go, run one file, and meet the four commands you will use every day.

Topic 1 of 98 · 5 min to read · 45 min to build

After this topic you can

Write and run a package main program with go run ..
Explain what the zero value of an int, a string and a bool is.
Predict what go build, go fmt and go vet each do before you run them.

Go is a compiled language. You write a .go file, the compiler turns it into a single machine-code binary, and you run that. There is no interpreter to install on the server and no virtual machine. That one fact explains most of what people like about Go: you build one file and copy it anywhere.

First, install it. Pick your system below. Every option installs the same thing: the compiler, the standard library and the go command.

terminal

1go version
2# go version go1.25.1 linux/amd64

Install Go

macOS

1# with Homebrew (easiest)
2brew install go
3
4# or download the .pkg installer from https://go.dev/dl/
5# and double-click it

Windows

1# with winget
2winget install GoLang.Go
3
4# or download the .msi installer from https://go.dev/dl/
5# then close and reopen your terminal so PATH updates

Linux

1# the official way — distribution packages are often far behind
2curl -LO https://go.dev/dl/go1.25.1.linux-amd64.tar.gz
3sudo rm -rf /usr/local/go
4sudo tar -C /usr/local -xzf go1.25.1.linux-amd64.tar.gz
5
6# then add Go to your PATH, and reload your shell
7echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
8source ~/.profile

Check https://go.dev/dl/ for the current version number before you copy that URL.

check it worked

1go version
2# go version go1.25.1 linux/amd64
3
4go env GOPATH
5# /home/you/go   — where downloaded packages live. You rarely need to touch it.

Note: Nothing else to install. No package manager to set up, no virtual environment, no build tool. The go command does all of it.

You can also run Go without installing anything

Every code block on this site with a ▶ Run button executes on the official Go Playground, so you can work through the language topics in a browser before you install anything. Press Run, change the code, press Run again.

You will need a real installation from the practice projects onwards, because those use files, folders and a database. The playground has none of them.

A module is a project

Every Go project is a module. A module is a folder with a go.mod file at the top. That file records the module name and which Go version it needs. You make one once, at the start.

terminal

1mkdir -p ~/go-learn/d01
2cd ~/go-learn/d01
3go mod init d01

The name `d01` is the import path. For real projects use something like `github.com/you/project`.

The first program

Every Go file starts with package. A program you can run lives in package main and has a func main(). That function is where execution starts, and when it returns the program exits.

main.go

1package main
2
3import "fmt"
4
5func main() {
6	fmt.Println("hello")
7
8	name := "sahdev"    // short declaration, the type is inferred
9	var age int = 25    // the long form, type written out
10	var city string     // no value given, so it gets the zero value: ""
11	const pi = 3.14     // fixed at compile time, cannot change
12
13	fmt.Println(name, age, city, pi)
14}

Three ways to declare, one you will mostly use

name := "sahdev" — inside a function, the common case. Go works out the type.
var age int = 25 — when you want the type written down, or you are outside a function.
var city string — declare now, assign later. It holds the zero value until you do.
const pi = 3.14 — a value fixed at compile time. It cannot be changed and has no address.

Zero values: Go has no "undefined"

This is the first idea that makes Go different from JavaScript or Python. A variable you declare but do not set is not empty, null, or undefined. It holds a well-defined zero value for its type.

Type	Zero value
`int`, `float64`	`0`
`string`	`""` (empty, not nil)
`bool`	`false`

Because of this you never get a "cannot read property of undefined" style crash from an unset variable. The other types you will meet later also have zero values, and each lesson says what they are.

The four commands

terminal

1go run .          # compile and run, leave no binary behind
2go build -o app . # produce ./app, ready to copy to a server
3go fmt ./...      # format the code. Not a preference, the standard.
4go vet ./...      # find real mistakes the compiler allows

Note: Go has one formatting style, and go fmt applies it. Tabs, brace placement and spacing are decided for you, so a Go team has nothing to argue about there. Most editors run it on save; if yours does not, run it before every commit.

Try it yourself

press Run — this executes on the Go Playground

1package main
2
3import "fmt"
4
5func main() {
6	name := "sahdev"    // short declaration, the type is inferred
7	var age int = 25    // the long form, type written out
8	var city string     // never assigned, so it holds the zero value
9	const pi = 3.14     // fixed at compile time
10
11	fmt.Println(name, age, city, pi)
12	fmt.Printf("city is %q and has %d characters\n", city, len(city))
13}

Press Run. Then change a value, or add a line, and run it again.

Build this: your first win

A tiny program that does a real job: split a bill. Put it in main.go in your d01 folder and run go run .. Then change the numbers and run it again.

main.go — split a bill

1package main
2
3import "fmt"
4
5func main() {
6	total := 84.50
7	people := 4
8
9	share := total / float64(people)
10	fmt.Println("Total:", total)
11	fmt.Println("People:", people)
12	fmt.Println("Each pays:", share)
13}

`float64(people)` turns the whole number into a decimal so the two can be divided. **Type conversion** explains why Go makes you write that.

The short version

A module is a folder with a go.mod. A runnable program is package main with func main().
Every variable has a zero value. There is no undefined, and no unset variable to guard against.
:= inside functions, var when you want the type written down or you are at package level.
go run, go build, go fmt, go vet. That is the whole daily toolchain.

Remember: Go compiles to one self-contained binary with nothing to install beside it, and every variable starts at a defined zero value. Those two facts shape most of the language.

Build this before moving on

Print your name, age, and whether you are a student, using all three declaration styles. Then declare a variable of each basic type without assigning it and print them, to see the zero values yourself.

Then try these in your own editor

1Make a second file in the same folder, put a function in it, and call that function from main. Notice you did not need an import.
2Delete the fmt import while still calling fmt.Println, and read the error. Then add an unused variable and read that one too.
3Build with go build -o app . and run ./app. Copy the binary to another folder and run it there — nothing else needed.

Official documentation

Check yourselfTake the Getting started test