Lore

The golang/go repository's git history goes back further than Go itself. The earliest commit, dated 18 July 1972, is a copy of Brian Kernighan's original "hello, world" program from the Bell Labs era — a deliberate Easter egg added when the project went public to honor the lineage from B and C. Real Go development starts in March 2008.

This page tells the story of how the codebase evolved. Dates are approximate and derived from git tags, commit timestamps, and surviving notes in doc/.

Eras

The pre-history (Jul 1972 – Feb 2008)

A handful of commits dating to 1972, 1974, and 1988 are stand-ins from the historical "hello, world" / B / C lineage. They are repository folklore: the Go project's git history begins with a wink at the Unix tradition.

Birth and design (Mar 2008 – Nov 2009)

• Mar 2008 — First substantive commit (Go spec starting point) lays down doc/go_spec. The project starts as a Google internal effort by Robert Griesemer, Rob Pike, and Ken Thompson, soon joined by Russ Cox, Ian Lance Taylor, and Adam Langley.
• 2008 — Two compilers exist in parallel: gc (the Plan-9-derived compiler this repo's cmd/ descends from) and gccgo (a separate GCC frontend, not in this repo).
• 10 Nov 2009 — Go is open-sourced. The compiler, runtime, and a small standard library go public on go.googlecode.com.

Stabilization toward Go 1 (2010 – Mar 2012)

• 2010 – 2011 — The standard library matures. Goroutines and channels stabilize. The runtime is still substantially written in C.
• Mar 2012 — go1 tag. The Go 1 compatibility promise: every Go program that compiles with Go 1 will continue to compile with future 1.x releases. This commitment shapes everything that follows in src/ — especially the public APIs in api/.

The C-to-Go runtime conversion (2013 – Aug 2014)

• The runtime started life partly in C (runtime.c, *.c files under src/runtime/). Beginning around Go 1.4, this code is mechanically translated into Go using a custom tool, then iteratively cleaned up.
• Aug 2014 — Go 1.4 ships. src/runtime/ is now mostly Go plus per-architecture assembly. The .c files have been retired except for cgo glue.

Concurrent garbage collector (Oct 2014 – Mar 2016)

• Aug 2015 — Go 1.5 ships with a fully concurrent, low-latency GC (mark phase concurrent with the mutator). This is one of the project's most consequential rewrites and lives in src/runtime/mgc*.go. The hybrid write barrier (Yuasa + Dijkstra) appears around Go 1.8.
• Feb 2016 — Go 1.6 / 1.7 brings further GC and scheduler refinements. Pause times drop into single-digit milliseconds for typical heaps.

SSA backend (Aug 2016 – Feb 2017)

• Aug 2016 — Go 1.7 ships with the new SSA-based amd64 backend (src/cmd/compile/internal/ssa). This eventually replaces the legacy "obj"-based backend on every architecture and is now the foundation of the compiler's middle-and-back end.
• The SSA rewrite system (*.rules files) becomes the standard way to add architecture-specific peepholes.

Modules (Aug 2018 – Aug 2019)

• Aug 2018 — Go 1.11 introduces modules in preview. The new dependency system (go.mod, go.sum, MVS) lives in src/cmd/go/internal/mod* and src/cmd/go/internal/modload.
• Aug 2019 — Go 1.13 makes modules the default. GOPATH mode persists for a few releases but stops being the recommended workflow.
• The module proxy infrastructure (proxy.golang.org, sum.golang.org) is built outside this repo but is integrated through src/cmd/go/internal/modfetch.

Generics (Mar 2022)

• Mar 2022 — Go 1.18 adds type parameters ("generics"). Implemented largely in src/cmd/compile/internal/types2 (a fork of go/types) and src/cmd/compile/internal/noder. The "Unified IR" import/export format that survives today is introduced as part of this work.

Coverage everywhere, profile-guided optimization, fuzzing (2022 – 2023)

• Mar 2022 — Native fuzzing in testing.F and src/internal/fuzz/.
• 2022 — Coverage data format moves to a new internal representation (src/cmd/internal/cov/) supporting whole-binary coverage, not just go test.
• Aug 2023 — Go 1.21 ships profile-guided optimization (PGO). The compiler reads default.pgo files; see src/cmd/compile/default.pgo for the toolchain's own profile and src/cmd/compile/internal/pgo/.

Language adjustments (2023 – 2025)

• Aug 2023 — Go 1.21 changes the long-standing for loop variable scoping to per-iteration semantics in modules that opt in via go.mod's go directive. This is one of the few intentional breaks of the Go 1 promise, gated by language version.
• Aug 2024 — Go 1.23 introduces range-over-function iterators (for _ = range myFunc) and the iter package (src/iter/).
• 2024 – 2025 — Toolchain switching (GOTOOLCHAIN) lets go.mod request a specific Go release; cmd/go/internal/toolchain/ re-execs the right go binary.

Recent and ongoing (2025 – 2026)

• The current master is Go 1.27 in development. Recent activity (see by-the-numbers) is concentrated in:
  • ARM64 SVE support — large changes to src/cmd/internal/obj/arm64/ and src/cmd/asm/internal/asm/.
  • Generic methods experiment — GOEXPERIMENT=genericmethods, type parameters on methods, gated through src/internal/goexperiment/.
  • JSON v2 — encoding/json/jsontext and a new encoding/json/v2 API are being staged in.
  • SIMD intrinsics — src/simd/ hosts the foundations for explicit SIMD types and operations.
  • Goroutine leak profiling — runtime/goroutineleakprofile_test.go and surrounding code grow new instrumentation.

Longest-standing features

A few subsystems trace back to the very first commits and still exist in roughly the same shape:

• Channels and goroutines. The user-visible primitives have been there since 2008. Their runtime implementations have been rewritten multiple times (notably for fairness and performance) but the API surface is unchanged.
• The Go specification (doc/go_spec). First committed March 2008. Edited continuously, but it's the same document and still authoritative.
• gofmt. One of the earliest user-visible tools. Nominally complete and stable for many releases — its rules have evolved very little since Go 1.
• net/http. The initial http server and client land before Go 1. The package's API is unchanged in shape since Go 1.0; under the hood it has gained HTTP/2 (Go 1.6, in src/net/http/internal/http2/) and HTTP/3 work in progress.

Deprecated or replaced features

• GOPATH mode. The pre-modules workspace style. Still works for older code but nothing new is written this way; toolchain pieces under cmd/go/internal/work and cmd/go/internal/modload route around it.
• The C-language runtime. Replaced over 2013–2014 by Go-language runtime files. Surviving C is mostly cgo support.
• go get for installing tools (pre-modules behavior). Go 1.16 changed go get to manage go.mod only; tool installation moved to go install pkg@version. The legacy install behavior is gone from cmd/go/internal/modget.
• The legacy "old" backend. Pre-SSA architecture-specific code generators were retired in stages between Go 1.7 and Go 1.10. Their files are gone from cmd/compile/internal/.
• The Plan 9 C-style toolchain (6c, 8c, 5c, …). Removed when the C compilers were no longer needed for runtime.

Major rewrites

When	What	Why
2013 – 2014	Runtime: C → Go	Self-hosting, fewer toolchains to maintain, easier to optimize
2014 – 2016	GC: stop-the-world → concurrent mark	Latency and scalability for server workloads
2015 – 2017	Compiler back end: legacy → SSA	Better optimization, easier per-arch work
2018 – 2019	Dependency model: GOPATH → modules	Reproducible builds and vendoring without per-repo conventions
2021 – 2022	Type checker / IR: legacy IR → types2 + Unified IR	Generics support and a cleaner front-end design
2022 – 2023	Coverage: per-test → application-wide	Coverage from non-test binaries (go build -cover)

Growth trajectory

• 2008 – 2009. Single Google-internal team. Tens of thousands of lines.
• 2010 – 2014. Open source ramp. First few hundred external contributors.
• 2015 – 2018. Steady community growth; release cadence solidifies (every six months).
• 2019 – present. ~3,000 commits per year; ~1,500 in the last six months (see by-the-numbers). Total unique commit authors crosses ~2,800 in 2026.

Speculation

The repo's history is well-documented compared to most projects, but a few details are inferred:

• The conversion of the runtime from C to Go appears to have been driven primarily by maintainability: maintaining two languages, two toolchains, and a cgo-style boundary inside the runtime itself was a recurring source of bugs.
• The shift from a per-platform legacy back end to SSA likely happened gradually because new architectures (arm64, ppc64, riscv64) were easier to add against the SSA framework than the legacy one.

Where to read next

• Components — the present-day subsystems each of these eras created or transformed.
• How to contribute → patterns and conventions — coding style passed down through these rewrites.
• Reference → dependencies — the small set of golang.org/x/* modules vendored into the standard library today.