What's the difference between the Game of Life rules B3/S23, B36/S23 and B2/S?

The notation lists birth counts before the slash and survival counts after it. B3/S23 (Conway): a dead cell with exactly 3 live neighbors is born, a live cell with 2 or 3 survives. B36/S23 (HighLife) adds birth on 6 neighbors, which enables a self-replicator. B2/S (Seeds) has no survival rule at all — every live cell dies each generation while pairs of neighbors give birth, producing constant explosive waves. You can type any combination 0–8 for each side.

Why is Rule 110 special?

Rule 110 is the elementary 1-D cellular automaton that Matthew Cook proved Turing-complete (2004): its left-moving periodic stripes act as gliders whose collisions can emulate any computation, given enough space and time. It's the simplest known system where determinism, chaos and universal computation coexist — which is why it anchors Wolfram's arguments in A New Kind of Science.

How does the Wireworld model work?

Four states: empty, conductor (copper), electron head and electron tail. Each step, heads become tails, tails become copper, and copper with exactly 1 or 2 neighboring heads becomes a head. That 'exactly 1 or 2' condition is what makes timed signals behave like logic gates — diodes, AND/OR gates and entire CPUs have been built in Wireworld.

What does the blue-to-red coloring mean?

It's a cell-age heatmap: newborn cells are bright blue, and cells that stay alive age through green and yellow to red. The rule itself still sees only alive/dead — the age is purely visual, tuned so long-lived structures (still lifes, oscillators) stand out from the churn.

What is a toroidal grid?

A grid whose edges wrap around: the right neighbor of the last column is the first column, and likewise top-to-bottom, forming a donut topology. It prevents gliders from dying at the walls, at the cost of patterns eventually interacting with their own wrap-around residue. Uncheck Toroidal for hard walls and out-of-bounds reads as dead.

Can I use patterns from LifeWiki?

Yes — copy any RLE block (the lines starting 'x = width, y = height, rule = ...') and paste it into the RLE box, then Import. The pattern loads centered on the grid, and if it carries a rule string it's applied for Life mode. Export works the same way in reverse: your current pattern is cropped to its bounding box and serialized as standard RLE.

How does GIF recording work?

Recording starts from the current state, steps the automaton for the chosen number of frames in the worker, encodes them into a looping GIF89a (encoded in the same palette the canvas uses), and downloads it. The simulation continues from the final recorded frame, so recording and playback compose naturally.

What do the code exports contain?

The JavaScript export is a runnable module: the grid as a boolean matrix plus a step() implementing the current Life rule. The C and Rust exports are static bit-packed matrices — each row as uint64_t/u64 words, MSB-first, with a cell() accessor — ready to drop into an engine or firmware. The exports always snapshot the grid as it currently stands.

Cellular Automata Studio

Six automaton models — Game of Life, Wireworld, Langton's Ant, Wolfram 1D, Brian's Brain and Star Wars — with age heatmaps, toroidal grids, RLE import/export, GIF recording and bit-packed code exports.

RuleToroidal (wrap edges)

Speed12/sgen 0 · pop 0

GridWidth80Height48Density28%

Click or drag on the grid to paint cells. Bright blue = newborn, aging cells shift orange→red.

Templates

GIF recordingFrames48

RLE import / export

About this tool

Cellular Automata Studio packs six classic models of emergence into one browser playground. Conway's Game of Life runs any outer-totalistic B.../S... rule you type — Conway's B3/S23, HighLife's B36/S23 with its replicator, the explosive Seeds B2/S, and symmetric Day & Night B3678/S34678. Wireworld models copper wires carrying electron heads and tails, the standard for visualizing logic gates built from a four-state rule. Langton's Ant supports arbitrary turn strings (RL, LRR, LLRR…) for multi-color turmites. Wolfram's 256 elementary automata include the famous Rule 30 (chaos from a single seed — Wolfram's PRNG), Rule 90 (Sierpinski triangles), Rule 110 (proven Turing-complete) and Rule 184 (traffic flow). Brian's Brain and Star Wars round out the three-state oscillators.

Every simulation is recorded as a live grid you can paint directly: click or drag to toggle cells, watch newborn cells glow bright blue and age through orange to red with the heatmap, and wrap the world into a torus or leave hard edges. Playback runs from 1 to 120 steps per second with single-step scrubbing, and the heavy stepping happens in a Web Worker so the page stays responsive even at 200×120.

The template library ships canonical LifeWiki patterns — glider, LWSS/MWSS/HWSS spaceships, blinker, toad, beacon, pulsar, pentadecathlon, R-pentomino, the 5,206-generation Acorn methuselah, the exactly-130-generation Diehard, and the Gosper glider gun that proves infinite growth. Wireworld templates include clock wires and signal splits.

Exchange patterns with the wider world through standard RLE (Run Length Encoded) text: paste any LifeWiki pattern and it loads at the center of your grid; export your current creation cropped to its bounding box. Record any run as an animated GIF (looping, palette-accurate to what you see) with a chosen frame count, and export the current grid as a JavaScript boolean matrix with a matching step function, or as MSB-first bit-packed uint64_t rows for C and Rust.

Everything is computed locally: no uploads, no accounts, no backend. The only network request your browser makes is loading the page itself.

How to use

Pick a model
Choose Game of Life, Wireworld, Langton's Ant, Wolfram 1D, Brian's Brain or Star Wars — each loads a sensible random start.
Set the rule
Type a B.../S... rule for Life (or pick a preset), a turn string for the ant, or a rule number 0–255 for Wolfram.
Run it
Press Play for continuous stepping at 1–120 steps per second, or Step to advance one generation and study the change.
Paint and stamp
Click-drag on the grid to draw cells by hand (Wireworld cycles conductor→head→tail), or stamp a template like the Gosper gun.
Import and export
Paste RLE from LifeWiki to load a pattern; export your grid as RLE, a looping GIF, or bit-packed C/Rust/JS code.

