History of Go

From a frustrated whiteboard session at Google to the language that powers Kubernetes, Docker, and the cloud-native ecosystem.

Origins
Born from C++ Frustration

Go was conceived on September 21, 2007, when Robert Griesemer, Rob Pike, and Ken Thompson began sketching the design of a new language at Google. The catalyst was a legendary 45-minute C++ build during which they had nothing to do but wait — and complain.

Google's codebase at the time was enormous: millions of lines of C++ and Java. Builds were slow. Dependencies were tangled. Concurrency was error-prone. The existing languages were too complex for the scale of distributed systems Google was building. Pike later recalled: "We were sick of waiting for compilations."

The three creators had deep pedigree. Thompson co-created Unix and the B language at Bell Labs. Pike co-created Plan 9, Inferno, and UTF-8 at Bell Labs. Griesemer had worked on the V8 JavaScript engine and the Java HotSpot compiler. They understood systems programming at a level few teams on Earth could match.

"Go was born out of frustration with existing languages and environments for the work we were doing at Google. Programming had become too difficult, and the choice of languages was partly to blame."
— Rob Pike, "Go at Google: Language Design in the Service of Software Engineering" (2012)
Timeline
The Evolution of Go
September 2007
Go Is Conceived
Griesemer, Pike, and Thompson begin designing Go at Google. The initial goals: fast compilation, easy concurrency, and simplicity. Within days, they have a rough language spec sketched on a whiteboard.
2008
Compiler Development
Ken Thompson writes the first Go compiler, initially targeting C as an intermediate language. Ian Lance Taylor independently starts a GCC frontend for Go. The team iterates rapidly on the language design.
November 10, 2009
Go Goes Open Source
Google publicly releases Go as an open-source project under a BSD license. The announcement generates massive interest — "a new systems language from the creators of Unix" is a compelling pitch. The first users start building real software.
2010
Go Wins Language of the Year
TIOBE names Go its "Language of the Year" for the fastest rise in popularity. The Go team releases the go command, consolidating build, test, install, and documentation into a single tool.
March 28, 2012
Go 1.0 Released
The Go 1 compatibility promise: programs written to the Go 1 spec will compile and run correctly, unchanged, for the entire life of Go 1. This stability guarantee is critical for enterprise adoption. Docker begins development in Go this same year.
2013 – 2014
Docker & Kubernetes
Docker is released in March 2013, written entirely in Go. Google open-sources Kubernetes in June 2014, also in Go. These two projects will define the cloud-native era — and Go becomes the de facto language of infrastructure.
August 2015
Go 1.5 — Self-Hosting
The Go compiler is rewritten from C to Go. Go is now self-hosting — the compiler, linker, assembler, and runtime are all written in Go. The garbage collector gets concurrent collection with sub-millisecond pause times.
2016 – 2017
Go Modules & dep
The Go community grapples with dependency management. dep emerges as a community tool. The Go team begins designing the official module system that will ship in Go 1.11.
August 2018
Go 1.11 — Modules
Go modules ship as the official dependency management system. Versioned dependencies, reproducible builds, and no more GOPATH requirement. Also adds experimental WebAssembly support.
March 2022
Go 1.18 — Generics
After a decade of debate, Go adds type parameters (generics). Also introduces fuzzing as a first-class testing feature and workspace mode for multi-module development. The most significant language change since Go 1.0.
2023 – 2024
Go 1.21 – 1.22
Go 1.21 adds min, max, and clear builtins, plus profile-guided optimization (PGO) enabled by default. Go 1.22 adds range-over-int, improved routing in net/http, and loop variable scoping fix.
2025
Go 1.24
Go continues its six-month release cadence. The language remains committed to backward compatibility, performance improvements, and the Go 1 compatibility promise — now entering its 13th year.
Releases
Major Go Releases at a Glance
VersionDateKey Additions
Go 1.0Mar 2012Go 1 compatibility promise, stable spec, goroutines, channels, interfaces
Go 1.1May 2013Method values, race detector, performance improvements
Go 1.4Dec 2014go generate, internal packages, Android support
Go 1.5Aug 2015Self-hosting compiler (rewritten from C to Go), concurrent GC
Go 1.7Aug 2016context package in stdlib, SSA compiler backend
Go 1.8Feb 2017HTTP/2 push, graceful shutdown, plugins, sub-ms GC pauses
Go 1.11Aug 2018Go modules, experimental WebAssembly support
Go 1.13Sep 2019Error wrapping (errors.Is, errors.As), number literal improvements
Go 1.16Feb 2021embed package, io/fs filesystem abstraction
Go 1.18Mar 2022Generics (type parameters), fuzzing, workspace mode
Go 1.21Aug 2023min/max/clear builtins, PGO by default, log/slog
Go 1.22Feb 2024Range-over-int, enhanced net/http routing, loop var fix
Legacy
Go's Influence on Modern Language Design

Go demonstrated that a language could be simple, fast to compile, and productive without being complex. Its success influenced the design of newer languages: Rust adopted Go's approach to toolchain integration (cargo mirrors go), Zig embraced Go's philosophy of simplicity, and even Java and C# have adopted Go-style concurrency patterns.

Go also proved that garbage collection is not incompatible with systems programming. The Go GC achieves sub-millisecond pause times at scale — fast enough for infrastructure software that needs both safety and performance. This challenged the assumption that only manual memory management (C/C++/Rust) was viable for low-latency systems.

"Simplicity is complicated. But the clarity it brings is worth the effort."
— Rob Pike, "Simplicity is Complicated" (dotGo 2015)
Go History — Created at Google, 2009