Program Structure & Packages

Introduction

Go organizes code into packages rather than loose files. Understanding how packages, imports, and visibility work is essential before writing anything beyond a single-file toy program — it's the foundation for how every real Go project, including the standard library itself, is structured.

This lesson covers the anatomy of a Go file, what packages are and how imports pull in code from elsewhere, and Go's uniquely simple rule for controlling what is visible outside a package.

Anatomy of a Go File

Every Go source file follows the same basic structure, in this exact order: a package declaration, followed by any import statements, followed by the actual code (functions, variables, types, etc.).

package greetings // 1. Package declaration

import "fmt" // 2. Imports

// 3. Code — functions, types, variables, constants
func Hello(name string) string {
	return fmt.Sprintf("Hello, %s!", name)
}

What Is a Package?

A package is Go's unit of code organization — essentially a folder of .go files that all declare the same package name and work together as one unit. Every Go program is made up of at least one package, and larger programs are typically split into many packages, each with a focused responsibility (for example, a `database` package, an `httpserver` package, and so on).

The import Statement

The `import` statement pulls in code from another package so you can use it. You can import a single package, or a grouped block of several packages using parentheses — the grouped form is idiomatic Go style for more than one import.

package main

import (
	"fmt"
	"strings"
)

func main() {
	message := strings.ToUpper("go is fun")
	fmt.Println(message)
}

To use anything from an imported package, you prefix it with the package name, as in `fmt.Println` or `strings.ToUpper`. Go will refuse to compile if you import a package but never actually use it — this keeps the codebase free of unused clutter.

Exported vs Unexported Identifiers

Go has a strikingly simple rule for controlling visibility, with no `public`/`private` keywords at all: if a function, variable, type, or constant name starts with an uppercase letter, it is exported (visible to other packages that import this one). If it starts with a lowercase letter, it is unexported (only usable within its own package).

package greetings

import "fmt"

// Hello is exported — starts with a capital letter.
// Other packages can call greetings.Hello(...)
func Hello(name string) string {
	return formatGreeting(name)
}

// formatGreeting is unexported — starts with a lowercase letter.
// Only code inside package "greetings" can call it.
func formatGreeting(name string) string {
	return fmt.Sprintf("Hello, %s!", name)
}

Building a Multi-File Package

Files in the same package can freely use each other's unexported identifiers without importing anything, since they're part of the same package. For example, a `main.go` and a `helpers.go` file both declaring `package main` in the same folder can call each other's functions directly.

package main

import "fmt"

func main() {
	fmt.Println(shout("go"))
}

package main

import "strings"

// shout is unexported, but main.go can still call it directly
// because both files belong to the same package.
func shout(word string) string {
	return strings.ToUpper(word) + "!"
}

Standard Library Packages

Go ships with a rich standard library covering common needs, so you frequently won't need third-party packages for everyday tasks.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You now understand how Go organizes code into packages, how imports work, and the capitalization rule that governs visibility across the entire language. Next, you'll dig into how to declare variables and constants in Go.