while True: learn()

Machine learning is the definitive “black box” of modern existence. We know it powers our recommendations and filters our spam, but for the average user, the underlying mechanics are as opaque as a dark-matter nebula. Enter Luden.io with while True: learn(), a title that attempts the impossible: making the history and application of data science approachable, engaging, and—yes—cute.

The premise is delightfully absurd. You play as a freelance programmer who discovers their cat is a better coder than they are. To bridge the communication gap, you set out to build a cat-to-human translator. This narrative framing provides a whimsical anchor for what is essentially a rigorous series of logic puzzles. Since its January 17, 2019 release, the game has occupied a unique niche in the “edutainment” market, positioning itself not as a coding simulator, but as a high-level logic trainer. It doesn’t ask you to write a single line of Python; instead, it asks you to understand the logic flow that makes modern AI possible.

Luden.io has carved out a reputation for these types of systemic deep dives, and here they target the conceptual hurdles of AI history. From the early days of simple expert systems to the complex, multi-layered “black boxes” of neural networks, the game serves as a playable museum. It’s a bold market play, targeting both the “curious amateur” and the “hardcore puzzle enthusiast” while managing to keep its tongue firmly in cheek. In a landscape of dry tutorials and overly-simplified “coding for kids” apps, while True: learn() stands out by respecting the player’s intelligence while simultaneously poking fun at the industry’s jargon-heavy absurdity.

• Visual Programming Interface: A sleek, node-based drag-and-drop system where you connect data sources to algorithms (Expert Systems, Decision Trees, etc.) to sort shapes and colors.
• The Mega Map of Machine Learning: A comprehensive, educational tech tree that traces the actual historical evolution of AI, providing real-world context for every node you unlock.
• In-Game Economy & Hardware: A simulation layer where you earn money from freelance contracts to buy faster CPUs, more powerful GPUs, and—crucially—fashionable hats for your cat.
• Startup Simulation: The ability to invest your earnings into tech startups, adding a layer of risk and reward that mirrors the Silicon Valley “fail fast” culture.

The Logic of the Loop

The core gameplay of while True: learn() is built on algorithmic thinking. Each “job” presents you with an incoming stream of data—circles, triangles, and squares in various colors—and a set of requirements. You might need to output only green circles or filter out everything that isn’t red. To do this, you drag nodes onto the workspace. In the beginning, these are simple “Expert Systems” (if/else blocks). As you progress, you unlock “Decision Trees,” “Random Forests,” and eventually, the heavy hitters like “Neural Networks.”

The strength here lies in the onboarding friction, or lack thereof. The game introduces complex concepts by stealth. You aren’t “learning backpropagation”; you’re trying to figure out why your current node setup is too slow to meet a client’s deadline. This creates a natural desire for optimization. You start chasing “Gold” ratings, which require your system to be both fast and accurate. This mirrors the real-world trade-off in machine learning: precision versus compute cost.

The “Sorting Puzzle” Trap

However, we have to address the elephant in the server room: at a certain point, the game stops feeling like a machine learning simulator and starts feeling like a pure sorting puzzle. Experienced programmers might find the abstraction a bit too thin. While the nodes are named after real algorithms, their function within the game is strictly limited to the color/shape data streams. You aren’t dealing with edge cases, data cleaning, or the messy reality of biased datasets.

As the puzzles grow in complexity, the “solutions” often involve sprawling, messy webs of nodes that look less like a sophisticated AI and more like a “spaghetti code” disaster. This leads to a noticeable spike in repetitiveness during the mid-to-late game. Once a reliable pattern for sorting specific data types emerges, the same “meta” gets reapplied across multiple jobs. The challenge shifts from “how do I solve this?” to “how do I click fast enough to wire this up again?”

Education Through Atmosphere

Where the game succeeds most is in its contextual storytelling. The “Mega Map” is genuinely insightful, offering digestible snippets of history that explain why we moved from one technology to another. The humor is sharp, too. Your inbox is filled with emails from “clients” who have no idea what they want, perfectly capturing the frustration of freelance tech work. The hardware upgrades cut down iteration time on complex builds, feeding a satisfying loop of: Solve Job -> Get Paid -> Upgrade Rig -> Solve Harder Job.

The inclusion of the Startup mechanic is a clever touch. It forces you to think about the long-term viability of the tech you’re building. Do you keep your stable freelance gig, or do you sink your savings into a “self-driving car” startup that might crash and burn? It adds a much-needed layer of stakes to the puzzle-solving.

The aesthetic direction is minimalist-industrial. It uses a blueprint-style background that keeps the focus on the colorful data streams. The UI design is remarkably clean, avoiding the “dashboard bloat” that plagues many simulation games. The visual representation of data “flowing” through your nodes is a tactile feedback loop—a readable picture of throughput that makes success feel earned.

As a 2D logic puzzler of this scope, the game is light on hardware by design, and the minimalist presentation means even screen-filling webs of nodes and thousands of data points stay legible. The cat’s animations are sparse but charming, providing just enough “personality” to keep the game from feeling like a sterile academic exercise.

On Steam, the setup is optimal by design. The mouse-and-keyboard controls suit the precision required in later levels, where dragging wires between small node ports demands accuracy.

On the Nintendo Switch, the picture is a bit more mixed. The touch screen is a sensible alternative for placing nodes, but wiring with Joy-Cons is a fiddly proposition for precision work. It’s built to be playable in handheld mode, but the desktop experience is the better way to play for anyone chasing those “Gold” efficiency ratings.

while True: learn() is a solid example of how to gamify the “boring” parts of technology. It doesn’t promise to turn you into a senior engineer at Google, but it does promise a functional, logical framework for understanding the technology that is currently reshaping our world. The late-game grind and a few oversimplifications keep it from greatness, but its charm and educational utility make it an easy recommendation for the right audience—at $12.99, a reasonable price for a guided tour of the history of the “thinking machine”—and the cats that probably run them.