A curated guide to everything on go.dev, organized for learners and practitioners. Whether you're writing your first Hello, World! or digging into compiler internals, there's something here for you.

Generated from golang/website at commit 8cadfa8.

• Start Here
• Tutorials
• Language Specification & Reference
• Modules & Dependencies
• Blog: Language Design & Features
• Blog: Generics
• Blog: Concurrency
• Blog: Performance & Internals
• Blog: Error Handling
• Blog: Testing
• Blog: Security
• Blog: Tooling
• Blog: Standard Library Deep Dives
• Blog: WebAssembly
• Blog: Modules & Versioning
• Blog: Community & Ecosystem
• Blog: Release Announcements
• Blog: History & Milestones
• Case Studies
• Documentation
• A Tour of Go
• Talks & Presentations

If you're new to Go, this is the path:

• Learn Go - Official learning hub with books, courses, and guided tutorials
• A Tour of Go - Interactive introduction you can do in your browser
• How to Write Go Code - Setting up your workspace and writing your first program
• Effective Go - The style and idioms that make Go code feel like Go
• Frequently Asked Questions - Honest answers to "but why does Go...?"

Hands-on, step-by-step guides. Best done in order if you're starting out.

• Getting started - Install Go and write your first program
• Create a module - Build something reusable
• Getting started with multi-module workspaces - Work across multiple modules locally
• Accessing a relational database - Connect to SQL, query rows, handle transactions
• Developing a RESTful API with Go and Gin - Build a web service
• Getting started with generics - Write type-safe generic functions
• Getting started with fuzzing - Find bugs automatically with fuzz testing
• Find and fix vulnerable dependencies with govulncheck - Security scanning for your project
• Vulnerability scanning in your IDE - Real-time vulnerability detection

The definitive source of truth for the language.

• The Go Programming Language Specification - Every rule, every edge case, all of it
• Go Modules Reference - Complete reference for the module system (go.mod, go.sum, commands)
• Go Doc Comments - How to write documentation comments that tools understand
• Go Memory Model - Guarantees about when goroutines can see each other's writes
• Debugging with GDB - Lower-level debugging when Delve isn't enough

• Managing dependencies - Adding, upgrading, and removing dependencies
• Developing and publishing modules - Creating modules others can use
• Module release and versioning workflow - When to tag, how to version
• Managing module source - Repository layout and organization
• Module version numbering - What v1.2.3 actually means
• Major version updates - The v2+ story and import path changes
• Publishing a module - Making your module available to the world
• Module layout - Recommended project structure
• Module graph pruning - How Go keeps your dependency graph lean

Posts that explain why Go works the way it does.

• 2010-07-07 Go's Declaration Syntax - Why x int instead of int x
• 2010-07-13 Share Memory By Communicating - The philosophy behind channels
• 2010-08-04 Defer, Panic, and Recover - Go's approach to cleanup and error recovery
• 2011-01-05 Go Slices: usage and internals - A gentler intro to slices
• 2011-09-06 The Laws of Reflection - Understanding reflect from first principles
• 2012-08-16 Organizing Go code - Project structure advice
• 2013-02-06 Go maps in action - Everything about maps
• 2013-09-26 Arrays, slices (and strings): The mechanics of 'append' - How slices really work under the hood
• 2013-10-23 Strings, bytes, runes and characters in Go - The full story of text in Go
• 2013-11-26 Text normalization in Go - Unicode normalization deep dive
• 2014-08-25 Constants - Untyped constants and why they matter more than you think
• 2014-12-22 Generating code - go generate and code generation patterns
• 2015-01-12 Errors are values - Rob Pike on why if err != nil is a feature
• 2015-02-04 Package names - Naming conventions that make APIs pleasant
• 2015-05-07 Testable Examples in Go - Examples that are also tests
• 2024-02-22 Robust generic functions on slices - Writing slice utilities that don't surprise you
• 2025-03-26 Goodbye core types - Simplifying the type system in Go 1.25
• 2026-03-24 Type Construction and Cycle Detection - How the compiler handles recursive types

The multi-year journey from "maybe someday" to func Map[T, U any].

