0 1 local left-center-right map -> new state

000->0

001->1

010->1

011->1

100->1

101->1

110->1

111->0

Continue simulating

adds generations past the last row, without restarting from the initial row

View: convert field to patterns

The field is cut into square M×M chunks. Each chunk becomes one pixel: identical patterns get the same unique color. Below is a legend showing which pattern corresponds to which color.

chunk size M

Render: export a large image

Renders the current rule off-screen at a chosen size and gives you a ready PNG to download. The PNG is encoded directly (no canvas), so it is not bound by the browser's canvas size limit — very large fields, e.g. 10000×10000, work as long as there is enough memory. Switch the scale to "cells per pixel" to shrink a big field into a small image. The interactive diagram above is left untouched.

width (cells) height (generations)

pixels per cell

output image: 2000×2000 px (4.0 Mpx)

Rule Controls

States

Rule

Neighborhood

Previous rows

Local rule code (0-255)

126

Local rule: 8 digits from 0 to 1 in order 000..111

8/8 positions filled

Initial Conditions

Start

Generation height

220 rows

Generation width

401 cells per row

Noise probability (against the rule)

the rule is applied with no random deviations

About this simulator

An interactive explorer for one-dimensional cellular automata. Define a rule, run it, and study the resulting space-time diagram — or let the app scan thousands of rules automatically and tag the interesting ones.

What you can do

Run automata with an arbitrary number of cell states (2–36), a neighborhood of 3, 5 or 7 cells, and a temporal depth of up to 8 previous rows.
Define rules in several ways: totalistic (keyed by the sum of the neighbors), by templates (a full local transition table, editable as JSON, including stochastic entries), by descendants (each live cell emits children that collide by a chosen rule), or by generating a random rule.
Start from a single live cell, random noise of a given density, or a custom row.
Render the space-time diagram on canvas, continue an existing run for extra generations, reduce the field to a pattern map, and export very large diagrams directly to PNG.
Generate rules that conserve the number of cells of a chosen “particle” state, derived statically from the rule table.

Automated rule analysis

Each analysis scans a code range, a random sample of rules, or a set of already tagged rules, and attaches a tag to every match:

Classification — dead, fixed, periodic, stable, chaotic, complex.
Fields — a repeating, possibly drifting pattern covering most of the diagram.
Gliders — localized structures that reappear shifted sideways.
Custom search — user-drawn templates with wildcards and equality variables.
Absence of lines — full-height vertical or diagonal solid streaks.
Chaos and Chaos 2 — dominant-pattern share and pattern diversity.
All states present — every state still occurs late in the run.
Sub-analysis — an extra pass detecting large surviving structures.

About cellular automata

A one-dimensional cellular automaton is a row of cells that all update at the same time according to one local rule applied to each cell's neighborhood. Stacking every generation under the previous one produces a space-time diagram. Despite the simplicity of the rules, these systems produce the full range of behavior — from an immediately dead field to periodic structures, chaos and computationally universal patterns such as elementary rule 110.

Source code: github.com/Kypaku/ca2026

JavaScript is required to run the simulator itself: the diagram is drawn on an HTML5 canvas in your browser.

Cellular Automaton Simulator

One-dimensional cellular automaton simulator with a configurable number of states, totalistic and local rules