u/Content_Ad_4153

I’ve been building Yellow Olive - an open-source, gamified way to learn Kubernetes, built primarily with Python.

The idea is simple: instead of reading through Kubernetes tutorials, you enter a retro, Game Boy-inspired environment and complete missions against a real Kubernetes cluster.

The project uses Python + Textual for the terminal experience and challenge engine. Each mission gives you an objective, lets you work with a real cluster, and then validates whether you actually completed it - so learning feels closer to progressing through a game than following a tutorial.

More recently, I’ve also started building Yellow Olive Academy using Pyxel. It adds pixel-art classrooms, characters, diagrams and interactive lessons before you jump into the hands-on challenges.

The goal is to combine gamification, retro aesthetics and real hands-on infrastructure learning rather than building another Kubernetes tutorial.

It’s still evolving, and I’d love feedback from Python folks - especially anyone who has worked with Textual, Pyxel, TUIs or educational games.

And if you like the idea, a ⭐ would be hugely appreciated :)

GitHub: https://github.com/Anubhav9/Yellow-Olive

[ Pls turn on the volume for the video ]

I’m building Project Yellow Olive, an open-source retro TUI that helps people learn Kubernetes through gamified, hands-on challenges running against real clusters. I’ve posted about Project Yellow Olive here before and got a really good response to the idea, so I wanted to share one of the newer things I’ve been experimenting with.

I’ve now started experimenting with Pyxel, a lightweight retro game engine for Python, to add a visual learning layer alongside the existing challenges.

The idea is to visually explain concepts like nodes, namespaces, pods, services and deployments, while keeping the same retro aesthetic as the rest of Yellow Olive.

The hands-on part still stays real Kubernetes - Pyxel is mainly there to make some of the underlying concepts easier to understand before jumping into kubectl/YAML.

Would be interested to hear what people here think about this direction, especially those who’ve taught or mentored people on Kubernetes. Feedback is the main thing I’m looking for, but if you like the project, a GitHub star is always appreciated 🙂

GitHub: https://github.com/Anubhav9/Yellow-Olive

[🔊 Sound on for the demo!]

I’ve been building Yellow Olive, a side project that lets you learn Kubernetes by actually playing through challenges instead of just reading YAML tutorials.

You get missions, work against a real Kubernetes cluster, and the game validates whether you actually solved them.

It started as a small experiment because I wanted Kubernetes practice to feel a little less… Kubernetes-y 😅

It’s now grown into multiple chapters covering things like Pods, Services, RBAC, Deployments and more.

I’ve attached a short demo 👆

Would genuinely love feedback from r/SideProject:

Does this look like something you’d actually use to learn/practice Kubernetes?

GitHub: github.com/Anubhav9/Yellow-Olive

Hey r/commandline

I’ve posted about Project Yellow Olive here before. It’s a Pokémon-inspired terminal game where users practise Kubernetes by completing missions against a real cluster.

One problem I’ve faced with maintaining a CLI tool is understanding failures that happen on other people’s machines.

Until now, I depended entirely on users opening a GitHub issue and sharing the traceback. That works when someone is willing to report the issue, but otherwise I have no visibility into crashes, environment-specific failures, or unexpected edge cases.

I’ve now added Sentry reporting, but it is completely opt-in.

On first use, Yellow Olive asks whether the user wants to send sanitized error reports to Sentry. If they say no, Sentry is not initialized and nothing is sent. The user can also enable or disable it later through the CLI.

I’m intentionally avoiding the collection of Kubernetes manifests, resource contents, kubeconfig information, environment variables, terminal commands, credentials, and other cluster data. The reports are intended to contain only information such as the Yellow Olive version, Python/OS version, mission identifier, exception type, and sanitized stack trace.

The trade-off is that when someone declines telemetry, I have no remote way to diagnose what happened unless they voluntarily share their local logs or open an issue. I think that is the correct trade-off: opting out should actually mean opting out.

I’d appreciate some general feedback:

• Does this consent model feel appropriate for an open-source CLI?
• What fields would you never include in a crash report?
• How do you handle debugging when users disable telemetry?

Looking forward to all your feedbacks. In case, you are interested in the project, Github Link is attached below. If you like the project, please do star the repo as it will help it reach wider audience. Thanks !

Project: Project Yellow Olive on Github

Hi r/kubernetes,

Hope you are all doing well. I recently set up a mini PC with k3s and wanted to use it for something beyond the usual homelab services. I maintain Yellow Olive, a terminal-based game for learning Kubernetes locally with minikube.

I started experimenting with a hosted variant: a small number of users sign in, each receives an isolated namespace, and works through a challenge using kubectl in the browser-for example, debugging a pod that fails to start.

The proof of concept is running on my homelab. I’m less confident about the multi-tenant security model and would appreciate feedback from others who’ve run similar setups.