• 2019-07-31 Why Generics? - The problem statement, by Ian Lance Taylor
• 2020-06-16 The Next Step for Generics - Updated design with type parameters
• 2021-01-12 A Proposal for Adding Generics to Go - The accepted proposal
• 2021-12-14 Go 1.18 Beta 1 is available, with generics - It's happening
• 2022-03-22 An Introduction To Generics - Practical guide for the rest of us
• 2022-04-12 When To Use Generics - And more importantly, when not to
• 2023-02-17 All your comparable types - The nuances of comparable
• 2023-09-26 Deconstructing Type Parameters - Advanced patterns
• 2023-10-09 Everything You Always Wanted to Know About Type Inference - How the compiler figures out your types
• 2025-07-07 Generic interfaces - Combining generics with interfaces

Go's bread and butter.

• 2010-07-13 Share Memory By Communicating - Don't communicate by sharing memory
• 2010-09-23 Go Concurrency Patterns: Timing out, moving on - Timeouts with channels
• 2013-05-23 Advanced Go Concurrency Patterns - Talk by Sameer Ajmani
• 2013-06-26 Introducing the Go Race Detector - Finding data races automatically
• 2014-03-13 Go Concurrency Patterns: Pipelines and cancellation - Building data pipelines
• 2014-07-29 Go Concurrency Patterns: Context - The context package explained
• 2021-02-24 Contexts and structs - Where should context go?
• 2022-09-26 Go runtime: 4 years later - How the scheduler evolved

For when you need to understand what's happening underneath.

• 2011-06-24 Profiling Go Programs - CPU and memory profiling with pprof
• 2015-08-31 Go GC: Prioritizing low latency and simplicity - The Go 1.5 GC revolution
• 2016-08-18 Smaller Go 1.7 binaries - Binary size optimizations
• 2018-07-12 Getting to Go: The Journey of Go's GC - GC history from Rick Hudson
• 2023-02-08 Profile-guided optimization preview - Feeding runtime data back to the compiler
• 2023-08-28 Perfectly Reproducible, Verified Go Toolchains - Supply chain integrity
• 2023-09-05 Profile-guided optimization in Go 1.21 - PGO goes GA
• 2024-03-14 More powerful Go execution traces - Runtime tracing improvements
• 2025-02-26 Faster Go maps with Swiss Tables - New map internals in Go 1.24
• 2025-08-20 Container-aware GOMAXPROCS - Respecting container CPU limits
• 2025-09-26 Flight Recorder in Go 1.25 - Always-on diagnostics
• 2025-10-29 The Green Tea Garbage Collector - Latest GC improvements
• 2026-02-27 Allocating on the Stack - Escape analysis and stack allocation
• 2026-03-10 //go:fix inline and the source-level inliner - Source-level optimization

• 2011-07-12 Error handling and Go - The basics of Go error handling
• 2015-01-12 Errors are values - A shift in perspective
• 2019-10-17 Working with Errors in Go 1.13 - errors.Is, errors.As, and wrapping
• 2025-06-03 On syntactic support for error handling - The 2025 discussion on ? and alternatives

• 2013-12-02 The cover story - Code coverage in Go
• 2016-10-03 Using Subtests and Sub-benchmarks - Table-driven tests done right
• 2021-06-03 Fuzzing is Beta Ready - Introduction to Go's fuzzer
• 2023-03-08 Code coverage for Go integration tests - Coverage beyond unit tests
• 2023-12-12 Finding unreachable functions with deadcode - Static analysis for dead code
• 2025-02-19 Testing concurrent code with testing/synctest - Deterministic concurrency testing
• 2025-04-02 More predictable benchmarking with testing.B.Loop - Better benchmark patterns
• 2025-08-26 Testing Time (and other asynchronicities) - Dealing with time in tests

• 2021-01-19 Command PATH security in Go - Avoiding command injection
• 2021-09-15 Automatic cipher suite ordering in crypto/tls - TLS best practices
• 2022-03-31 How Go Mitigates Supply Chain Attacks - Security design decisions
• 2022-09-06 Vulnerability Management for Go - The vulnerability ecosystem
• 2023-07-13 Govulncheck v1.0.0 is released! - Dependency vulnerability scanning
• 2024-05-02 Secure Randomness in Go 1.22 - ChaCha8 replaces the old PRNG
• 2025-03-06 From unique to cleanups and weak - New low-level efficiency tools
• 2025-03-12 Traversal-resistant file APIs - Safe file path handling
• 2025-05-19 Go Cryptography Security Audit - Third-party audit results
• 2025-07-15 The FIPS 140-3 Go Cryptographic Module - FIPS compliance in Go

