K8s Games: Kubernetes Practice Through a Browser Simulator

A Kubernetes Lab That Runs in the Browser

K8s Games addresses a practical gap between reading Kubernetes documentation and operating a cluster. Its stated purpose is to let people deploy pods, resolve CrashLoopBackOff and type kubectl commands inside a 3D simulation. The target audience includes people learning Kubernetes, CKA candidates, students studying cloud-native systems and SRE practitioners who want a visual environment for rehearsing operational decisions.

The project separates learning into a menu-driven game and a diagramming workspace. Campaign contains 20 levels across five chapters covering pods, deployments, networking, storage and production Kubernetes. Chaos presents escalating incidents and an objective based on survival. Sandbox lets users build a cluster freely, while Challenges provides 10 timed scenarios involving deployment and outage work. The documentation does not describe a connection to a live Kubernetes API or a real cluster, so the simulator should be understood as a learning surface rather than an operational control plane.

K8s Draw, available at /draw, has a narrower purpose. It is a 3D architecture whiteboard with 21 draggable resource types, connections, auto-layout, YAML export, PNG export and URL sharing. Its documentation explicitly says that it contains no game logic, incidents or scoring.

How the Simulator Models Kubernetes Resources

The simulator presents Kubernetes objects as shapes in a 3D cluster view. The README lists 25 resource types, including Pod, Deployment, ReplicaSet, StatefulSet, DaemonSet, Job, CronJob, Service, Ingress, NetworkPolicy, ConfigMap, Secret, PVC, PV, StorageClass, Node, Namespace, HPA, ResourceQuota, PodDisruptionBudget, ServiceAccount, Role, ClusterRole, RoleBinding and ClusterRoleBinding. Each resource has a distinct 3D shape, colour and simulated behaviour.

The visual model uses connections to represent relationships. Animated lines show ownership chains such as Deployment to ReplicaSet to Pod and network routing from Service to Pods. The Service connection is based on label selectors, and the interface includes quick-connect actions for wiring a Service to an existing Deployment. This makes the simulation useful for seeing how object relationships affect a cluster layout, although the visual line is an explanatory aid rather than a Kubernetes networking diagnostic.

Resources can be selected, moved, inspected and edited. The inspection view includes status, YAML and kubectl describe information. Editable properties include labels, replicas, selectors and service types. The Architecture Advisor scores a Sandbox design across HA, security, scalability, cost and six additional categories. This score is part of the game, not a documented Kubernetes certification or an independent infrastructure assessment.

Practising Commands and Incident Response

The command bar opens when the user presses /. The README gives examples of commands that the simulator supports, including:

get pods
describe deployment nginx
scale deployment nginx --replicas=3
logs pod-1
rollout status
drain node-1

Tab completion is included. The command examples show that the simulator is intended to connect visual inspection with command-line reasoning. A learner can select an object, read its status, request logs or description output, and then change a resource through the context menu or edit controls.

The incident catalogue contains 29 situations, including OOMKilled, CrashLoopBackOff, ImagePullBackOff, node NotReady, DNS failures, pending PVCs, API throttling, stuck rollouts, certificate expiry and HPA flapping. The documented workflow is to investigate with kubectl describe and logs, then apply a fix. The interface also exposes Logs, Restart, Scale and Delete actions through the right-click menu.

The project uses 40 achievements and a 30-level XP system ranging from Novice to CKA-ready. That progression can motivate repeated practice, but the README does not state that the XP system maps to every objective in the current CKA examination. It also does not claim that completing the campaign provides a certificate.

Starting K8s Games Locally

The hosted version requires no installation, signup or build step. A first use begins by visiting the site and choosing a game mode. The / shortcut opens the kubectl command bar, the question mark opens help, and the bottom toolbar provides Auto-Align, Reset View, YAML export and Help.

For local use, the README provides this short procedure:

