The history of the Go language

Go was born on a Google whiteboard on 21 September 2007 because C++ took too long to compile. In November 2025, the language celebrated 16 years of open source. In September 2026, the stable series is 1.27.1. Docker, Kubernetes, Terraform, the go you install on Linux — all of it stems from that meeting of three people.

Why a new language

Google toward the end of the 2000 decade: servers in C++ and Java, builds lasting three quarters of an hour, manual concurrency, dependencies that would not resolve. Rob Pike described the message in Go at Google: Language Design in the Service of Software Engineering: it was not a language fad, it was software engineering at scale. Compile quickly, use static typing, talk to the network without a threading framework, and produce a single binary.

The official FAQ pins down the origin: Robert Griesemer, Rob Pike, and Ken Thompson started sketching goals on the whiteboard on 21 September 2007. Within days it became a plan. In January 2008, Ken already had a compiler that emitted C. In May, Ian Lance Taylor independently began a GCC frontend. Russ Cox joined in late 2008 and took the prototype out of the lab.

Unix, Plan 9, CSP

The three résumés explain the language's taste. Ken Thompson co-created Unix and the B language. Pike came from Plan 9 and Inferno, co-invented UTF-8 with Thompson, and spent decades on concurrent languages — Newsqueak, Alef, Limbo — all following Tony Hoare's CSP (1978). Griesemer came from compilers: Java's HotSpot, V8. Go inherits Unix minimalism, CSP channels, and the stubbornness of a runtime that compiles in seconds.

The name appeared in Pike's email on 25 September 2007: “go.” Short, a verb, an easy domain. “Golang” is the search nickname — golang.org existed because go.org was not available. The canonical website today is go.dev.

The central idea: goroutines and channels

Before continuing the chronology, it is worth seeing what the language does differently — because it is not the syntax, it is the concurrency model.

A goroutine is not a system thread. It is a function that the Go runtime schedules across a handful of real threads, with an initial stack of a few kilobytes that grows on demand. That is why you launch ten thousand of them without a second thought — which with pthread would be irresponsible:

go processar(pedido)   // é isso. Não há pool, não há executor, não há Future.

Communication between them is the other side of the design, and it comes straight from Tony Hoare's CSP: instead of sharing memory and protecting it with a mutex, you pass data through a channel. The community's motto sums it up: “do not communicate by sharing memory; share memory by communicating”.

resultados := make(chan string)

for _, host := range hosts {
    go func(h string) {
        resultados <- checar(h)      // envia pelo canal
    }(host)
}

for range hosts {
    fmt.Println(<-resultados)        // recebe, bloqueando até chegar
}

And select is the epoll of the language: it waits on multiple channels at once, including a timeout channel.

select {
case r := <-resultados:
    fmt.Println(r)
case <-time.After(2 * time.Second):
    fmt.Println("estourou o tempo")
}

It is this combination — cheap goroutines, channels, select, and a static binary without a VM — that explains why virtually every infrastructure tool of the past decade chose Go. It is not the most expressive language; it is the one an entire team reads the same way on Monday.

10 November 2009

Go became a public project that day. The mascot — the blue gopher with enormous eyes — came with the launch. Renée French, who had already drawn the Plan 9 bunny (and is married to Pike), adapted a gopher from a WFMU T-shirt. It was called Gordon for a while; since 2010 it has simply been “the Go gopher.” GopherCons around the world came from there.

It was not Go 1 yet. There were two compilers: gc (the Plan 9 line, 6g/8g) and Taylor's gccgo. The standard library echoed Plan 9's taste — the package fmt even its name.

Go 1.0 and the promise

28 March 2012: Go 1.0. The contract that sustained adoption: a program written for Go 1 keeps compiling on any 1.x. There will be no Go 2 that breaks the world. Companies committed. The cadence became twice a year (February and August, with delays of days, not years).

Milestones that matter on Linux:

• 1.5 (August 2015): the compiler becomes written in Go (self-hosting); concurrent GC.
• 1.11 (August 2018): modules, still experimental. Goodbye to GOPATH as a prison.
• 1.13 (2019): official modules; errors.Is / %w.
• 1.16 (2021): //go:embed, modules by default.
• 1.18 (15 March 2022): generics — type parameters. The oldest request in the FAQ.
• 1.21 (2023): GOTOOLCHAIN automatically downloads the version that go.mod requests; min/max; packages slices and maps.
• 1.22 (2024): per-iteration loop variables (end of the classic bug with for); better routing in net/http.
• 1.25 (August 2025): the collector Green Tea appears as an experiment (10–40% lower collection overhead in many services).
• 1.26 (10 February 2026): Green Tea becomes the default; modernizers in go fix.
• 1.27 (August 2026; 1.27.1 on 28 August): generic methods — Griesemer's proposal approved in March 2026 —, the new JSON engine (encoding/json/v2) and post-quantum cryptography in the standard library. The option to disable Green Tea also disappears.

