The Game of Life, created by mathematician John Conway in 1970, is a zero-player game that simulates the evolution of cellular patterns on a grid through simple rules. Each cell in the grid is either alive or dead, and its state in the next generation depends solely on its neighbors. Despite its simplicity, the Game of Life reveals complex and often unpredictable behavior, showcasing how intricate structures and behaviors can emerge from basic rules. This simulation has fascinated scientists, programmers, and artists alike, as it illustrates fundamental principles of emergence, chaos, and self-organization. Before delving into its mathematical or computational implications, it's important to build an intuition for how patterns evolve, stabilize, or disappear—just by observing how local interactions shape global outcomes.

I'll start with the simulator, because a few minutes of watching patterns gives you the questions the rules then answer. After that, we look at the four rules and count neighbors by hand for one small pattern. The last section runs every preset in the dropdown to the end, so you can check what you saw against a computed result.

• Build Up Intuition
• How it works ?
• What does each preset pattern turn into ?

Build Up Intuition

Building up intuition is essential when exploring complex systems like the Game of Life because raw rules and formulas alone often fail to convey the deeper patterns and behaviors that emerge over time. Intuition serves as the mental scaffolding that allows us to anticipate outcomes, recognize structure, and form meaningful insights without relying on step-by-step analysis. We build this intuition not through memorization, but by interacting with the system—observing, experimenting, and reflecting on how small changes ripple through the whole. In the Game of Life, watching how simple initial patterns evolve into stable structures, oscillators, or chaotic growth helps us grasp core ideas like feedback, equilibrium, and nonlinearity. Through repeated observation and exploration, we begin to see not just what happens, but why it happens, enabling us to think more creatively and critically about dynamic systems in general.

NOTE : First Select a Predefined Pattern from 'Select Pattern' dropdown box  (e.g, Pick Proliferator) and Hit [Start] button. Check out the usage description below for further details.

Basic Controls

These five buttons decide when the grid changes and what it starts from. Start runs one generation per frame at the chosen speed, while Step lets you count neighbors yourself between generations. Note one detail of Clear: when a pattern is selected in the dropdown, Clear reloads that pattern instead of emptying the grid. Choose 'Select Pattern' first if you want an empty grid.

• Start/Pause: Toggle the simulation
• Step: Advance one generation at a time
• Clear: Reset the grid
• Add/Remove Mode: Toggle between adding and removing cells
• Random: Generate random initial state

Pattern Library

Each preset is placed at the centre of the grid, and loading it resets the generation counter to 0. Glider, Blinker, Block, Beacon and Glider Gun are classic named patterns. Proliferator is the five-cell pattern known as the R-pentomino, which keeps changing for hundreds of generations. The last section of this page lists what each preset finally turns into.

Select from pre-built patterns:

• Glider
• Blinker
• Block
• Beacon
• Glider Gun
• Proliferator
• Decayer

Grid Controls

The grid size changes the number of cells, not the canvas. So a larger grid draws smaller cells on the same 580 x 580 pixel canvas. When you shrink the grid, the cells beyond the new right and bottom edges are cut off. Grid Wrap matters more than it looks, because it changes the neighbor count of every cell on the border.

• Grid Size: Adjust the grid dimensions (20x20 to 100x100)
• Show Grid Lines: Toggle grid line visibility
• Grid Wrap: Enable/disable wrapping at grid edges

Simulation Settings

Speed only changes how fast you watch a run, and population size only sets how many cells the Random button adds. The mutation rate is different, because it changes the rules themselves. At any rate above 0%, the run is no longer Conway's Game of Life, so compare patterns at 0% first. The FPS value in the info panel is the measured frame rate, and it can fall below the speed you set.

• Speed: Adjust simulation speed (1-60 FPS)
• Population Size: Control initial random population (10-1000 cells)
• Mutation Rate: Introduce random variations (0-100%)
• At 0%: Standard Conway's Game of Life rules
• Higher rates: Increased chance of rule violations
• Affects both birth and survival rules

Creating Initial Patterns

At 0% mutation the rules contain no randomness, so the starting pattern decides everything that follows. You can draw cells by hand, load a preset, or scatter random cells. You can also combine the last two. Random first reloads the selected preset and then adds the chosen number of cells on empty positions around it.

• Click cells to add/remove them manually
• Use "Add Mode" button to toggle between adding and removing cells
• Select from preset patterns in the dropdown menu
• Click "Random" to generate a random pattern

Adjusting Simulation

Speed, grid lines and grid size do not change the rules. Grid wrap does change the result, because a cell on one edge then counts the cells on the opposite edge as neighbors. For example, the Glider Gun keeps firing on an open grid. With wrap on, its own gliders come back around and destroy it.

• Use the speed slider to control simulation rate
• Adjust grid size to change the playing field
• Toggle grid lines for better visibility
• Enable grid wrap for infinite-field simulation

Using Mutations

