Binged this game from the beginning this last MLK weekend, after a few times taking a light run at it before and peeling off. This time I leaned in, and I’m in the last few levels now.

Man, what a trip. I’ve played the NAND game and MRHD, among others, but never quite got to the “build a computer” endgame. I did with this one. At this point I’ve built a 256-byte RAM system that does six math instructions, six conditional jumps, and subroutine calls using its own stack—then developed my own assembly language for it which I'm now using in the endgame to solve more traditional programming puzzles.

And I designed and built the entire architecture for it myself. The initial levels are mostly "one solution only" problems that each results in you designing a component. But by the time you're at midgame, all the decisions are yours as long as the output is correct. Previous problems tend to hint towards partial solutions of later problems, but very little is given to you outright. That gives you an incredible sense of accomplishment for what you put together.

What a thrill it was to get past adding the math instructions to adding the conditional jumps, and to discover that the tech decisions I made for the former (plus some clever crafting of the previous puzzles to define conditional opcodes as the same as math + a high bit) led to the latter being entirely incremental.

Or when the campaign led me by the nose through implementing a stack using the same basic controls as the RAM component—again, leading me to reuse infrastructure—and then suddenly set me loose to implement subroutine call/return using it with no further instruction than explaining that the return address needed to be an instruction later.

I’d already done the work of making the stack programmable, so I had the connections right there and just had to set up a hardcoded way to push addresses to the stack and counter at the right times. It actually meant ripping out more stuff than I had to add anew. Sounds intimidating but when you’re already knee deep in the “circuitry” it’s like working on your project car—you’re totally familiar and things flow.

Or how cool was it to realize that “immediate” mode for opcode parameters was probably originally called that because they *also* implemented it as a switched mux that cut off the circuits that selected registers for arguments in favor of “immediate” wiring of the inputs?

Or when I realized I was using “immediate zero” a lot, and (without being directed by a puzzle) created a “_" [indexed as 16] pseudo-register that actually cut off the argument bus entirely, leaving the argument as a hardcoded zero. That let me define new opcodes like "sav [src] _ [dest]" or "jmp _ _ [dest]" which were really just aliases for "add [src] 0 [dest]" or "jeq 0 0 [dest]" without them all needing extraneous immediate flags for the empty parameters.

Even better, I discovered the “disable” pin I’d put on the custom bus selector component I’d designed already did exactly this, when wired to bit 4 of the incoming value, and got to celebrate another prescient tech decision.

Even just the thrill of extracting really hairy parts of my circuits, designing them into standalone components, and reimplementing in terms of those is addicting. I’ve caught myself zooming out from my “computer” to admire the trace symmetry and how clean I’ve gotten parts of it, and I actually feel accomplished.

The game is far from perfect: wiring management in particular is a minor nightmare, with too few colors and a tendency for wires to cross connect as you drag attached components around. That’s especially true since highly attached components sometimes “drop out” of drag on their own.

There’s no way to, say, click a wire and see its routing, and the wiring engine has a *really* nasty tendency to route separate wires on top of each other in a way that makes it impossible to see the individual routings and makes them impossible to separate later. And then it has the rather awful behavior that if you hook another wire to a “combined” set by mistake (or by dragging a component around when it stutters and drops with a pin in the wrong place) it collapses the stacked set and shorts them *all* together. I find myself hitting Ctrl-Z a lot to find the last time things weren’t shorted out.

And labeling is just terrible. You can label a wire but if you add junctions it splits the wire in a way that eventually makes the label either relocate or disappear. And you can’t label *components* or add free text to the “breadboard” to label systems. I’ll be pretty well screwed coming back to this later for lack of hardware layout “comments,” so be prepared to binge to get it done. You pretty much have to because of the spaghetti problem.

And then there are more minor issues: component menus open on top of each other, and make things hard to select. Custom components with multiple inputs and outputs usually end up with unreadable labels that overlap each other. The need to select all wire terminals along with the component they’re on to get auto-routing on the wiring sucks, and the drag handles for a multi select work differently than most apps.

The game also never explains schematics to you, that there is only a single OVERTURE or LEG schematic, or that you’ll be totally screwing yourself in other levels if you sandbox your computer without making a copy first because using that schematic in the sandbox also just modified all your solutions.

Coming from Zachtonics games with all their polish, this is all pretty painful. And I do miss leaderboards, assuming they don’t unlock when I complete the campaign. Yet, somehow the appeal of iteration, componentization, and optimization has kept me coming back to this one with a passion and feeling of ownership I haven’t experienced in a long time.

Highly recommended, rough edges and all, especially in the “build yourself a computer” subgenre! This could be better, but it does hit the button really nicely.

