Legendary Game Dev Jonathan Blow | The Standup

Jonathan Blow’s long-running throughline—rewind in Braid, symbol-driven puzzle design in The Witness, and now the “fuse realities” premise in Order of the Sinking Star—centers on one idea: game rules should generate surprising complexity, not just enforce tension. In a mailing-list debate around Braid’s signature rewind mechanic, Blow pushed the view that undoing actions shouldn’t be a gimmick bolted onto gameplay; it should be a core technical capability, designed into the system so designers can build around it. The counterargument was familiar—rewind might drain the stakes of dying—but Blow’s counter was that tension can be replaced with other kinds of interest, and that replay control can even make games more satisfying. That stance traces back to his own experience playing older NES titles on emulators where save-state/rewind-like features let him shape how much repetition he endured.

That same philosophy shows up again when Blow describes how The Witness’s puzzle language evolved. Early on, he focused on rules that could make puzzles; later, he planned for symbol combinations to create “curve balls,” where the meaning of a rule expands as the game progresses. He frames good game design as the careful construction of simple rules that yield emergent complexity—situations players can’t fully predict from the starting conditions. He then draws a comparison to mathematics and computation: fractals and cellular automata explode into complexity from simple equations, suggesting there’s an underlying “engine in the universe” that designers exploit without fully articulating. Blow wants to make a game that stares at that phenomenon, treating game mechanics like ingredients that can be combined into a larger, higher-dimensional system.

Order of the Sinking Star, as discussed through its development goals and trailer framing, is built around multiple “lands” that function like separate games at first—each with its own characters, stories, and mechanics—before later interactions fuse them into a composite experience. The design intent is to start with mechanics already “fun and complete,” then mash them together so their interactions create new rules and new surprises. Blow also links this to a broader critique of how game development converges: teams iterate until a complexity ceiling is reached, then ship. His approach tries to push beyond that ceiling by increasing the dimensionality of interactions.

The conversation then pivots to the practical side of building such systems: Blow’s decision to create a new programming language (Jai) rather than rely on C++. He points to compile times and the cognitive friction of working inside large, complex codebases as the real bottleneck—more than syntax errors or surface-level ergonomics. He criticizes C++’s “baggage” and its inability to deprecate features cleanly, arguing that legacy constraints slow down better ideas and force new features to interoperate with old ones. Jai’s development philosophy emphasizes the working programmer’s day-to-day experience, including fast full builds (about two seconds for a 300,000-line debug build) and avoiding incremental builds to reduce confusion.

Finally, Blow situates his long development timeline as a gradual, motivation-driven choice rather than a deliberate rejection of speed. He argues that newcomers should ship quickly to learn and calibrate, but that some “adults in the room” must still invest in improving quality rather than chasing generic output. His answers also extend to web development skepticism—warning that the modern web’s default interpreted model traded away tooling, debuggability, and strong type discipline for convenience—suggesting that the best path forward would recover those lost quality tools without losing the ease of deployment. The result is a coherent picture: Blow’s projects aim to make systems where rules, tooling, and iteration speed all serve the same goal—more meaningful surprise, not less.