The internet's infrastructure

Docker (2013) is Go. So is Kubernetes. Terraform, Prometheus, the Git client, half of the cloud CLIs. A static binary, no VM, no node_modules of 400 MB — that sold the language to Linux operators. In the 2026 TIOBE ranking, Go hovers around position 12ª; on GitHub and in infrastructure repositories, its weight is different.

Concurrency is the calling card: go func(), channels, select. It is not Erlang, not Java with a thread pool. It is CSP that fits in a syslog.

What Go rejected

No type inheritance, no exceptions in the style of throw, no macros, no method overloading. Generics arrived late and narrow. Generic methods only in 2026. The FAQ still says: if you miss X, perhaps Y already covers it. Pike, in 2023 (What We Got Right, What We Got Wrong), acknowledges what mattered: the gopher was right; GOPATH took too long to die; communication of the “why” arrived in 2013, four years after launch.

The complaints that remain, and matter to anyone choosing a stack:

• if err != nil on every line. The absence of exceptions makes errors explicit — and also leaves a third of the file repeating the same check. It is the community's oldest debate, and no syntactic sugar proposal has passed to this day.
• nil still exists. Nil pointer, nil map, nil interface that is not nil: Go did not follow the path of Option that Rust took, and a panic from dereferencing remains the most common bug in production.
• A garbage collector is a garbage collector. Green Tea significantly reduced the overhead, but anyone needing predictable latency at percentile 99,9 still runs into it — and that is exactly where Rust enters the conversation.
• Governance belongs to Google. Open, with public proposals and visible reviews, but the company's team has the final say. It differs from the independent foundations Rust and Kubernetes established.

None of this is accidental. Go was designed for large teams to write network services with little ceremony, not to be the most powerful language in the room. The rejections are the product.

On Linux today

The stable series in September 2026 is 1.27.1, from 28 August. The recommended route is the go.dev tarball, because distribution packages are usually one or two versions behind:

# descobre a versão atual sem abrir o navegador
VER=$(curl -fsSL 'https://go.dev/VERSION?m=text' | head -n1)
echo "$VER"

# instala no lugar canônico
curl -fLO "https://go.dev/dl/${VER}.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "${VER}.linux-amd64.tar.gz"

# PATH permanente
echo 'export PATH=$PATH:/usr/local/go/bin' | sudo tee /etc/profile.d/go.sh
source /etc/profile.d/go.sh
go version

To keep multiple versions side by side — useful when a project is still stuck on an older one — Go itself handles it, without an external manager:

go install golang.org/dl/go1.26@latest
go1.26 download
go1.26 version

Since 1.21, incidentally, GOTOOLCHAIN does this automatically: if go.mod requests a version you do not have, the correct toolchain is downloaded at build time.

The complete how-to is in Installing Golang on Linux; its 2017 sibling, with 1.8.3, remains in Installing Golang 1.8.3 on Linux.

Timeline

• 21 September 2007 — Griesemer, Pike, and Thompson sketch the goals on Google's whiteboard.
• 25 September 2007 — in Pike's email, the language gets its name: go.
• January 2008 — Ken Thompson has a compiler that emits C.
• May 2008 — Ian Lance Taylor independently starts the GCC frontend.
• Late 2008 — Russ Cox joins and takes the prototype out of the lab.
• 10 November 2009 — the project opens up; Renée French's gopher comes with it.
• 28 March 2012 — Go 1.0 and the compatibility promise that sustained adoption.
• 2013 — Docker is born in Go and takes the language into infrastructure.
• 2014 — Kubernetes too; Go's cargo the go get, still depended on GOPATH.
• August 2015 — 1.5 becomes self-hosting (compiler written in Go) and gains concurrent GC.
• August 2018 — 1.11 brings modules, still experimental; GOPATH starts to die.
• 2019 — 1.13 makes modules official.
• 2021 — 1.16 brings //go:embed and modules by default.
• 15 March 2022 — 1.18 finally delivers generics.
• 2023 — 1.21 brings GOTOOLCHAIN, min/max, slices and maps.
• 2024 — 1.22 fixes the classic loop variable bug.
• August 2025 — 1.25 brings the collector Green Tea as an experiment.
• 10 February 2026 — 1.26 makes Green Tea the default.
• August 2026 — 1.27 delivers generic methods, JSON v2, and post-quantum cryptography.

Wrap-up

Three people, a whiteboard, a language that rejected weight and won the cloud. Sixteen years after going open source, the 1.x contract still holds and the gopher is still blue. The opposite bet, from the same decade, is in The history of the Rust language; the complete map, in The 7 main programming languages. And what Go built is in The history of Docker and The history of Kubernetes. Sources: FAQ, Go’s Sweet 16, Pike, ten years, wiki and release notes at go.dev/doc/devel/release.

Gopher based on the official mascot by Renee French, CC BY 3.0 license.