• 2011-03-31 Godoc: documenting Go code - Documentation tooling
• 2013-12-12 Inside the Go Playground - How play.golang.org works
• 2019-03-21 Debugging what you deploy in Go 1.12 - Better debug info in optimized builds
• 2020-06-09 The VS Code Go extension joins the Go project - Official VS Code support
• 2021-02-01 Gopls on by default in VS Code - Language server improvements
• 2022-01-14 Two New Tutorials for 1.18 - Learning generics and fuzzing
• 2023-07-31 Experimenting with project templates - gonew for scaffolding
• 2023-08-22 Structured Logging with slog - The new standard logging library
• 2023-09-08 Scaling gopls for the growing Go ecosystem - Making the language server fast
• 2024-09-03 Go Telemetry - Opt-in usage analytics for Go tools
• 2026-02-17 Using go fix to modernize Go code - Automated code modernization

• 2011-01-25 JSON and Go - Encoding and decoding JSON
• 2011-03-17 C? Go? Cgo! - Calling C code from Go
• 2011-03-24 Gobs of data - Go's binary serialization format
• 2011-09-21 The Go image package - Working with images
• 2011-09-29 The Go image/draw package - Compositing images
• 2017-03-24 HTTP/2 Server Push - Server push in net/http
• 2020-03-02 A new Go API for Protocol Buffers - The protobuf v2 API
• 2024-02-13 Routing Enhancements for Go 1.22 - Pattern matching in the standard mux
• 2024-05-01 Evolving the Standard Library with math/rand/v2 - Modernizing random number generation
• 2024-08-20 Range Over Function Types - Iterator protocol in Go 1.23
• 2024-08-27 New unique package - Value interning for efficiency
• 2024-09-12 Building LLM-powered applications in Go - Go for AI applications
• 2024-12-16 Go Protobuf: The new Opaque API - Next-gen protobuf performance
• 2025-09-09 A new experimental Go API for JSON - The v2 JSON API

• 2023-09-13 WASI support in Go - Running Go in WebAssembly runtimes
• 2025-02-13 Extensible Wasm Applications with Go - Exporting Go functions to Wasm

The evolution of Go's dependency management.

• 2018-03-26 A Proposal for Package Versioning in Go - The original vgo proposal
• 2018-12-19 Go Modules in 2019 - State of the module ecosystem
• 2019-03-19 Using Go Modules - Getting started with modules
• 2019-08-01 Experiment, Simplify, Ship - The design process behind modules
• 2019-08-21 Migrating to Go Modules - Moving from GOPATH
• 2019-08-29 Module Mirror and Checksum Database Launched - proxy.golang.org and sum.golang.org
• 2019-09-26 Publishing Go Modules - Making modules available
• 2019-11-07 Go Modules: v2 and Beyond - Major version handling
• 2020-07-07 Keeping Your Modules Compatible - API evolution guidelines
• 2021-02-18 New module changes in Go 1.16 - Modules on by default
• 2023-08-14 Backward Compatibility, Go 1.21, and Go 2 - The compatibility promise
• 2023-08-14 Forward Compatibility and Toolchain Management - Automatic toolchain downloads

• 2013-07-18 The first Go program - Where it all started
• 2014-03-24 The Go Gopher - The story behind the mascot
• 2014-09-26 Deploying Go servers with Docker - Containerizing Go apps
• 2015-07-08 Go, Open Source, Community - Go's open-source philosophy
• 2017-07-13 Toward Go 2 - Russ Cox on the future of Go
• 2018-01-22 Hello, 中国! - Go documentation in Chinese
• 2018-07-24 Portable Cloud Programming with Go Cloud - Cloud abstraction libraries
• 2018-08-28 Go 2 Draft Designs - Error handling, generics, error values drafts
• 2018-10-09 Compile-time Dependency Injection With Go Cloud's Wire - DI without reflection
• 2018-11-29 Go 2, here we come! - Process for Go 2 proposals
• 2019-06-26 Next steps toward Go 2 - Evaluating proposals
• 2019-11-13 Go.dev: a new hub for Go developers - Launch of go.dev
• 2020-03-25 Go, the Go Community, and the Pandemic - 2020 and the community
• 2020-12-17 Go on ARM and Beyond - Platform support story
• 2021-06-23 The Go Collective on Stack Overflow - Community Q&A

