Emergent Computing

Research lab · Emergent Models

Computation that emerges from simple rules

We build machine-learning models from simple dynamical systems such as cellular automata. One local rule is applied to a state, step after step; training searches for the initial state, the program, that makes the dynamics compute a task.

How it works Papers
model on the right
140 bits
trained on
x ≤ 30
exact on all inputs tested
x ≤ 1000
EM43 · live
activeinput / outputhaltingorigin

How it works

A model is a rule, a state and time

An Emergent Model computes by iteration. The four steps hold for the general framework; the second line of each shows how EM43, the model in the figure above, implements it.

Encode

The input is written into the state at a fixed place, next to a learned initial pattern: the program.

EM43: a red cell x positions right of the origin; a 10-cell program on the left.

Iterate

One local rule updates every cell from its neighbours, all cells at once, step after step. The rule is the same for every input.

EM43: a lookup table over 3-cell neighbourhoods with 4 values per cell.

Halt

The run stops when a condition on the whole state holds, so larger inputs can use more steps.

EM43: stop when blue cells are at least half of the non-blank cells.

Decode

The output is read from the final state by a fixed rule.

EM43: the distance of the rightmost red cell from the origin.

Training. A genetic algorithm searches over the program and, optionally, the rule. Only the decoded output is scored; the intermediate dynamics are never supervised. Any structure visible in the space-time diagram comes from minimising the output error alone. Full description →

Research

Five lines of work

Each line is marked by status: published, in progress, or hypothesis (stated, not yet tested). Every figure is computed in your browser from a real model.

Published

Emergent Models

The framework: a model is a state, a local update rule, a halting condition and a fixed input/output interface. With a latent-universality theorem and experiments on models of 20 to 300 parameters.

EM43 computing 70 mod 4. Trained on x ≤ 30.
In progress

Latent-universal machines

Small Turing machines whose rule and input/output interface never change: only the program on the tape differs between tasks. They make the theorem concrete and let us measure how hard programs are to find from examples.

LUTM-6 computing the parity of 1101001 with a 32-symbol program found by evolutionary search. Top: program-head position. Bottom: data tape over 1,429 steps, head in red.
In progress

Continuous and neural cellular automata

Real-valued media and neural-network update rules, aiming at one shared rule with a learned program per task. Current models generalise to longer inputs on some string tasks and fail on others.

CEM1D: the three-coefficient rule learned for CartPole in the paper. Values at the four input ports are rewritten every 30 steps. Red positive, blue negative.
Hypothesis

Reasoning models

Questions about iterated models in general, looped transformers included: does iteration cause extrapolation, is locality a separate inductive bias, and how does the ratio of parameters to computation time affect generalisation and trainability?

Steps until halting against input size for the five EM43 models. Computation time grows with the input, also beyond the training range.
Hypothesis

Parallel and analog substrates

Local rules map onto parallel and analog hardware. Which computations could such hardware perform, how fast, and where does locality set the limit?

Rule 30 from one live cell. No cell outside the dashed cone can be affected: information travels at most one cell per step.

Also: applied research, joint projects where small iterated models, program search or evolutionary optimisation fit the problem.

Result

A 140-bit model that extrapolates exactly

EM43 was trained on x mod 4 for x from 0 to 30 and is exact on every input tested up to 1000. The diagrams show the same learned rule at three input sizes: signals travel between the program and the input marker, and the pattern scales with x instead of changing. The paper calls this geometric grokking.

x = 15 → 3 · in the training range

x = 47 → 3 · outside

x = 120 → 0 · outside

Publications

Papers

  1. ALIFE 2026
    Proceedings, MIT Press
    Oral, 18 Aug 2026

    Emergent Models: Machine Learning from Cellular Automata

    Giacomo Bocchese, Nicola Giacobbo, Etienne Guichard, James Wiles, Akshaj Devireddy

    Conference paper presenting Emergent Models and the EM43 results. International Conference on Artificial Life, Waterloo, Canada; session “The Distributed Maple Leaves”.

    doi:10.1162/ISAL.a.953
    BibTeX 
    @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}
}
  2. arXiv 2608.14019
    cs.NE, Aug 2026
    Preprint, full version

    Emergent Models: Intelligence from Tiny Substrates

    Giacomo Bocchese, Nicola Giacobbo, Etienne Guichard, James Wiles, Akshaj Devireddy

    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.

    abstract pdf
    BibTeX 
    @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

Open code

All code is public. Demos run in the browser.

  • EM43

    1D, 4-state cellular automaton learning integer functions by evolutionary search.

    codedemo
  • GoL-EM

    Conway's Game of Life with the rule fixed; only glider placements are searched. Arithmetic (x + k) and CartPole.

    codearithmetic demoCartPole demo
  • CEM1D

    Continuous 1D lattice with three trainable coefficients controlling CartPole, with state retained between steps.

    codedemo
  • CEM2D · Meta-Life

    Two-channel continuous field (activation and memory) adapting online to food and poison phases.

    demo
  • LUTM-1

    Fixed 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.

    code
  • LUTM-6

    Two-tape machine with 9 states and 144 transitions; read-only program tape; resumable GA.

    code
  • LUTM-6 and LU-A simulators

    Step-through browser simulators for LUTM-6 and the ten-operation LU-A language, with checked programs for the same tasks on both.

    codedemo
  • NCPU-EM-1D

    1D neural cellular automaton: one rule, a learned program per task, seven string tasks. Builds on NCPU by Zhechev and Walas.

    codedemo
  • NCPU-EM-2D and variants

    2D neural cellular automata with program tiles; single-task baselines; binary addition with single-cell inputs.

    ncpu-em-2dncpu-computerncpu-simplified

Writing

Notes

All notes →

People

Who we are

Mattia Fioranzato

Mattia Fioranzato

Affiliate developer

Full-stack development.

    Contact

    Get in touch

    For questions about the work, collaborations, or attempts to reproduce or refute our results.

    info@emergentcomputing.org Discord Email updates GitHub