Binged this game from the beginning this last MLK weekend, after a few times taking a light run at it before and peeling off. This time I leaned in, and I’m in the last few levels now. Man, what a trip. I’ve played the NAND game and MRHD, among others, but never quite got to the “build a computer” endgame. I did with this one. At this point I’ve built a 256-byte RAM system that does six math instructions, six conditional jumps, and subroutine calls using its own stack—then developed my own assembly language for it which I'm now using in the endgame to solve more traditional programming puzzles. And I designed and built the entire architecture for it myself. The initial levels are mostly "one solution only" problems that each results in you designing a component. But by the time you're at midgame, all the decisions are yours as long as the output is correct. Previous problems tend to hint towards partial solutions of later problems, but very little is given to you outright. That gives you an incredible sense of accomplishment for what you put together. What a thrill it was to get past adding the math instructions to adding the conditional jumps, and to discover that the tech decisions I made for the former (plus some clever crafting of the previous puzzles to define conditional opcodes as the same as math + a high bit) led to the latter being entirely incremental. Or when the campaign led me by the nose through implementing a stack using the same basic controls as the RAM component—again, leading me to reuse infrastructure—and then suddenly set me loose to implement subroutine call/return using it with no further instruction than explaining that the return address needed to be an instruction later. I’d already done the work of making the stack programmable, so I had the connections right there and just had to set up a hardcoded way to push addresses to the stack and counter at the right times. It actually meant ripping out more stuff than I had to add anew. Sounds intimidating but when you’re already knee deep in the “circuitry” it’s like working on your project car—you’re totally familiar and things flow. Or how cool was it to realize that “immediate” mode for opcode parameters was probably originally called that because they *also* implemented it as a switched mux that cut off the circuits that selected registers for arguments in favor of “immediate” wiring of the inputs? Or when I realized I was using “immediate zero” a lot, and (without being directed by a puzzle) created a “_" [indexed as 16] pseudo-register that actually cut off the argument bus entirely, leaving the argument as a hardcoded zero. That let me define new opcodes like "sav [src] _ [dest]" or "jmp _ _ [dest]" which were really just aliases for "add [src] 0 [dest]" or "jeq 0 0 [dest]" without them all needing extraneous immediate flags for the empty parameters. Even better, I discovered the “disable” pin I’d put on the custom bus selector component I’d designed already did exactly this, when wired to bit 4 of the incoming value, and got to celebrate another prescient tech decision. Even just the thrill of extracting really hairy parts of my circuits, designing them into standalone components, and reimplementing in terms of those is addicting. I’ve caught myself zooming out from my “computer” to admire the trace symmetry and how clean I’ve gotten parts of it, and I actually feel accomplished. The game is far from perfect: wiring management in particular is a minor nightmare, with too few colors and a tendency for wires to cross connect as you drag attached components around. That’s especially true since highly attached components sometimes “drop out” of drag on their own. There’s no way to, say, click a wire and see its routing, and the wiring engine has a *really* nasty tendency to route separate wires on top of each other in a way that makes it impossible to see the individual routings and makes them impossible to separate later. And then it has the rather awful behavior that if you hook another wire to a “combined” set by mistake (or by dragging a component around when it stutters and drops with a pin in the wrong place) it collapses the stacked set and shorts them *all* together. I find myself hitting Ctrl-Z a lot to find the last time things weren’t shorted out. And labeling is just terrible. You can label a wire but if you add junctions it splits the wire in a way that eventually makes the label either relocate or disappear. And you can’t label *components* or add free text to the “breadboard” to label systems. I’ll be pretty well screwed coming back to this later for lack of hardware layout “comments,” so be prepared to binge to get it done. You pretty much have to because of the spaghetti problem. And then there are more minor issues: component menus open on top of each other, and make things hard to select. Custom components with multiple inputs and outputs usually end up with unreadable labels that overlap each other. The need to select all wire terminals along with the component they’re on to get auto-routing on the wiring sucks, and the drag handles for a multi select work differently than most apps. The game also never explains schematics to you, that there is only a single OVERTURE or LEG schematic, or that you’ll be totally screwing yourself in other levels if you sandbox your computer without making a copy first because using that schematic in the sandbox also just modified all your solutions. Coming from Zachtonics games with all their polish, this is all pretty painful. And I do miss leaderboards, assuming they don’t unlock when I complete the campaign. Yet, somehow the appeal of iteration, componentization, and optimization has kept me coming back to this one with a passion and feeling of ownership I haven’t experienced in a long time. Highly recommended, rough edges and all, especially in the “build yourself a computer” subgenre! This could be better, but it does hit the button really nicely.