A single developer publishing under the handle calfonso has released Rusternetes, a ground-up reimplementation of Kubernetes in Rust — 216,000 lines across ten crates, thirty-one controllers, and a passing grade of 94% on the official Kubernetes e2e conformance suite across 160 test rounds. This is not a wrapper around the Go codebase, not a partial mock, not yet another operator framework. Every load-bearing component — API server, scheduler, controller manager, kubelet, kube-proxy — has been rewritten from scratch against the upstream wire format. The repository sits at github.com/calfonso/rusternetes, and the README is unusually honest about what works and what does not.

To understand why this matters, separate it from what came before. kube-rs — a CNCF Sandbox project since November 2021 — is a Rust client library for building controllers and operators against an existing Kubernetes cluster. It does not replace anything. Rusternetes does. The lineage to look at is not kube-rs; it is AWS Firecracker, Cloudflare’s Pingora, Microsoft’s Hyperlight, and the Rust-for-Linux merge — the slow, deliberate eating of the Go and C foundations of cloud infrastructure by a memory-safe language. Kubernetes’ control plane was the obvious next target. It has now been hit.

For a Swiss procurement officer, the interesting part is not the Rust. It is the deployment mode. Rusternetes ships in three shapes from one codebase: a full cluster with etcd, the same cluster with etcd swapped for Rhino (a Rust-native etcd replacement backed by SQLite, Redis or Postgres), and a single-binary, single-process mode that runs all five control-plane components as concurrent tokio tasks against an embedded SQLite file. That last mode is the one to read carefully. Today, every Kubernetes entry in a federal procurement document drags along an etcd cluster, three nodes minimum, and an operations team that knows what Raft is. A single binary on a Framework laptop with a SQLite file does not. As The New Stack reported this month, 89% of organisations now prioritise Kubernetes rightsizing under the weight of AI workloads — but only 27% trust automation to apply the changes. Rust-native infrastructure attacks both the bill and the trust gap by being smaller and more legible.

←TODAY: A 94%-conformant Kubernetes control plane now runs in a single process against an embedded SQLite database — no etcd cluster, no operations team, no root.
→3012: The Zurich-3012 manifesto’s compute layer will be procured Kanton by Kanton. By then the question will not be “Go or Rust” but “what runs without phoning home.”
Fulcrum: Memory-safe infrastructure plus single-process orchestration collapses the floor at which a Kanton can sovereignly host its own AEC compute — which is the floor at which data residency stops being a clause and becomes an architectural decision.

Atelier: Architecture offices already run in-house compute for IFC processing, point-cloud handling, parametric simulation, and PAZ-GPT-class inference. The reason most studios do not run that compute on Kubernetes is operational, not technical: a real K8s cluster wants three nodes and a CI engineer. Rusternetes’ all-in-one mode collapses the wall. IfcOpenShell as a workload, Speckle as the data-exchange seam, a single binary as the cluster — the Atelier suddenly has the same orchestration substrate as a research lab, without the etcd babysitting.

Hack: This Hack teaches you to stand up a real Kubernetes cluster as a single process on your own machine — no etcd, no second node, no root — and then schedule an IFC job on it tonight. Medium: the Workflow itself; domain: shell.

# One Kubernetes cluster, one binary, one SQLite file.
git clone https://github.com/calfonso/rusternetes.git
cd rusternetes
cargo build -p rusternetes --release
./target/release/rusternetes --data-dir ./atelier.db &
export KUBECONFIG=~/.kube/rusternetes-config
kubectl get nodes
# Your laptop is now the cluster. Schedule a real IFC job
# the way the EPFL CNPA-IFC team would on their server.
kubectl create deployment ifc --image=aecgeeks/ifcopenshell
kubectl logs deployment/ifc

The risks are real, and the README is honest about them: a single-author project, no production deployments cited yet, no public benchmark against k3s, and a 6% conformance gap whose contents matter more than the headline number. Red Hat’s MicroShift 4.16.63, which shipped its own security advisory for edge-Kubernetes on 28 May 2026, is the incumbent in that lane and is not going away. Rusternetes is not yet production. It is a credible proof that the substrate can be Rust — and that proof is the part that lands in next year’s Bundesblatt.

When your Gemeinde next procures software, read the data-residency clause yourself, and write to your Gemeinderat if it is missing. The Switzerland that kept its sovereignty into the late 2070s did so because three Kantone wrote that clause in when nobody else was paying attention. Federalism is a slowness budget. Tools like Rusternetes are how you spend it.

Sources & Further Reading

• Primary: calfonso/rusternetes — Kubernetes, reimplemented in Rust
• Reinforcing: The New Stack — the fix for soaring AI cloud bills exists, so why won’t we trust it?