The history of Kubernetes: Borg’s helm

On 6 June 2014 Joe Beda made the first public commit of what would become Kubernetes: 250 files, 47.501 lines of Go, Bash and Markdown. Four days later Eric Brewer announced the project at DockerCon. A year later, on 21 July 2015, 1.0 came out — and Google announced it would donate the code to the newly created Cloud Native Computing Foundation. Twelve years later, Kubernetes 1.37.0 (26 August 2026), nicknamed Garhwal, is still the standard way to orchestrate containers in production.

Years 2000: Borg, Omega and a Java prototype

Before the helm there was Borg. Since the middle of the 2000 decade Google had been running jobs on an internal cluster nobody outside could see. Omega (2013) tried the next step: a more shared scheduler, less monolith. None of it left the campus. Outside, in 2013, the cloud world was still bash scripts, Netflix-style immutable VM images and very little container orchestration.

What changed the perspective was Docker. Brendan Burns, Craig McLuckie and Joe Beda, at Google Cloud, saw the single-machine runtime and understood the gap: the fleet orchestrator was missing. Burns made a Java prototype. They rewrote it in Go. Ville Aikas, Tim Hockin, Dawn Chen, Brian Grant and Daniel Smith joined. Pods were still called Tasks; the name changed two days before the announcement, in the 8 June commit.

The internal codename, given by Burns, was Seven of Nine: the more approachable Borg from Star Trek. Hence the logo’s heptagon: seven sides, seven spokes on the helm. Kubernetes, in Greek, is the helmsman — the ship’s pilot. k8s is the same trick as i18n: eight letters in the middle.

June 2014: the commit and DockerCon

The first public commit is dated 6 June 2014, 16:40:48 Pacific time. Beda cleaned up the repository for launch; earlier work already existed. On 10 June Brewer took the stage at the first DockerCon. The message was simple: Docker packages; someone is needed to spread the package across dozens of machines, replicate it, discover services and heal what dies.

The “minimum viable orchestrator” they wanted had four pieces: replication, load balancing and service discovery, health checks with self-healing, and a scheduler that treats the fleet as a pool. The rest — Ingress, CRD, Operators, sidecars — came later from the community.

July 2015: 1.0, OSCON and the CNCF

Red Hat arrived early and brought what was missing: experience selling software to large enterprises, accumulated with OpenShift. Without that real-world perspective — multi-tenancy, zero-downtime upgrades, authorization that survives audits — 1.0 would not have shipped. Real RBAC would only arrive in 1.6, in 2017. On 21 July 2015, at OSCON, Kubernetes 1.0 was declared production-ready. That same day Google handed over control: the Cloud Native Computing Foundation was born, an arm of the Linux Foundation, with AT&T, Cisco, Docker, IBM, Intel, Red Hat, Twitter, VMware and a dozen others.

The project only actually joined as a CNCF hosted project on 10 March 2016 — the first. On 6 March 2018 it was the first to graduate. Apache 2.0, Go, declarative API: you describe desired state; the control loop tries to reach it. ReplicaSet, Deployment, Service, Namespace. Then Job, DaemonSet, StatefulSet, Ingress, CRD.

What the helm copied from Borg — and what it did not

The Pod is the atomic unit: one or more containers sharing networking and volumes, scheduled together. Borg already had this. Labels and selectors, the Service as a stable VIP in front of dying Pods, the kubelet on each node, etcd as the source of truth — that is the design. What Borg did not have, and Kubernetes bet on, was the open API and extensibility: Custom Resource Definition, admission webhook, Container Runtime Interface.

The runtime, incidentally, was never “Docker required”. Dockershim (the bridge that talked to the Docker daemon) was marked deprecated in 1.20 and removed in 1.24 (May 2022). Anyone who still thinks “Kubernetes = Docker” is four years behind, at best. CRI-O and containerd speak CRI directly. Docker Engine also uses containerd underneath. The whale’s story is in the companion post.

Kubernetes and Linux: the debt nobody mentions

Kubernetes only exists because the Linux kernel gained, years earlier, the two primitives that make containers possible — and one came from the same place.

• Namespaces answer “what can this process see?”. The first type arrived in 2002 (mount); the classic set — PID, network, IPC, UTS, user — was only completed in 2013, with the user namespace in kernel 3.8. The cgroup namespace would follow in 2016, and time in 2020.
• cgroups answer “what can this process consume?”. They were written by Paul Menage and Rohit Seth, from Google, starting in 2006, and entered mainline in kernel 2.6.24, released in January 2008. The original name was process containers — changed because “container” was already overloaded in the Linux ecosystem: Solaris Zones, Linux-VServer, OpenVZ.

Two Google engineers working on CPU and memory limits in 2006 is no coincidence: the company already ran everything on shared clusters, the lineage that would lead to Borg. The same campus that produced Borg donated to the kernel the piece that, five years later, Docker packaged and Kubernetes orchestrated. The helm did not invent isolation — it scheduled, at scale, isolation Linux already knew how to provide.

This shows up in everyday work: a Pod’s limit becomes a cgroup on the node (cpu.max, memory.max) and its request for CPU becomes scheduling weight (cpu.weight) — the request for memory only becomes a cgroup with Memory QoS enabled. The kubelet is an ordinary process reading and writing in /sys/fs/cgroup. And cgroup v2 (the default on current distributions) brought the unified memory controller — memory.min, memory.low, memory.high, memory.max — which slows the workload instead of only killing it at the limit. Under the v2 hierarchy the kernel exposes PSI (pressure stall information, kernel 4.20, December 2018) per cgroup; kubelet has read this signal as a stable feature since 1.36. Those who understand the kernel underneath debug Kubernetes much faster than those who only know YAML.