Every major Go release, from the beginning.

Detailed release notes for each version are at go.dev/doc/devel/release.

The anniversary posts are genuinely fun reads.

• 2010-11-10 Go: one year ago today
• 2011-11-10 Go turns two
• 2012-11-10 Go turns three
• 2013-11-10 Four years of Go
• 2014-11-10 Half a decade with Go
• 2015-11-10 Six years of Go
• 2016-11-10 Seven years of Go
• 2017-11-10 Eight years of Go
• 2018-11-10 Nine years of Go
• 2019-11-08 Go Turns 10
• 2020-11-10 Eleven Years of Go
• 2021-11-10 Twelve Years of Go
• 2022-11-10 Thirteen Years of Go
• 2023-11-10 Fourteen Years of Go
• 2024-11-11 Go Turns 15
• 2025-11-14 Go's Sweet 16

What Go developers think, want, and struggle with.

• 2017-03-06 Go 2016 Survey Results
• 2018-02-26 Go 2017 Survey Results
• 2019-03-28 Go 2018 Survey Results
• 2020-04-20 Go Developer Survey 2019 Results
• 2021-03-09 Go Developer Survey 2020 Results
• 2022-04-19 Go Developer Survey 2021 Results
• 2022-09-08 Go Developer Survey 2022 Q2 Results
• 2023-05-11 Go Developer Survey 2023 Q1 Results
• 2023-12-05 Go Developer Survey 2023 H2 Results
• 2024-4-09 Go Developer Survey 2024 H1 Results
• 2024-12-20 Go Developer Survey 2024 H2 Results
• 2026-01-21 Results from the 2025 Go Developer Survey

Real companies, real production systems, real problems solved with Go.

• Google: Chrome - Go in Chrome infrastructure
• Google: Core Data Solutions - Data processing at scale
• Google: Firebase - Backend services for Firebase
• Google: Site Reliability - SRE tooling in Go
• Cloudflare - Edge computing and DNS services
• CockroachDB - Distributed SQL database
• Dropbox - Open sourcing Go libraries

• American Express - Payments and rewards
• PayPal - Modernizing and scaling payment systems
• Capital One - Banking infrastructure
• MercadoLibre - Latin America's largest e-commerce
• Curve - Fintech card platform

• X (Twitter) - 5 billion sessions a day
• Netflix - Streaming infrastructure
• Twitch - Live streaming platform
• Uber - GPU-powered analytics engine
• Bitly - URL shortening at scale
• Monzo - Digital banking

• Microsoft - Azure and internal services
• Salesforce - CRM platform services
• Allegro - E-commerce marketplace
• Trivago - Hotel search platform
• SIXT - Car rental technology
• Stream - Activity feeds and chat API

• Riot Games - Game infrastructure
• Wildlife Studios - Mobile game backends

• ByteDance - TikTok parent company
• Facebook / Meta - Internal Go usage
• Armut - Local services marketplace

• Why Go - General overview
• Go for Cloud & Network Services - Cloud-native development
• Go for Web Development - Web services and APIs
• Go for Command-line Interfaces - CLI tooling
• Go for DevOps & SRE - Operations and reliability

• Accessing relational databases - Overview and getting started
• Opening a database handle
• Executing SQL statements
• Querying for data
• Using prepared statements
• Executing transactions
• Cancelling in-progress operations
• Managing connections
• Avoiding SQL injection risk

• Security Best Practices
• FIPS 140-3 Compliance
• Go Security Policy
• Go Fuzzing
• Go Vulnerability Management
• Go Vulnerability Database
• Go CNA Policy

• Coverage profiling for integration tests
• Profile-guided optimization
• Go Toolchains
• Go Telemetry
• Gopls settings

The interactive tour at go.dev/tour. You can do it all from your browser, no install needed.

• Hello, World - Your first Go program
• Go local - Installing Go on your machine

• Packages, Imports, Exported names
• Functions, Multiple results, Named return values
• Variables, Short variable declarations
• Basic types, Zero values, Type conversions, Type inference
• Constants, Numeric constants

• For, For is Go's "while", Forever
• If, If with short statement, If and else
• Exercise: Loops and Functions
• Switch, Switch with no condition
• Defer, Stacking defers

• Pointers, Structs, Struct fields, Struct literals
• Arrays, Slices, Slice literals, Slice length and capacity, Making slices, Appending to a slice
• Exercise: Slices
• Maps, Map literals, Mutating maps
• Exercise: Maps
• Function values, Function closures
• Exercise: Fibonacci closure

• Methods, Pointer receivers, Choosing a value or pointer receiver
• Interfaces, Interfaces are implemented implicitly, Interface values, The empty interface
• Type assertions, Type switches
• Stringers, Exercise: Stringers
• Errors, Exercise: Errors
• Readers, Exercise: Readers, Exercise: rot13Reader
• Images, Exercise: Images

• Type parameters
• Generic types

• Goroutines, Channels, Buffered channels
• Range and close, Select, Default selection
• Exercise: Equivalent Binary Trees
• sync.Mutex
• Exercise: Web Crawler

Slide decks and presentations from Go team members at conferences and events. All available at go.dev/talks.

• Go — January 12, 2010
• Go, Networked — January 21, 2010
• Go Tech Talk — March 23, 2010

• Lexical Scanning in Go — Rob Pike on writing a lexer by hand

• Concurrency is not Parallelism — Rob Pike's classic on the distinction
• Go Concurrency Patterns — Foundational patterns with goroutines and channels
• Go at Google — Language design in the service of software engineering
• The Path to Go 1 — How Go reached its first stable release
• Go: a simple programming environment — Simplicity as a feature
• Go: code that grows with grace — Building a chat system live
• Get started with Go — Tutorial walkthrough
• 10 things you (probably) don't know about Go — Fun surprises
• Go for C programmers — Bridging the gap from C
• Go and the Zen of Python — Go through Python's lens
• Go docs — Documentation tooling
• Inside the "present" tool — How these slides are built

• Advanced Go Concurrency Patterns — Beyond the basics: pipelines, cancellation, and more
• Twelve Go Best Practices — Practical idioms from the Go team
• Go, for Distributed Systems — Building distributed services
• Go for Pythonistas — Go from a Python developer's perspective
• Go Language for Ops and Site Reliability Engineering — Go in production operations
• What's new in Go 1.1 — Release highlights
• High Performance Apps with Go on App Engine — Squeezing performance on GAE
• dl.google.com: Powered by Go — Real-world Go at Google scale

• Go for gophers — Deep dive for experienced Go users
• Go for Javaneros — Go from a Java perspective
• Go, from C to Go — Translating the Go compiler from C to Go
• Go: Easy to Read, Hard to Compile — Compiler internals
• Go: 90% Perfect, 100% of the time — GoCon Tokyo keynote
• Hello, Gophers! — Welcome talk
• What's in a name? — Naming conventions in Go
• Organizing Go code — Package layout and project structure
• Inside the Go playground — How the playground works
• When in Go, do as Gophers do — Idiomatic Go code
• Cancellation, Context, and Plumbing — Early context patterns
• A Taste of Go — Quick introduction
• Testing Techniques — How to test Go code effectively
• Gophers With Hammers — Code generation and tooling
• Static analysis tools — vet, lint, and friends
• The Research Problems of Implementing Go — Academic challenges
• More Research Problems of Implementing Go — Part two
• Toward Go 1.3 — Upcoming release preview
• The State of Go — Where the project stands
• The State of the Gopher — Community update
• Go on Android — Mobile development with Go
• Camlistore: Android, ARM, App Engine, anywhere — Brad Fitzpatrick's personal storage system

• Simplicity is Complicated — Rob Pike on why simple is hard
• The Evolution of Go — How Go's design evolved
• How Go was made — Origin story
• Go in Go — The self-hosting compiler
• Go for Java Programmers — Migration guide
• Go for C++ developers — Comparing paradigms
• Go on Mobile — GopherCon mobile talk
• gRPC Go — Introduction to gRPC in Go
• JSON, interfaces, and go generate — Working with JSON effectively
• Go Dynamic Tools — Race detector, profiler, and more
• The Cultural Evolution of gofmt — How formatting shaped Go culture
• Stupid Gopher Tricks — Clever (ab)uses of Go
• Keeping up with the Gophers — Following Go's growth
• The State of Go — February update
• The State of Go — May update

• The Design of the Go Assembler — Rob Pike on Go's assembler
• Program your next server in Go — Server development
• Stacks of Tokens — A look at Go's tokenizer
• The State of Go — Update

• The State of Go — February update
• The State of Go — May update

• Playground v3 — The redesigned Go Playground