Universal computers that reach universality without sequential von-Neumann execution 2026-06-28 · for systems engineers who want to see the axis, not the zoo
A von-Neumann machine is one fetch-decode-execute loop walking a shared memory, one instruction at a time. Turing-completeness requires none of that. Many of these substrates are universal; the question worth asking is how they get there. A spatial rule that updates every cell at once, a chemical gradient that relaxes to an answer, a tub of water whose surface holds a state. Same destination, different road, and the road is what to study.
One sentence
Universality is a property of a system's reachable states, not of a program counter — cellular automata, chemical reaction networks, reservoirs, analog GPACs, cluster-state quantum, DNA strand displacement, and organoids all compute, and the sharpest cases have no sequential step at all: the substrate's physics is the evaluation.
The axis: how it gets universal, not whether
Group these by mechanism of universality and the menagerie collapses into a few shapes. Some encode a Turing machine in a static pattern that a uniform local rule then evolves (cellular automata). Some let a physical process relax toward a fixed point that is the answer (analog, chemical, quantum annealing). Some borrow universality from a high-dimensional dynamical substrate they never program directly, only read out (reservoirs). The departure from von Neumann is the coordinate that sorts them, not Boolean vs. continuous or silicon vs. wet.
Von Neumann's three commitments, and who drops them. (1) A single locus of control (program counter) — cellular automata, CRNs, reservoirs, and cluster-state quantum all drop it; update is global and simultaneous. (2) Separation of program and data in one addressable store — in-materio and organoid computing fuse them: the substrate's physical configuration is the program. (3) Sequential, deterministic stepping — analog GPACs and annealers replace it with continuous-time relaxation; reversible billiard-ball logic keeps determinism but discards irreversible erasure. Each family is defined by which commitment it abandons.
The seven families at a glance
Each row: the mechanism by which it computes, whether it is proven Turing-universal, the physical substrate, rough maturity, and the specific von-Neumann commitment it abandons.
computation in molecular populations / living tissue
Amorphous / collective
vast unreliable parts, no global addressing, local interaction
universal under the amorphous model (Abelson-Knight)
smart dust, particle swarms, mechanical linkages
theory + mechanical UTM demos
no identity, no clock, no fixed topology
1. Cellular automata & minimal formal systems
Mechanism. A grid of cells, each holding a small state, all updated simultaneously by the same local rule. No instruction pointer, no fetch. The "program" is the initial pattern; "execution" is letting the rule iterate.
Rule 110 — a one-dimensional, two-state, nearest-neighbor cellular automaton. Matthew Cook proved it Turing-complete (announced ~1998, published 2004, Complex Systems 15, PDF). The simplest known universal CA; computation rides on collisions between moving "glider" structures.
Conway's Game of Life — 2D, two-state, totalistic. Turing-complete; gliders, glider guns, and logic gates have been hand-built, and full Turing machines and even a Universal Constructor exist as patterns inside it.
Interaction combinators — Yves Lafont's graph-rewriting model (1997), universal with just three symbols (γ δ ε). Rewrites are local and confluent (strong confluence: any reduction order yields the same result), so they fire in parallel. This is the substrate under HVM2 / Bend (Higher Order Company): HVM2 is an interaction-combinator GPU evaluator written in Rust (using Symmetric Interaction Combinators, Mazza 2007), and Bend — "feels like Python, scales like CUDA" — compiles to it and runs on GPUs with no manual parallelization (github.com/HigherOrderCO/HVM2). The most commercially-alive esoteric model here — a universality landmark people actually ship code on.
Tag systems — Post's deletion/append string machines; 2-tag systems are universal and (via cyclic tag systems) were Cook's bridge for the Rule 110 proof.
Wang tiles — unit squares with colored edges that must match neighbors; Berger (1966) encoded any Turing machine so the plane tiles iff the TM never halts, making the Domino Problem undecidable and proving aperiodic tile sets exist. Computation is static: a valid tiling is a spacetime diagram of a TM run. The smallest known aperiodic set is 11 tiles over 4 colors (Jeandel & Rao, 2015, arXiv:1506.06492), proven minimal by exhaustive search. This is exactly the model DNA algorithmic self-assembly realizes physically.
Lambda calculus / SKI combinators — the formal opposite of a CPU: universality from pure substitution. SKI needs only two combinators (S and K). No state, no memory cell, no clock; just term rewriting.
The shared move: universality from uniform local rules over many sites, never a central controller. Lattice cells, graph nodes, or symbols on a tape — the controller is the rule itself, applied everywhere.
2. Chemical, membrane & slime computing
Mechanism. Concentrations are the state; reactions are the transitions. The medium relaxes toward an equilibrium or a wave pattern, and that physical relaxation is the computation. Everything happens everywhere at once.
Belousov-Zhabotinsky reaction-diffusion — chemical waves propagate, collide, and annihilate. Andrew Adamatzky and colleagues built logic gates, diodes, and image-processing in BZ media (e.g. Reaction-Diffusion Computers, Adamatzky et al.). Computation by traveling chemical fronts, not by stepping.
Chemical reaction networks (CRNs) — Soloveichik, Cook, Winfree & Bruck showed stochastic CRNs are Turing-universal (Computation with finite stochastic chemical reaction networks, Natural Computing 2008, 10.1007/s11047-008-9067-y). A program is a set of reactions; the molecular counts evolve it. Soloveichik-Seelig-Winfree later showed DNA strand displacement can implement any CRN (PNAS 2010).
P-systems (membrane computing) — Gheorghe Păun's model: objects inside nested membranes, transformed by rules applied with maximal parallelism (every applicable rule fires every step). Many variants are Turing-universal; the parallelism is the whole point.
Physarum polycephalum (slime mould) — a single-celled organism that solves shortest-path and network-design problems by growing and pruning protoplasmic tubes. Adamatzky used it to approximate the Tokyo rail network and to build logic gates. Computation as collective foraging.
3. Reservoir & in-materio computing
Mechanism. Take a fixed, high-dimensional, nonlinear dynamical system you do not program. Drive it with input; it smears that input across many internal degrees of freedom. Train only a linear readout on top. The substrate computes for free; you learn to read it.
Echo state networks (Herbert Jaeger, 2001) and liquid state machines (Wolfgang Maass, 2002) are the founding reservoir-computing frameworks: a random recurrent "reservoir" plus a trained linear output. Universal-approximation results cover the class.
Bucket of water — Fernando & Sojakka's literal demonstration: project sound onto a tank of water, film the ripple interference, train a readout on the video. The water is the liquid state machine (Pattern Recognition in a Bucket, ECAL 2003).
Thompson's evolved FPGA — Adrian Thompson used a genetic algorithm to evolve an FPGA tone discriminator that worked using only ~32 cells and exploited analog physics (parasitic capacitance, cross-coupling) the designer never intended — some active cells weren't even wired into the output path (An evolved circuit, intrinsic in silicon, entwined with physics, 1996). In-materio computing: the matter, not the abstraction, does the work.
Memristor crossbars — resistive-memory grids that perform analog vector-matrix multiply in O(1) by physics (Ohm + Kirchhoff). The dominant in-materio substrate today; the basis for many analog-AI accelerators.
Reservoir computing abandons von Neumann's program/data split: there is no program inside the substrate. Its own dynamics are the computation; the only thing you store and train is the readout matrix outside it.
4. Analog & reversible computing
Mechanism. Two different escapes from the discrete clock. Analog: compute over continuous quantities in continuous time. Reversible: keep discrete logic but make every step invertible, so no information (and ideally no energy) is destroyed.
GPAC (General Purpose Analog Computer) — Claude Shannon's 1941 model of Vannevar Bush's differential analyzer: integrators, adders, multipliers wired into a network of differential equations. Bournez, Graça & Pouly proved the GPAC computes exactly the computable real functions, with the same power as Turing machines over the reals (Polynomial differential equations compute all real computable functions, J. Complexity 2007; arXiv:1601.05360). Universality with no clock and no discrete state.
Billiard-ball model / reversible logic — Fredkin & Toffoli (1982) showed elastic collisions of idealized balls can implement universal logic with zero information loss. The Toffoli (controlled-controlled-NOT) and Fredkin (controlled-swap) gates are reversible and universal; they underpin quantum circuits, where every gate must be unitary hence reversible. The departure: von Neumann machines erase bits (and pay Landauer's kT·ln2 per erasure); reversible logic erases nothing.
5. Quantum & optical computing
Mechanism. Universality from superposition, entanglement, and either gate-based or measurement-driven evolution — or from physically searching for an energy minimum.
Measurement-based / cluster-state quantum computing — Raussendorf & Briegel's "one-way quantum computer" (Phys. Rev. Lett. 86, 5188, 2001, DOI). Prepare a large entangled cluster state once, then compute by a sequence of single-qubit measurements; the choice and order of measurements is the program. Universal, and far from von Neumann: the entanglement resource is consumed rather than iterated, and measurement — usually the end of a computation — is the computation. The leading model for photonic quantum hardware.
Adiabatic / annealing — encode the answer as the ground state of a Hamiltonian, then evolve slowly so the system stays in its lowest energy state. Adiabatic quantum computation is polynomially equivalent to the gate model. Quantum annealers (D-Wave) are the commercial, non-universal cousin aimed at optimization. D-Wave's Beyond-Classical Computation in Quantum Simulation (Science, March 2025) claimed a quantum advantage on a useful magnetic-materials simulation — minutes versus a headline ~1 million years on the Frontier supercomputer. Read it with a caveat on both sides: it's a simulation task, not general computation, and the advantage is contested by classical/EPFL follow-up algorithms that reproduce the result far faster. Annealers optimize a QUBO/Ising class — they are not Turing-universal general computers.
Ising machines — physical (optical, electronic, or quantum) systems that relax to the minimum of an Ising energy. They solve QUBO/Ising problems by letting hardware settle, not by stepping an algorithm. Coherent Ising machines (optical parametric oscillators), Toshiba's simulated-bifurcation SQBM+, and quantum annealers all live here. The substrate finds the answer by minimizing energy. (For the builder angle on a software Ising solver, see the pointer below.)
6. Molecular & wetware computing
Mechanism. Computation carried by molecular populations or living tissue rather than fabricated devices.
DNA strand displacement — Lulu Qian & Erik Winfree built scalable digital logic circuits from DNA (Scaling up digital circuit computation with DNA strand displacement cascades, Science 332, 2011, DOI), including a 4-bit square-root circuit and later a DNA neural network. Toehold-mediated displacement is the transistor; cascades of strands are the gates. Massively parallel in a test tube.
DNA computing (brute force) — Leonard Adleman's 1994 founding experiment solved a 7-node Hamiltonian-path instance by encoding paths in DNA and letting the molecules anneal in parallel, then filtering (Molecular computation of solutions to combinatorial problems, Science 266, DOI). Solution by massive molecular parallelism, not by stepping.
Organoid / neural wetware — Cortical Labs' DishBrain embedded ~800,000 human and mouse cortical neurons on a multi-electrode array into a simulated Pong world; cultures showed learning within ~5 minutes of gameplay (Kagan et al., Neuron, Dec 2022, S0896-6273(22)00806-6). Cortical Labs has since shipped CL1, a commercial biological-neuron compute unit. Living neurons as the substrate; "programming" is closed-loop stimulation and reward.
7. Amorphous, collective & mechanical computing
Mechanism. Compute with a huge number of unreliable, identical, unaddressed parts that interact only locally — no global clock, no naming, no fixed wiring — or, at the other extreme, with purely mechanical linkages.
Amorphous computing — Abelson, Knight, Sussman et al. (MIT, late 1990s) asked how to get coherent behavior from "myriad unreliable parts interconnected in unknown, irregular, time-varying ways" (Amorphous Computing, MIT AI Memo 1665 / CACM 2000). The model gives up identity and topology and still achieves robust universal computation through local rules and gradients — the conceptual ancestor of smart-dust and programmable-matter visions.
Mechanical universal machines — Turing-completeness needs no electricity. Universal Turing machines and logic have been built from gears, dominoes, marble runs, Lego, and water valves. The point each makes: universality is about the structure of state transitions, not the medium — a sufficiently rich mechanical linkage is as universal as any chip.
The genuinely non-sequential paradigms
Several families above still hide a sequential loop in practice: you simulate a CA one tick at a time on a CPU, you step a strand-displacement reaction against a clock in your model. The families where non-sequentiality is intrinsic — no defensible "step" because update is physically simultaneous — are the ones that escape von Neumann:
Truly simultaneous (no step exists)
Reaction-diffusion / BZ & CRNs: every molecule reacts in continuous time; there is no global tick.
Reservoir / in-materio: the substrate's physics evolves continuously; you only sample a readout.
Analog GPAC: all integrators evolve at once in continuous time; discretizing is an approximation, not the machine.
Cluster-state quantum: entanglement is global; measurement order is a partial order, not a sequence.
Parallel-by-construction (step is a choice)
Cellular automata: the rule is defined over all cells at once; serial simulation is an implementation detail.
Interaction combinators / P-systems: all applicable rewrites/rules fire together (confluence, maximal parallelism); HVM2 exploits exactly this on GPUs.
DNA / molecular: astronomically many strands react concurrently; Adleman's win was the parallelism.
Amorphous: no shared clock to sequence against in the first place.
The cut that matters. A von-Neumann CPU is a sequential machine pretending to be general. These paradigms are general machines forced to look sequential when you simulate them on a CPU. Analog, reaction-diffusion, reservoir, and cluster-state have no honest notion of "the next instruction" at all. Not a faster von-Neumann machine: a different shape of universality.
For a builder
This page maps universality; it is not a project list. Most of these substrates are research artifacts, not solo-buildable systems — you do not ship a BZ reaction or an organoid as a weekend Rust crate. One family has a concrete, standalone software target: the Ising / annealing corner. A fast QUBO/Ising solver is real systems work (SIMD sparse matrix-vector inner loop, simulated bifurcation) with paying users in quant and DeFi.
For the build wager — the Rust QUBO/Ising solver and the rest of the standalone-artifact shortlist — see the sibling brief: