A Cellular-Automaton Model of Computation
February 14, 2019

A cellular automaton becomes a serious programming substrate when code maps directly onto local cells, state, authority, and interaction. This model combined six mature ideas on a spatial lattice so programmers could build computation in the medium itself instead of reconstructing it indirectly from moving patterns.

Program the Cells Directly

Conway-style glider chains demonstrate that local rules can support universal computation. They make programmers express ordinary logic through long, position-sensitive collisions. This model gives cells explicit computational roles instead: a cell can hold state, receive authority, react to neighbors, and participate in a larger composed object.

The shift replaces position-sensitive gate simulation with explicit local ownership and direct interaction among neighboring entities.

Six Ideas Form the Programming Model

Actor model
Each entity owns local state and interacts through explicit messages.
Object capabilities
Possession of a reference grants specific authority between parts.
Membranes
Spatial containers hold state and regulate exchange with neighboring regions.
Reactive programming
Changes propagate through local dependencies as the lattice evolves.
Interaction nets
Local graph rewrites express composition without a central scheduler.
Finite automata
Explicit state transitions give every cell an executable local rule.

Geometry Turns the Model Into Claytronics

The 2019 implementation used a hexagonal lattice. The intended three-dimensional design followed cuboctahedral symmetry and the kissing-number geometry of equal neighbors around one cell. That geometry gives the future catom a repeatable set of local relationships.

A catom that can compute locally, exchange authority, and join spatial structures creates a route toward programmable locomotion, damage recovery, and products that change physical form. Repeated cells supply scale; direct local programming supplies control.

Continue Into the Working Lineage

The cellular-automata collection preserves the browser machines that explored these local rules and led toward Cartilage.

Originally posted on LinkedIn

Brian Greenforest · (2019-02-14 19:52:54 UTC)

Open the original LinkedIn post · LinkedIn activity 6501900903703027712

LinkedIn status when archived: Visible to anyone on or off LinkedIn.

Please, join me on the next meetup about the new Model of Computation I have invented. We are doing a very active research on it right now. The concepts of #ActorModel, #ObjectCapabilities, #MembraneComputing, #FunctionalReactiveProgramming, #InteractionNets, #FiniteStateAutomaton were put at the foundation of the model to intentionally design a 3D #CellularAutomaton allowing TO WRITE CODE IN IT DIRECTLY, rather than playing with toy #gliders of Conway's #GameOfLife wich makes way too fragile #LogicGates and #TuringMachines making the latter completely impractical for conventional programming. My experimental lattice right now is hexagonal, but the intended design has #Cuboctahedron symmetry, perfectly matching #KissingNumber in #3D. The main objective is not just to achieve #Parallel #Computing and unbounded physical interface-free #Scalability (which already seems to be achievable in our model, it possibly can disrupt data centers and supercomputing industry in foreseeable future), but to create the #Catom —an elementary building block of #Claytronics. We are researching programmable #Locomotion, #DamageRecovery, and are going to build completely new classes of products with unexpected impacts of many consumer markets. https://lnkd.in/gCGiauk

Comments added by Brian Greenforest on LinkedIn

This comment was also preserved verbatim from Brian Greenforest’s LinkedIn data export or the public post page. The image attached to this comment is localized below.