git clone https://github.com/rohitg00/k8sgames.git
cd k8sgames
python3 -m http.server 8080
# Open http://localhost:8080

The repository uses Three.js r152, Tailwind CSS from a CDN and vanilla ES6 modules. It has no build step, bundler or package dependency installation. The top-level entries include index.html, draw.html, js/, style.css and vercel.json. The local procedure serves the files from the repository, so the browser needs access to the external Tailwind CDN described by the README.

A practical first session is to select Campaign, place a resource from the left palette, inspect it, and open the command bar with /. The help panel can be opened with ?. K8s Draw is separate from the game modes, so a learner who only wants diagrams should open the /draw page instead.

K8s Draw Versus the Game Modes

K8s Draw is the clearest alternative within the project itself. The game modes focus on learning through incidents, progression, scoring and timed scenarios. K8s Draw removes those mechanics and concentrates on architecture communication. Users can drag resources onto a 3D canvas, draw connections, rename resources with a double-click, delete selected objects with Del and let Auto-Align organize resources by Nodes, Workloads, Networking, Storage and RBAC.

Its export path is different from the simulator’s learning path. K8s Draw exports diagrams as YAML with Kubernetes apiVersions or as PNG, and it supports sharing diagrams through a URL. The documentation does not say that a YAML export from K8s Draw can be applied directly to a cluster, so the file should be treated as a diagram export unless the project separately documents deployment support.

For teams comparing tools, the practical distinction is between a guided practice environment and a diagramming canvas. K8s Games offers command entry, incident handling and resource behaviour. K8s Draw offers spatial arrangement, links and export. Neither is described as a general-purpose cluster deployment tool.

Limits, Maintenance and Upgrade Cost

The main limitation is the boundary between simulation and real Kubernetes operation. The README does not claim that the simulator validates manifests against a live API server, applies commands to a cluster or reproduces every controller, cloud provider integration and admission-control behaviour of Kubernetes. RBAC simulation includes ServicesAccounts, Roles, ClusterRoles, RoleBindings and ClusterRoleBindings with rule definitions and wildcard detection, but that feature is still presented as simulation. A learner should use it to understand relationships, not as proof that production authorization is correctly configured.

The project uses the Apache-2.0 license. That identifies the repository’s licensing terms, but it does not remove the need to check dependencies, hosted assets and any separate terms associated with use of the website. The README does not document a rollback procedure, release automation, compatibility matrix or upgrade policy.

The last push was on 2026-04-28. Releases v1.0.0 and v1.1.0 were published on 2026-03-31 and 2026-04-01 respectively. The repository is not archived, and the README describes no build or dependency installation step, which keeps the documented local setup small. Because the simulator is implemented in JavaScript and loads Tailwind CSS through a CDN, users should still account for browser and network availability when serving or presenting it.

Adoption Boundaries for Kubernetes Learners

Adopt K8s Games when the goal is repeated, visual Kubernetes practice in a browser, especially for building mental models of resource relationships and rehearsing incident commands. Campaign is the documented route for structured study, Chaos is suited to escalation practice, Sandbox supports free cluster design and Challenges adds time pressure. K8s Draw fits a different need, namely producing a readable architecture diagram with YAML or PNG output.

Do not adopt it as the sole substitute for a real cluster. The documentation does not establish that simulated commands interact with Kubernetes, that all Kubernetes versions behave identically, or that the Architecture Advisor reflects an external standard. The first verification should be to select one familiar workflow, compare the simulator’s command and resource behaviour with the learner’s actual Kubernetes environment, and confirm which version and scope the study material intends to cover.

Editorial conclusion

K8s Games suits learners who want guided Kubernetes practice, CKA-oriented preparation and a visual place to reason about cluster resources. It is not a replacement for a real Kubernetes cluster, production incident work or validation with the API server. Before adopting it for study, verify that the simulated commands and resource behaviours match the Kubernetes version and workflow used by the learner.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. rohitg00/k8sgames on GitHub