How it works

1. User signs in with GitHub → assigned a lab seat (max 7) and a namespace ({login}-{github-id})
2. Start session - the API (with admin kubeconfig) applies namespace, ResourceQuota, NetworkPolicy, RBAC, and a challenge manifest
3. A ServiceAccount token is issued; a limited kubeconfig is stored server-side only
4. The browser terminal runs kubectl via subprocess using that kubeconfig
5. Check challenge - the platform validates the workload (e.g. pod is Running/Ready)

Admin credentials are used for bootstrap and validation. Players never receive cluster-admin access.

Isolation (three layers)

• Cluster: ResourceQuota per namespace (CPU/memory caps, object limits), NetworkPolicy restricting traffic to within the namespace
• RBAC: Role scoped to pods only (get/list/watch/create/update/patch/delete); ServiceAccount player bound to that Role
• Application: Terminal accepts kubectl only, forces namespace server-side, strips flags like -n, --kubeconfig, --as, and blocks shell metacharacters

Feedback and Suggestion appreciated

Credential model - I’m using ServiceAccount tokens and keeping kubeconfig files on the server rather than issuing them to clients. For sessions of roughly an hour, does that match how you’d approach it, or is there a better pattern?

Namespace lifecycle - I haven’t settled on teardown yet: delete on logout, expire after a TTL, or clean up manually. What has worked in practice?

Capacity - Everything runs on one k3s node today (~7 namespaces, mostly single-pod challenges). Is that a reasonable long-term setup for a homelab, or a bottleneck waiting to happen. If it helps, my home lab PC has 16 gigs of memory.

In case, you want to check out the code, it's in my repository . Would really appreciate if you can star the repo for better reach :)

Project Yellow Olive on Github ( Hosted Labs )

TIA !

[ Pls turn on the sound for the demo video ]

Hey folks,

I had posted here earlier about Project Yellow Olive, my open-source attempt at making Kubernetes practice a little less boring through a retro terminal-based game.

Since then, I’ve been working on expanding it beyond the initial pod-based challenges.

The basic idea is still the same:

• Containers are Electromons
• Pods are Pokepods
• Namespaces are towns
• Team Evil breaks things
• You fix them using real Kubernetes commands

The game runs locally and validates your progress against an actual Kubernetes environment using Docker/minikube, so it is not just a quiz or a fake simulation.

Recent updates:

• Added a new Services chapter set in a virtual namespace called Signal Town
• The player fixes broken service discovery and networking issues
• Covered concepts like selectors, ClusterIP/NodePort-style service debugging, and broken workload access
• The next chapter on Kubernetes RBAC is all ready, set in a virtual namespace called Gold Rush City.
• Gold Rush focuses on Roles and RoleBindings, where Team Evil is abusing permissions and the player has to fix access properly

The project is still early and rough around the edges, but I’m trying to make Kubernetes practice feel more memorable, especially for folks preparing for CKAD/CKA or trying to get more hands-on with cloud-native concepts.

Would love feedback from developers here, especially on:

• Whether this kind of gamified learning actually feels useful
• What Kubernetes concepts would be fun to add next
• Any rough edges in the setup/install flow

Github: https://github.com/Anubhav9/Yellow-Olive

It can also be installed via PyPi by keying in: pip install yellow-olive

And if you like the idea, a GitHub star would genuinely help :)

Hey r/commandline,

I’m building Terminal Eleven - a retro football World Cup TUI for people who basically live inside the terminal.

The idea is simple: Not everyone can keep a live broadcast running, especially folks in places like India/China where streaming rights, subscriptions, time zones, and work hours can make it annoying to follow matches properly.

So Terminal Eleven sits quietly in your terminal and gives you match updates with retro vibes.

It can:

• show fixtures, groups, teams, and venues
• let you search matches by team/date/venue
• beep/play chiptune sounds for goals, half-time, and full-time
• give a nostalgic Winning Eleven / old PES-style terminal experience

Basically, a football companion for devs who want World Cup updates without leaving their shell.

A note on prior art: If you want a general football TUI that handles 65+ leagues year-round, golazo is excellent and the project that made me realise a terminal app could do this at all.

Mine is narrower on purpose - runs for 4 weeks of your year, knows exactly which 48 teams matter, has the half-time/full-time audio cues I wanted for this specific tournament.

Would love feedback from terminal/TUI folks on the UX, sound cues, and what would make this genuinely useful during the World Cup.

Repo URL : Terminal Eleven on Github

Installation Steps: pip install terminal-eleven

If anyone wants to bookmark this for June, easiest way is to star the repo - I'll push fixes to the live-score parsing if ESPN changes their endpoint mid-tournament, and stars are genuinely the only way I'll know there's anyone to ship for :)

Hey everyone,

