A free website runs Kubernetes in your browser and turns extra tabs into cluster nodes

Opening another browser tab usually makes the computer’s problems less manageable. Tabernetes turns that habit into cluster administration: another tab joins as another node. There is finally a respectable reason to explain that all those tabs are infrastructure.

Jan-Otto Kröpke’s project page says the API server, controller manager, scheduler and kubectl come from upstream Kubernetes Go code, compiled into a WebAssembly binary. The storage exception matters: an in-memory replacement implements the etcd API. Reloading the page discards the cluster, so this is a very direct demonstration of what disposable actually means.

The control plane lives in a shared worker. Individual tabs join with their own connections, letting the control plane continue when one tab closes. The page describes the entire control plane sharing one CPU core because this browser WebAssembly execution is single-threaded. Adding tabs does not quietly turn your laptop into a rack of independent physical servers.

The tabs can also run container images through an emulator. Tabernetes pulls image layers, builds an initial filesystem and boots a small Linux kernel in v86. The emulated processor is 32-bit x86, so the image needs a linux/386 variant. A container tag alone therefore does not establish compatibility; its available architecture still has to match the machine underneath.

There is another practical boundary in the image path. Docker Hub does not supply the browser headers this needs, so the project uses the maker’s registry mirror. The cluster may sit inside your browser, but that does not mean every operation is offline or independent of outside services. Your network still gets invited to this particular lab exercise.

For a real worker, the page’s join command prints a Docker command. That container runs kubelet and containerd and connects over WebRTC. The distinction gives the experiment a useful progression: start with a disposable control plane, then attach a separate execution environment when the emulated node’s limitations become the subject of the lesson.

The project even offers KubeDoom after joining a real node. Monsters represent pods, shooting one deletes it, and a Deployment can bring it back. That makes reconciliation visible in a way a healthy green status icon never quite manages. Kubernetes has found another way to make an operator responsible for their own monsters.

For learning, the appeal is how little ceremony stands between a command and its consequences. The limitation is equally plain. A demonstration that vanishes on reload can show scheduling and recovery without giving anybody an accidental production dependency. The storage substitution, architecture requirement and shared CPU remain part of the experiment, even when the terminal looks familiar.

Your tab count is now capacity planning.