Lu Wilson (spiralganglion) has been building a series of strange, self-referential programming tools for a while now. Cellpond is one of the more ambitious ones: a spatial programming environment where computation happens through cellular automata rules, and where the environment itself tries to be the whole story.
The subtitle, “without escape”, is the interesting part. Most programming tools are porous. You write code in an editor, run it in a terminal, debug it with a separate tool, deploy it somewhere else. Each step involves crossing a boundary. Cellpond’s goal is to collapse those boundaries: the place where you define rules is the same place where those rules execute, and there’s no external runtime you’re compiling down to.
Cellular automata are a natural fit for this kind of thinking. Conway’s Game of Life is the obvious reference point, but the key insight behind spatial programming is that you can express non-trivial computation just by placing cells with the right rules next to each other. The space itself carries state. There’s no hidden call stack, no invisible memory you can’t see. What you see is what’s running.
What makes Cellpond specifically interesting, beyond the cellular automata substrate, is the attention to the editing experience within that constraint. Wilson’s tools tend to prioritize legibility of the system to itself. You’re not writing rules in a separate syntax that gets interpreted, you’re constructing them spatially, in the same medium as your output. This is a direct descendant of ideas from Smalltalk and Self, where the image is the program, but taken in a more visual and constrained direction.
The “without escape” framing cuts both ways. The constraint is what makes the system coherent, but it’s also what limits it. When everything has to live inside the system, you can’t reach for a library, can’t pipe output to another tool, can’t leverage decades of infrastructure that exists outside. This is a real tradeoff, and Wilson seems aware of it. These tools are exploration environments, not production platforms, and that’s a legitimate and underexplored category.
I find myself thinking about this in the context of building Discord bots, where the opposite problem exists: the system is maximally porous, everything talks to everything through HTTP and webhooks, and keeping track of state is a constant negotiation across boundaries. A world where the computation and its representation occupy the same space sounds appealing, even if it means giving up the composability that makes distributed systems tractable.
Spatial programming in this sense is less about the grid and more about locality. Rules, state, and behavior all coexist in the same visible region. That’s a strong property. Whether it scales to programs of meaningful complexity is an open question, but it’s the right question to be asking, and Cellpond is a serious attempt to probe it.