I've been working on Project Yellow Olive - a terminal-based game that turns Kubernetes practice into a retro Pokémon Yellow style adventure.

Recently added a new area called Signal Town, where you meet:

• Cool Turtle (our version of Squirtle)
• Team Evil (our version of Team Rocket)

The game uses real Kubernetes concepts behind the scenes (Pods, Services, Deployments, etc.) while keeping the gameplay fun and nostalgic.

It's still in early stages but slowly growing. Built using Textual for the TUI.

It can be installed via pip by typing in the following command

pip install yellow-olive

If you liked the idea or even just smiled at PsyQuack’s headache face, a star on the repo would mean a lot - helps keep me motivated to add more levels!

GitHub: https://github.com/Anubhav9/Yellow-Olive

Thanks!

Hello r/devops,

Hope you're all doing well!

A while back I posted here about my side project Project Yellow Olive - a retro-styled TUI game inspired by Pokémon Yellow.

The initial feedback was trending on the positive side, so I kept building it.

A bit about Project Yellow Olive :

The game is all about turning the pain of learning K8s into a fun TUI game. We explore regions, battle with Posemons (container-based creatures), use kubectl-like commands as moves, and complete quests that actually run against the local cluster to validate what we did.

It is built entirely in Python using Textual for the TUI. It feels like a proper old-school terminal game with that nostalgic Pokémon Yellow palette and chiptune vibes

What's new since the last post

• Focused on Pods for now - added more challenges and battles around pod lifecycle, troubleshooting, and management.
• Added Game Save & Resume feature based on the feedback.
• Completely reworked the game flow with proper validations and a much smoother user experience (no more makeshift paths).
• Released on PyPI - installation is now super simple!
• Replaced the background music across all screens with CC0-licensed chiptune tracks. (Had to remove the original Pokémon Yellow tracks due to copyright reasons, but the new ones still keep that authentic retro 8-bit feel.)

Installation

I've now released this to PyPi. This means that the installation is now quite simple and straightforward. We just need to run the following command

pip install yellow-olive

As a pre-requisite, please also install Docker and Minikube.

Here is the PyPi page for reference : Project Yellow Olive on PyPi

Feedback and Suggestions

Project Yellow Olive isn't meant to replace proper Kubernetes learning resources (books, courses, CKAD practice, etc.). It's just here to make the repetition less boring and more engaging.

Would love to hear thoughts on:

• How does the TUI feel?
• Any suggestions for new mechanics or improvements?
• Ideas for future challenges (beyond Pods)?

Github Repo

The project is fully open source. I'd love contributions, especially new challenges/quests!
If you enjoy the idea, a star on the repo would really motivate me to keep pushing it forward. Looking forward to all your feedback

Github URL : Project Yellow Olive on Github

Hello r/TUI,

Hope you're all doing well!

A while back I posted here about my side project Project Yellow Olive - a retro-styled TUI game inspired by Pokémon Yellow.

The initial feedback was trending on the positive side, so I kept building it.

A bit about Project Yellow Olive :

The game is all about turning the pain of learning K8s into a fun TUI game. We explore regions, battle with Posemons (container-based creatures), use kubectl-like commands as moves, and complete quests that actually run against the local cluster to validate what we did.

It is built entirely in Python using Textual for the TUI. It feels like a proper old-school terminal game with that nostalgic Pokémon Yellow palette and chiptune vibes

What's new since the last post

• Focused on Pods for now - added more challenges and battles around pod lifecycle, troubleshooting, and management.
• Added Game Save & Resume feature based on the feedback.
• Completely reworked the game flow with proper validations and a much smoother user experience (no more makeshift paths).
• Released on PyPI - installation is now super simple!
• Replaced the background music across all screens with CC0-licensed chiptune tracks. (Had to remove the original Pokémon Yellow tracks due to copyright reasons, but the new ones still keep that authentic retro 8-bit feel.)

Installation

I've now released this to PyPi. This means that the installation is now quite simple and straightforward. We just need to run the following command

pip install yellow-olive

As a pre-requisite, please also install Docker and Minikube.

Here is the PyPi page for reference : Project Yellow Olive on PyPi

Github Repo

The project is fully open source. I'd love contributions, especially new challenges/quests!
If you enjoy the idea, a star on the repo would really motivate me to keep pushing it forward.

Github URL : Project Yellow Olive on Github

Feedback and Suggestions

Project Yellow Olive isn't meant to replace proper Kubernetes learning resources (books, courses, CKAD practice, etc.). It's just here to make the repetition less boring and more engaging.

I've attached a short demo video below (sound on for the full retro experience!).

Would love to hear thoughts on:

• How does the TUI feel?
• Any suggestions for new mechanics or improvements?
• Ideas for future challenges (beyond Pods)?

Looking forward to all your feedback