A mutation replaces the normal rule for one cell in one generation. Each cell is picked with a probability equal to the mutation rate. A picked live cell dies with probability 0.7, whatever its neighbors are. A picked dead cell with at least one live neighbor is born with probability 0.3. A dead cell with no live neighbors never mutates, so empty regions stay empty.

• Slide the mutation rate to introduce chaos
• Low rates (1-20%): Subtle variations
• Medium rates (20-50%): Noticeable changes
• High rates (50-100%): Significant rule breaking

How it works ?

The theory behind the Game of Life lies in its elegant set of rules governing the birth, survival, and death of cells on a grid, forming a type of cellular automaton. Each cell exists in one of two states—alive or dead—and its fate in the next generation is determined by the number of neighboring cells that are alive. With just four simple rules, complex and often unexpected patterns emerge over time, demonstrating how local interactions can give rise to global behavior. The Game of Life is not just a visual simulation but a theoretical framework for studying emergence, self-organization, and even computational universality. Despite having no input once it begins, the system can simulate logic gates and Turing-complete computation, making it a profound example of how complexity can arise from simplicity.

Here are the bulleted details about the theory of Game of Life:

• Type: It is a cellular automaton devised by mathematician John Conway in 1970.
• Grid Structure: The simulation occurs on a two-dimensional grid of square cells.
• Cell States: Each cell is in one of two states: alive or dead.
• Neighbor Rule: Each cell interacts with its eight neighbors (adjacent horizontally, vertically, and diagonally).
• Transition Rules:
• Underpopulation: A live cell with fewer than two live neighbors dies.
• Survival: A live cell with two or three live neighbors survives.
• Overpopulation: A live cell with more than three live neighbors dies.
• Reproduction: A dead cell with exactly three live neighbors becomes alive.
• No Player Control: Once started, the evolution is determined solely by its initial state and rules.
• Deterministic Evolution: The next state of the grid is fully determined by the current state.
• Emergent Behavior: Simple initial patterns can evolve into complex structures like oscillators, spaceships, and still lifes.
• Computational Universality: The Game of Life is Turing-complete, meaning it can simulate any computation given the right initial configuration.
• Applications: It is used in mathematics, computer science, philosophy, and systems theory to explore complexity, emergence, and self-organization.

Counting neighbors on a blinker

The rules are easy to read and easy to misapply, so let's count neighbors by hand once. Every cell looks at the eight cells around it, and all cells update together from the same old grid. A cell never sees a neighbor's new state in the same generation. The blinker is small enough to count by hand, and it shows three of the four rules at work.

The diagram below shows a horizontal blinker of three live cells in a 5 x 5 window. The left grid writes the live neighbor count into every cell. The right grid shows the next generation after the rules are applied.

Figure 1. One blinker step. The row of three becomes a column of three, and the next step turns it back, so the blinker has period 2.

• The centre cell has 2 live neighbors, so it survives.
• The two end cells have 1 live neighbor each, so they die from underpopulation.
• The dead cells directly above and below the centre have 3 live neighbors, so they are born.
• The dead cells above and below the end cells have only 2 live neighbors, so they stay dead. The rule for a dead cell asks for exactly 3.

These four rules are often written in a short code, B3/S23. B lists the neighbor counts that give birth, and S lists the counts that let a live cell survive. Other cellular automata change only these two lists. For example, B36/S23 is the rule known as HighLife. The code lets you compare rules without rewriting the whole list above.

• Every cell updates at the same time : the next grid is computed entirely from the current grid. That is why a hand count must use the old states only.
• Birth needs exactly three neighbors : two neighbors keep a live cell alive, but they never create one. Together with the overpopulation rule, this keeps a random start from filling the grid.
• The rule is local but the result is global : no cell sees more than one step around it, yet patterns such as the glider travel across the whole grid.

What does each preset pattern turn into ?

You have watched the presets move on the canvas. Now let's check where each one ends. A finite grid has a finite number of states, so every run must finally repeat a state it has already been in. After that point, it cycles forever. The only questions are when the cycle starts and how long it is.

The table below gives that answer for each preset on the default 50 x 50 grid at 0% mutation. The values come from running the same B3/S23 rule and the same centred placement as the simulator. The run stops when a grid state repeats. Period 1 means the pattern no longer changes.

Three results are worth a second look. First, the Decayer does not die out. It loses most of its 67 cells and then settles into small period-2 debris. Second, the Proliferator grows from 5 cells to well over 100 before it settles. On an unbounded grid the same R-pentomino takes 1103 generations to settle into 116 cells. The 50 x 50 grid ends it earlier, because its border removes cells that would otherwise keep interacting. Third, grid wrap changes the fate of the two moving patterns and of the Proliferator, and nothing else.

• Every run on a finite grid ends in a cycle : the grid has finitely many states, so a repeat is certain. The interesting part is the transient before it.
• Small start, long transient : the 5-cell Proliferator stays active longer than the 67-cell Decayer with either grid setting. The size of a start pattern does not predict how long it stays active.
• The boundary is part of the rule : grid size and grid wrap change the result for any pattern that reaches the edge. Compare runs only with the same grid settings.