Emergent Computing · research lab
We study how computation and intelligence emerge from simple dynamical systems, rather than from large, hand-designed architectures. Algorithms and models should be evolved, not designed. At most, a minimal core is designed and the rest is evolved. In nature, intelligence arose through evolution, from simple physical rules. Can the same happen in computation?
Our main work Emergent Models → Machine-learning models made of cellular automata and other simple dynamical systems.Our main work
An Emergent Model is a machine-learning model built from a simple dynamical system, such as a cellular automaton. Complex computation emerges from iterating a simple local function over a hidden state many times. The state itself decides when the computation stops: a halting function reads it at every step, so the number of steps adapts to the input (adaptive computation time).
EM43 is a particular instance, built from a one-dimensional cellular automaton with 4 cell states. The figure shows it computing 2x for x = 9.
s0 = p E(x)
The input is written into the initial state next to a learned pattern, the program p. In EM43, x is a red cell placed x cells right of the origin (green line).
st+1 = f(st)
A fixed local rule updates every cell from itself and its two neighbours, all cells at once. EM43's rule is a lookup table over the 64 possible neighbourhoods of a 4-state cell.
T = min{t : H(st) = 1}
The run stops at the first step where a condition on the whole state holds, so larger inputs can take more steps. EM43 stops when blue cells are at least half of the non-blank cells.
y = D(sT)
The output is read from the final state. In EM43, y is the distance of the rightmost red cell from the origin.
Training. In EM43, a genetic algorithm searches for the program, a finite portion of the initial state, and optionally the rule. Only the decoded output is scored; the dynamics in between are never supervised.
A feed-forward network has fixed depth: it does the same amount of computation for every input. Trained on sin x over [0, 4π], it fits the data and fails outside it (red). This is a limit of the architecture, not of training: fixed-depth networks with common activations cannot approximate functions such as ex or sin x on an unbounded domain, so they can only interpolate the training data (van Nuland, 2024). A recurrent model can instead learn a procedure that generates the function, and extrapolate over open ranges (blue). Under suitable conditions recurrent networks are Turing complete (Siegelmann and Sontag, 1995), so a model exists for every computable function on an unbounded domain.
Recurrence is therefore a basic requirement for models that must generalise over open ranges. An Emergent Model keeps iterating until a halting signal: variable-depth computation is its default mode.
EM43 learned x + 1, 2x, x mod 4, round(x/3) and x⋅(1 + x mod 2). We observed no error on any input tested: every x up to 1000, and sample inputs between 10 000 and 50 000. x mod 4 is a discrete sine: it repeats 0, 1, 2, 3 forever. x⋅(1 + x mod 2) is a discrete sine with growing amplitude. Like sin x above, neither can be represented by a fixed-depth feed-forward network on all of ℕ. The models that work show a regular space-time geometry that scales with the input instead of changing: below, the same x mod 4 model at three input sizes. The paper calls this geometric grokking. Two-input multiplication a⋅b was not learned.
x = 15 → 3 · in the training range
x = 47 → 3 · outside
x = 120 → 0 · outside
Conway's rule, fixed. Only the positions of two gliders are searched. Learns x + k exactly up to x = 200 after training on x ≤ 10, but random search does about as well as the genetic algorithm: similar programs have unrelated fitness.
The learned x + 2 program; input and output are 2×2 blocks on the diagonal.
A one-dimensional automaton with continuous-valued cells and a local update rule. It controls CartPole, balancing the pole for 735 ± 107 of 800 steps.
Glider-like signals that emerge in training and carry information through the automaton, which lets it control CartPole.
A two-dimensional grid with a local update rule. It controls an agent that forages food and avoids poison, and adapts online when food and poison swap roles.
Learned initial state: fast field c and slow memory field m. Outlined: input (black) and output (green) cells.
Theory. Some Emergent Models are latent-universal: with the rule, halting condition and interface fixed, every computable function is computed by some finite program. The solutions are guaranteed to exist in the search space; the theorem says nothing about how hard they are to find.
Research
Emergent Models are our main line of work, not the only one. More broadly we study how small rules, search and selection produce programs that generalise. Pinned posts describe each line; notes, hypotheses and results follow.
Framework, latent-universality theorem, and experiments on discrete and continuous substrates: EM43, Game of Life, CEM1D, CEM2D.
In progressLUTM-1, LUTM-6 and LU-A: small machines whose rule and interface never change. Only the program differs between tasks, and we measure how hard programs are to find.
In progressNeural cellular automata with one shared rule and a learned program per task. Builds on NCPU by Zhechev and Walas.
What looped and adaptive-time models have in common with Emergent Models, and four hypotheses we want to test.
Search on GPUs, cellular arithmetic, and the limit that locality puts on latency.
The claims, the evidence behind each, and the open problems.
Publications
Emergent Models: Machine Learning from Cellular Automata
Conference paper presenting Emergent Models and the EM43 results. International Conference on Artificial Life, Waterloo, Canada; session “The Distributed Maple Leaves”.
Emergent Computing@inproceedings{bocchese2026alife,
title = {Emergent Models: Machine Learning from Cellular Automata},
author = {Bocchese, Giacomo and Giacobbo, Nicola and Guichard, Etienne
and Wiles, James and Devireddy, Akshaj},
booktitle = {Proceedings of the Artificial Life Conference 2026 (ALIFE 2026)},
publisher = {MIT Press},
year = {2026},
doi = {10.1162/ISAL.a.953}
}Emergent Models: Intelligence from Tiny Substrates
Full framework; latent-universality theorem with proof sketch; experiments on EM43, Game of Life, continuous lattices (CEM1D, CEM2D) for arithmetic, CartPole and an adaptive foraging task; stated limitations. Summary on this site.
@misc{bocchese2026emergent,
title = {Emergent Models: Intelligence from Tiny Substrates},
author = {Bocchese, Giacomo and Giacobbo, Nicola and Guichard, Etienne
and Wiles, James and Devireddy, Akshaj},
year = {2026},
eprint = {2608.14019},
archivePrefix = {arXiv},
primaryClass = {cs.NE},
url = {https://arxiv.org/abs/2608.14019}
}This work is supported by the Wolfram Institute and by ResearchHub.
Code and demos
All code is public. Demos run in the browser.
1D, 4-state cellular automaton learning integer functions by evolutionary search.
codedemoConway's Game of Life with the rule fixed; only glider placements are searched. Arithmetic (x + k) and CartPole.
codearithmetic demoCartPole demoContinuous 1D lattice with three trainable coefficients controlling CartPole, with state retained between steps.
codedemoTwo-channel continuous field (activation and memory) adapting online to food and poison phases.
demoFixed one-tape Turing machine (150 states, 16 symbols) with a p#x interface; simulators in Python, NumPy and CUDA, an island GA and a program miner.
Two-tape machine with 9 states and 144 transitions; read-only program tape; resumable GA.
codeStep-through browser simulators for LUTM-6 and the ten-operation LU-A language, with checked programs for the same tasks on both.
codedemo1D neural cellular automaton: one rule, a learned program per task, seven string tasks. Builds on NCPU by Zhechev and Walas.
codedemo2D neural cellular automata with program tiles; single-task baselines; binary addition with single-cell inputs.
ncpu-em-2dncpu-computerncpu-simplifiedPeople
Founder · also Wolfram Institute
Machine-learning researcher. Emergent Models, latent-universal machines, evolutionary search.
Publications
Co-founder · research
Astrophysicist, postdoctoral researcher at the University of Padova. PhD on compact-object binaries and gravitational-wave sources; scientific software.
Publications
Affiliate researcher · Wolfram Institute
Emergent computation in simple programs, cellular-automaton-based AI, complexity measures; philosophy of mind.
Publications
Contact
For questions about the work, collaborations, or attempts to reproduce or refute our results.