Use cases

Teaching emergence and complexity

Show chaos, self-organization and computation arising from uniform local rules — the exact progression Wolfram uses in A New Kind of Science.

Prototyping procedural generation

Cave-and-tunnel dungeon generators start from Life-like CAs; tune B/S rules on random noise here before writing engine code.

Studying logic from first principles

Wireworld's four states make AND/OR/XOR gates and diodes visible — students trace electrons instead of believing truth tables.

Sharing results

RLE round-trips with LifeWiki's pattern archive, and the GIF export turns any run into a looping artifact for docs, issues and slides.

Common mistakes

Mistake:Judging rules from one random seed

Fix:Chaotic rules like Rule 30 differ wildly by seed; rerun with several seeds before concluding anything about a rule's character.

Mistake:Forgetting the torus

Fix:On toroidal grids gliders wrap around and collide with the residue of your own pattern; uncheck Toroidal for bounded experiments.

Mistake:Reading the heatmap as a third state

Fix:Blue→red encodes cell age only; the rule sees binary alive/dead. For true multi-state models use Wireworld, Brain or Star Wars.

Mistake:Expecting bounded Langton's Ant to build the highway

Fix:The famous highway emerges on an effectively infinite plane; a bounded 5×5 grid traps the ant. Use toroidal or a large grid.

Frequently asked questions

Symmetry, Dithering and the Sprite Sheet: A Pixel Artist's Toolkit

Why PICO-8 has exactly 16 colors, how a Bayer matrix fakes a gradient with none, and what actually happens when you export a walk cycle to Pixi, Phaser or Godot.

Why Your Logic Circuit Needs a Clock: Discrete-Event Simulation, Explained

A truth table tells you the answer eventually — it can't tell you when. Propagation delay, tri-state conflicts and the priority-queue trick that makes a browser-based circuit simulator behave like real silicon.

Stable Fluids: Why Smoke Simulators Never Blow Up

Semi-Lagrangian advection, pressure projection and vorticity confinement — the three tricks from Jos Stam's 1999 paper that made real-time fluid simulation unconditionally stable, explained by playing with them.

One Pixel at a Time: Thinking in Fragment Shaders

Fragment shaders invert everything procedural programmers know: no objects, no loops over data — just one function evaluated half a million times per frame. The mental models that make GLSL finally click, from plasma to raymarching.

References & standards

Distributed Systems & Network Topology Simulator

Build a network topology from load balancers, API gateways, microservices, message queues, distributed databases and caches, then inject chaos — kill nodes, partition the network, packet loss, latency spikes, circuit breaker trips — and watch Raft leader election, split-brain and Hystrix-style breaker state react live. Export the topology as Docker Compose, Kubernetes manifests, Mermaid or PlantUML. Entirely client-side, educational simulation.

Typography Anatomy & Variable Font Lab

Load a TTF/OTF/WOFF/WOFF2 font and inspect glyph Bézier outlines, baseline/x-height/cap-height guides, kerning pairs, OpenType features and live variable-font axis sliders — export CSS @font-face, font-variation-settings and fallback metric overrides.

Pixel Art Sprite Studio

Draw retro pixel art on an 8x8 to 64x64 grid with pencil, flood-fill, ordered-dither and symmetry tools, curated PICO-8/Game Boy/NES/C64/Endesga-32 palettes, multi-layer compositing, and a frame timeline with onion skinning. Export static PNG, animated PNG, GIF, a sprite-sheet atlas (Pixi/Phaser/Godot/Unity JSON), or a CSS steps() animation snippet.

Digital Logic Gate & Circuit Simulator

Build digital circuits from AND/OR/NOT/NAND/NOR/XOR/XNOR gates, tri-state buffers, switches, clocks and 7-segment displays; wire flip-flops, latches and multiplexers into adders and counters. Runs an event-driven propagation-delay simulation with High-Z and driver-conflict detection, packages sub-circuits into reusable ICs, and exports a truth table, K-Map minimization, Verilog, VHDL, and a documented JSON+SVG schematic. Everything runs client-side; circuits never leave the browser.

2D Fluid Dynamics & Particle Physics Sandbox

A physics playground with two engines sharing one canvas. The fluid mode runs a real Eulerian Navier-Stokes solver — semi-Lagrangian advection, explicit diffusion, Jacobi pressure projection and vorticity confinement — that you paint with dye and velocity using mouse or touch. The particle mode is a damped Verlet N-body engine with gravity wells, Coulomb attractors and repulsors, spring links, wall restitution and elastic circle collisions. Particle counts adapt to the device (100k target on WebGL2 desktop, 2k-5k on CPU fallback), and every configuration exports as runnable code: a Matter.js world, a PixiJS ticker setup, or a standalone vanilla Canvas engine.

GLSL Shader Art & Visual FX Playground

A live GLSL fragment-shader laboratory running on WebGL2 with the full Shadertoy uniform set (iResolution, iTime, iTimeDelta, iFrame, iMouse, iChannel0..3). Write shaders with syntax highlighting and see them recompile on every keystroke, with compiler errors mapped back to your line numbers and highlighted in the editor, plus a live FPS counter. The gallery ships raymarched spheres, tori and a Mandelbulb fractal, Voronoi and FBM procedural noise, cyberpunk grids, plasma waves, a neon audio visualizer and matrix rain. Export any shader as Three.js ShaderMaterial code, a React Three Fiber component, a standalone single-file WebGL2 HTML page or plain GLSL — or record the canvas straight to WebM video. A Canvas2D plasma fallback keeps the tool usable where WebGL2 is unavailable.