Sign in Get started

Go Tutorial · Go Basics · Lesson 9 of 30

Go History & Versions

Why three Google engineers designed Go, the Go 1 compatibility promise, every important release from Go 1.0 to 1.27 on one timeline (including generics), and which version to use today.

How Go started

In September 2007, three engineers at Google, Robert Griesemer, Rob Pike and Ken Thompson (co-creator of Unix and the B language), started sketching a new language on a whiteboard while waiting for a large C++ program to compile. Their frustrations were concrete: slow builds, complicated dependency management, and languages that made it hard to use multicore processors and write networked servers.

Their answer was Go: a small, statically typed, compiled language with fast builds, garbage collection, a simple syntax that is quick to learn, and built-in concurrency through goroutines and channels. Go was released as an open-source project on 10 November 2009, and Go 1.0 followed on 28 March 2012. Its gopher mascot was drawn by Renée French.

Go 1.0 came with the Go 1 compatibility promise: programs written for Go 1 keep compiling and running with every later Go 1.x release. That is why Go is still on version 1.x after more than a decade, and why the language has grown slowly and carefully. Go now powers much of the cloud: Docker, Kubernetes, Terraform and Prometheus are all written in Go.

Timeline of important releases

Go ships two releases a year, in February and August. Each release is supported until two newer releases exist, so roughly one year.

  1. Go 1.27Current
    • Generic methods: methods can declare their own type parameters
    • encoding/json/v2 arrives and now backs encoding/json; post-quantum signatures in crypto/mldsa
  2. Go 1.26Supported
    • new(expr) creates a pointer to a value: new(yearsSince(born))
    • The Green Tea garbage collector on by default (10–40% less GC overhead); a rewritten go fix with "modernizers"
  3. Go 1.25End of life · Aug 2026
    • Container-aware GOMAXPROCS, testing/synctest, sync.WaitGroup.Go; experimental Green Tea GC and JSON v2
  4. Go 1.24End of life · Feb 2026
    • Generic type aliases, faster maps based on Swiss tables, os.Root for safe file access, testing.B.Loop
  5. Go 1.23End of life · Aug 2025
    • Range over functions (iterators) and the iter package
  6. Go 1.22End of life · Feb 2025
    • Each loop iteration gets its own variable (fixing a classic bug), for i := range 10, method and wildcard routing in net/http
  7. Go 1.21End of life · Aug 2024
    • Built-ins min, max, clear; the slices, maps and log/slog packages; automatic toolchain downloads
  8. Go 1.18End of life · Feb 2023
    • Generics (type parameters), built-in fuzz testing, workspaces
  9. Go 1.16Historic
    • //go:embed to bundle files into the binary; modules on by default
  10. Go 1.13Historic
    • Error wrapping with %w, errors.Is and errors.As
  11. Go 1.11Historic
    • Go modules (go.mod) for dependency management, and a WebAssembly port
  12. Go 1.5Historic
    • The compiler and runtime rewritten in Go itself; a low-latency concurrent garbage collector
  13. Go 1.0Historic
    • The first stable release and the Go 1 compatibility promise
  14. Go Open sourceHistoric
    • Go is announced and released as an open-source project

How Go modernized

  • Modules (1.11–1.16) replaced the old GOPATH workspace with versioned dependencies in go.mod and checksums in go.sum.
  • Generics (1.18) were the biggest language change since 1.0, added after years of design work so they would fit Go's simplicity. Later releases extended them with generic type aliases (1.24) and generic methods (1.27).
  • A richer standard library, with slices, maps, structured logging with log/slog (1.21), iterators (1.23) and JSON v2 (1.27).
  • Faster programs without code changes, from the concurrent GC (1.5) to profile-guided optimization (1.21), Swiss-table maps (1.24) and the Green Tea GC (1.26).
  • Forward compatibility (1.21). The go line in go.mod can now download and use the right toolchain automatically.

Go before and after generics

Task Before Go 1.18 Go 1.18 and later
A function for many types One copy per type, or interface{} plus type assertions func Max[T cmp.Ordered](a, b T) T
Common slice helpers Write your own loops slices.Contains, slices.Sort, slices.Index
Typed containers interface{} and casts type Stack[T any] struct { items []T }
Compile-time safety Mistakes found at run time (bad casts) Caught by the compiler

Which version should you use?

  • Always use one of the two supported releases (1.27 or 1.26 today). Thanks to the compatibility promise, upgrading is usually just changing the go line in go.mod and rebuilding.
  • This tutorial: examples are compiled and run with the Go toolchain when we build the lessons, and their real output is shown under each example. Go examples can't run in your browser.

Official resources

Last reviewed 21 October 2026. Release and support dates come from the official release pages linked above.