Tiny Logic

Tiny Logic looks like a small pixel-art puzzle toy but plays like a semester of computer architecture that happens to end with DOOM running on hardware you wired yourself. You begin with a battery and an LED, and you keep going until a CPU you built is executing your own code.

From One LED to a Working CPU in Tiny Logic

The core idea is simple to state and demanding to finish: build a computer from transistors upward. Early in the game you connect a battery to an LED, then you start placing transistors, and every step afterward stacks on what you just made. Because every gate is simulated and the electricity behaves the way the lessons describe, the circuits you build actually compute instead of just looking the part.

A set of 30 lessons guides the climb from single components to larger blocks and finally to a processor. Each lesson ends with something that works, which keeps the pace manageable even when the ideas get abstract. Players who have built redstone computers in Minecraft will feel at home, though the focus here is on understanding the logic rather than decorating a build.

A demo offers 15 lessons, and progress carries over into the full version, so you can test whether the style suits you before committing. The lessons start from a battery and an LED, so no electronics background is demanded up front. Patience matters more than prior knowledge, since the real obstacle is staying with a wiring problem until the lights finally behave.

Why Wiring Transistors Beats Reading About Them

Transistors are the first real building block, and the lessons treat them as switches you place and connect by hand. Watching one switch control another teaches the principle faster than any textbook diagram, because you can break the circuit and see exactly why it failed. That trial-and-error loop is where most of the learning happens.

Gates come next, built out of those switches. Once you stack gates into larger circuits, you start to recognize the same patterns again and again, which is when the experience stops feeling like a puzzle and starts feeling like engineering. Students tend to enjoy this stage because the abstract diagrams from class suddenly have wires you can follow.

Code arrives near the end, when the machine you built needs instructions to run. Programmers will get a kick out of this stage, because the program you write finally executes on hardware you can point to, gate by gate. It closes the loop between software and the physical logic underneath it.

Meeting TINY-32 and the DOOM Finish

TINY-32 is the machine the whole journey points toward, a 32-bit RISC-V computer made of 93,338 transistors. It is not an emulator hiding under a pixel-art skin; the computer is built from the gates you place, and it passes the official RISC-V test suite. Once TINY-32 is on screen and DOOM runs at full speed, the effort of the earlier lessons suddenly makes sense.

DOOM is not the only trophy. The same kind of machine can run a chess engine, a Minecraft-style 3D world, Java, and a tiny AI, all powered by gates. Chess fans and tinkerers will probably spend longer here than anywhere else, since each program shows a different side of what a CPU can do.

The scale is both the exciting part and the intimidating part. Seeing a processor of that size next to your first battery-and-LED circuit makes the opening lessons look tiny, which is exactly the point of the climb. It also explains why players describe the finish as earned rather than handed over.

Where Tiny Logic Asks a Lot From Players

The curve is the first honest warning. The jump from a handful of gates to a working processor is long, and players who skip lessons or rush the wiring will hit a wall. Patience, or a willingness to pause and redo a circuit, is worth more than speed here.

The second issue is the state of the project. It is still in development, and early ratings come from a small number of votes, so the perfect score should be read with that in mind. Windows players may also see an antivirus warning at install; the project page explains it as a false positive caused by the way the engine compiles circuits while you play, and promises a signed build.

Larger builds, DOOM especially, also want a capable machine, so older laptops may struggle where the early lessons run smoothly. Casual players who want a quick puzzle may find the sessions heavier than expected, while students and programmers will probably find the depth exactly right.

What Players Take Away From the Climb

Players leave with vocabulary they did not have before: gates, clocks, registers, and instruction sets stop being buzzwords and become things you have physically wired. Students gain a visible map of how a program turns into electrical activity, and curious players learn why a processor does what it does. That understanding stays useful long after the last lesson.

The project describes itself as a solo effort built with its players, and the community Discord is where lesson feedback and new ideas collect. Fifteen supported languages open the lessons to many learners who would otherwise skip an English-only tutorial. That reach matters for a subject that usually hides behind dense textbooks.

Because everything rests on real logic, the skills transfer. Anyone who finishes the lessons will read a CPU diagram differently, and anyone who bounced off hardware tutorials before gets a hands-on route that rewards experimenting.

Tiny Logic rewards players who enjoy building things from the ground up, and few projects make the leap from a battery and an LED to TINY-32 running DOOM feel this earned. Expect a steep climb, a few stubborn circuits, and a Windows warning that deserves a second look, but also the rare satisfaction of watching your own gates draw a 3D world.