2016–2017: the war Swarm lost

While the helm grew, Docker bet on Swarm as its native orchestrator — easier to learn, integrated into the product everyone already had installed. In 2017 Docker, Inc. itself threw in the towel and announced Kubernetes support. Mesos, Nomad, Cattle — all survived in niches. The de facto standard became the heptagon. Not because YAML is pretty (it is not), but because every cloud provider began selling the same object: a managed Kubernetes cluster. GKE, EKS, AKS, Red Hat’s OpenShift, Rancher. The API became the Linux of the cloud: nobody loves it, everyone speaks it.

2016–2018: what happened to its creators

All three left Google, each in his own time. Brendan Burns went to Microsoft in July 2016 and helped build Azure Kubernetes Service. Joe Beda had already left in 2015; Craig McLuckie left in late 2016, and the two founded Heptio in November, in Seattle, to sell Kubernetes to enterprises. VMware announced the acquisition in November 2018 for about US$ 550 million and closed it in December; Heptio became one of Tanzu’s pillars — Velero, Sonobuoy, Contour, TKG. The project stayed where it should: in a foundation, with open governance and hundreds of companies pushing it forward.

2026: Garhwal, kube-dns and cleaning up legacy

Kubernetes 1.37.0 came out on 26 August 2026, a 15-week cycle, release lead Dipesh Rawat. Nickname Garhwal (गढ़वाल), a Himalayan region of Uttarakhand. 67 enhancements: 16 stable, 23 beta, 27 alpha, one deprecation. Highlights that matter in real clusters:

• Dynamic Resource Allocation completed the package: extended resource requests via drivers, taint and toleration for devices and the attribute resource.kubernetes.io/numaNode became Stable. DRA’s core had already been GA since 1.34 — it is what freed GPUs, FPGAs and AI devices from the Device Plugin workaround.
• kube-dns is deprecated. CoreDNS has been the default DNS since 1.13; new kube-dns packages should not ship after 1.40.
• The IPVS mode of kube-proxy had already been deprecated since 1.35; the path forward is iptables or, preferably, nftables — the mode is removed for good in 1.43.
• HPA scale-to-zero entered beta, enabled by default — autoscaling can now reduce replicas to zero.
• Nodes on cgroup v1 no longer start: kubelet’s failCgroupV1 is true by default since 1.35. Without cgroup v2 there is no Memory QoS, swap or PSI metrics — the debt to the kernel became an operational requirement.

The versions in active support in September 2026 are 1.37, 1.36 and 1.35 — 1.34 still receives fixes until 27 October. Version 1.37.1 is scheduled for 15 September. Etcd and CRI and CNI implementations remain outside the binary: the helm orchestrates; another process runs the container.

Try it today, without a cluster or the cloud

Twelve years later, starting Kubernetes to study it takes minutes on a single machine. Three paths, from most disposable to most production-like:

# kind — cluster dentro de containers, o mais rápido de jogar fora
kind create cluster --name estudo
kubectl get nodes

# minikube — VM ou container, com addons (dashboard, ingress, registry)
minikube start
minikube addons enable ingress

# k3s — leve, criado pela Rancher (hoje SUSE) e doado à CNCF em 2020; roda de verdade em Raspberry Pi
curl -sfL https://get.k3s.io | sh -
sudo k3s kubectl get nodes

The kind and the minikube are lab tools. k3s is something else: a single binary, with etcd replaced by SQLite by default (etcd returns only in HA with multiple servers), used at the edge and in small production environments. If the idea is a real cluster on a home server, start with it.

Timeline

• Middle of the 2000 decade — Google already runs jobs on Borg, an internal cluster nobody outside sees.
• 2006–2008 — Paul Menage and Rohit Seth, from Google, write cgroups; the feature reaches kernel 2.6.24 in January 2008.
• 2013 — Omega tries the next step inside Google; outside, Docker makes containers obvious.
• 6 June 2014 — first public commit: 250 files, 47.501 lines.
• 10 June 2014 — Eric Brewer announces the project at the first DockerCon.
• 21 July 2015 — Kubernetes 1.0 at OSCON; the same day the CNCF is born and Google announces it will hand over control.
• 10 March 2016 — first CNCF hosted project.
• 2016 — Burns goes to Microsoft; McLuckie and Beda found Heptio.
• 2017 — Docker, Inc. announces Kubernetes support; the Swarm contest ends.
• 6 March 2018 — first project to graduate at the CNCF.
• November 2018 — VMware buys Heptio for about US$ 550 million.
• May 2022 — dockershim is removed in version 1.24; containerd and CRI-O take over.
• 26 August 2026 — 1.37.0 “Garhwal”: kube-dns deprecated, HPA scale-to-zero in beta, complete DRA, cgroup v1 blocked by kubelet.

Wrap-up

Three engineers at Google Cloud, a single-machine runtime, an internal cluster nobody could see. The result is the control plane the industry copied. The heptagon on the cover is the same one from 2014. So is the YAML — for better and worse.

The whale that made containers obvious is in The history of Docker. The server hypervisor, in Proxmox and Xen. The kernel underneath everything, in Linux turns 35 and The history of Linus Torvalds.

From Borg to Garhwal: the helmsman is still at the helm. 1.37.0, Apache 2.0, CRI, nftables. Seven spokes, twelve years, and the YAML nobody likes writing but everyone commits.