A comprehensive guide to configuring cellular automata
A cellular automaton is a grid of cells where each cell can be in one of several states. Every generation, each cell looks at its neighbors and changes state according to rules you define.
The most famous example is Conway's Game of Life, but you can create infinitely many variations by changing the rules!
When you open the automaton settings, you'll configure:
Give your creation a unique name to identify it
Define what different conditions cells can be in (like Dead, Alive, Dying, etc.)
Define rules for when cells change from one state to another based on their neighbors
States are the different conditions a cell can be in. You need at least 2 states, but you can add as many as you want.
A descriptive name for this state (e.g., "Dead", "Alive", "Dying", "Growing", "Stable")
The color this state will display on the board. Choose contrasting colors for better visibility.
This is crucial: What state does this cell become if none of the specific transition patterns match?
Think of it as the "otherwise" rule. For example, if an alive cell doesn't match any survival patterns, it might die by default.
The specific neighborhood configurations that cause this cell to change to a different state. This is where the magic happens!
States are numbered starting from 0. The order matters because you'll reference these numbers in your transitions:
Every cell has exactly 8 neighbors surrounding it (like a 3×3 grid with the cell in the center):
The cell checks all 8 surrounding positions each generation
The automaton counts how many of these 8 neighbors are in each state, then uses that information to decide what happens next.
Patterns are the heart of your automaton. They tell cells when to change state based on their neighborhood.
A pattern is written as: pattern:targetState
Where pattern is a string of digits (one for each state) and targetState is the state number to transition to.
Example: 53:1
If this cell has 5 neighbors in state 0 and 3 neighbors in state 1, it becomes state 1
The pattern string has 2 positions (one for each state):
53Position 0 = 5 (five dead neighbors), Position 1 = 3 (three alive neighbors)
80Position 0 = 8 (eight dead neighbors), Position 1 = 0 (zero alive neighbors)
62Position 0 = 6 (six dead neighbors), Position 1 = 2 (two alive neighbors)
Note: The two digits must add up to 8 (total number of neighbors)
The pattern string has 3 positions (one for each state):
4224 dead neighbors, 2 alive neighbors, 2 dying neighbors
5305 dead neighbors, 3 alive neighbors, 0 dying neighbors
1611 dead neighbor, 6 alive neighbors, 1 dying neighbor
Note: The three digits must add up to 8
Sometimes you only care about the count of one specific state. Use * as a wildcard to mean "any number".
*3*Means: "I don't care about states 0 and 2, I only care that there are exactly 3 neighbors in state 1"
This matches: 530, 431, 332, 233, 134, 035
*2*Means: "exactly 2 neighbors in state 1, don't care about the rest"
This is especially useful in Brian's Brain where only alive neighbor count matters
2**Means: "exactly 2 neighbors in state 0, don't care about states 1 and 2"
Wildcards work in any position!
In the Transition Patterns field, write one pattern per line in the format pattern:targetState
Transition Patterns:
If a dead cell has exactly 5 dead neighbors and 3 alive neighbors, it becomes alive (state 1)
Default Transition:
If no patterns match, the cell stays dead
Transition Patterns:
An alive cell stays alive (state 1) if it has 2 or 3 alive neighbors
Default Transition:
If it has 0, 1, 4, 5, 6, 7, or 8 alive neighbors, it dies (becomes state 0)
This creates the classic Life behavior: birth with 3 neighbors, survival with 2-3 neighbors, death otherwise.
Let's walk through a complete 3-state automaton configuration that creates colorful, pulsing patterns.
Name: Dead
Color: #202020
Transition Patterns:
Dead cells with exactly 2 alive neighbors become alive
Default Transition:
Name: Alive
Color: #00FF00
Transition Patterns:
No specific patterns needed
Default Transition:
Alive cells always become dying in the next generation, no exceptions
Name: Dying
Color: #0000FF
Transition Patterns:
No specific patterns needed
Default Transition:
Dying cells always become dead in the next generation
Understanding how the automaton evaluates patterns is important when you have multiple rules.
The system first looks for exact pattern matches (like 53)
If no exact match is found, it checks wildcard patterns (like *3*) in the order you wrote them
If nothing matches, the default transition is used
Pro Tip:
Order your patterns from most specific to least specific. Put exact patterns first, then wildcards with fewer wildcards, then wildcards with more wildcards.
Begin with 2 states and a few simple rules. You can always add complexity later.
Example starter rules:
If birth is too easy, everything explodes. If death is too easy, everything dies immediately.
Too aggressive:
Birth with 1-6 neighbors → everything fills up instantly
Too restrictive:
Birth with exactly 8 neighbors → nothing ever happens
Just right:
Birth with 2-4 neighbors → interesting patterns emerge
The survival rules determine whether patterns are stable, oscillating, or chaotic.
Choose colors that help you understand what's happening:
Extra states can show where cells have been, creating trails and patterns:
2 states:
On/Off, present only
3 states:
Born → Alive → Dying (shows one generation of history)
4+ states:
Born → Young → Mature → Old → Dead (shows multiple generations)
If you have 3+ states but only care about one, wildcards save you from listing dozens of patterns.
Instead of:
530:1431:1332:1233:1134:1035:1Just write:
*3*:1After each change, run the simulation and observe:
Here are some interesting patterns to try in your automatons:
53:1Dead cells with 3 alive neighbors become alive. The foundation of Conway's Game of Life.
62:1
53:1Alive cells stay alive with 2-3 alive neighbors. Creates stable patterns and oscillators.
53:1
26:1Birth with 3 or 6 alive neighbors. Creates self-replicating patterns.
*2*:1Birth with exactly 2 alive neighbors (ignoring other states). Creates wave patterns.
62:1Birth with 2 neighbors, no survival rules. Creates explosive patterns that quickly die out.
*5*:1
*6*:1
*7*:1
*8*:1Cells adopt the majority state. Creates blob-like, smoothing patterns.
53:1
26:1
17:1
44:1Birth with 3,6,7,8 alive neighbors. Symmetrical rules create interesting dynamics.
44:1Birth only with 4 alive neighbors. Creates sparse, slowly evolving patterns.
Problem: Your survival rules are too strict or your default transitions kill cells.
Solution: Add more survival patterns, or check that your defaults aren't forcing everything to state 0.
Problem: Your birth rules are too lenient.
Solution: Require more specific neighbor counts for birth (like exactly 3 instead of 1-5).
Problem: Your rules create immediate stability.
Solution: Make survival conditions more specific, or add states that force cells through cycles.
Problem: Pattern format might be wrong, or you're confusing state indices.
Solution: Double-check that pattern positions match state indices (0, 1, 2, etc.), and verify the numbers add up to 8.
Problem: Wildcard length doesn't match the number of states.
Solution: Make sure your wildcard pattern has the same length as the number of states. For 3 states, use *2*, not *2.