The Fascination of Conway's Game of Life: How Simple Rules Create Complexity

What Is Conway’s Game of Life?

In 1970, mathematician John Horton Conway devised a zero-player game that would go on to captivate programmers, scientists, and philosophers for decades. The Game of Life is a cellular automaton — a grid of cells, each either alive or dead, evolving through discrete time steps according to a tiny set of rules.

That’s it. No strategy. No input. Just four rules and a grid.

The Four Rules

The entire universe of the Game of Life is governed by these rules:

Underpopulation — Any live cell with fewer than two live neighbors dies.
Survival — Any live cell with two or three live neighbors lives on.
Overpopulation — Any live cell with more than three live neighbors dies.
Reproduction — Any dead cell with exactly three live neighbors becomes alive.

Read them again. They are trivially simple. A child could understand them. And yet, from these four lines, entire universes unfold.

Why It Fascinates Me

What draws me to the Game of Life isn’t the rules — it’s what emerges from them.

Emergence: The Magic of “More Is Different”

Emergence is the phenomenon where complex behavior arises from simple interactions. No single rule says “create a glider” or “build an oscillator” — yet these structures appear spontaneously. A glider is a five-cell pattern that walks diagonally across the grid, forever. Nobody programmed it to move. It just does, as a consequence of the rules.

This idea — that complexity doesn’t require complex foundations — is profound. It shows up everywhere:

Ant colonies — individual ants follow simple chemical signals, yet the colony builds elaborate nests, farms fungus, and wages wars.
Flocking birds — each bird follows three rules (separation, alignment, cohesion), and the flock moves as a mesmerizing, coordinated whole.
Neural networks — individual neurons fire or don’t, yet consciousness emerges from billions of these binary decisions.
Markets — individual buy/sell decisions aggregate into booms, crashes, and trends that no single participant intended.

The Game of Life is perhaps the purest distillation of this principle. Four rules. Infinite possibility.

Patterns That Shouldn’t Exist

Over the decades, enthusiasts have discovered an astonishing zoo of structures:

Still lifes — stable patterns that never change (blocks, beehives, loaves)
Oscillators — patterns that cycle through states (blinkers, pulsars, pentadecathlons)
Spaceships — patterns that translate across the grid (gliders, lightweight spaceships)
Glider guns — patterns that periodically emit gliders, producing an endless stream of moving objects
Methuselahs — tiny patterns that take hundreds of generations to stabilize, producing enormous, chaotic cascades from a handful of initial cells

The Gosper Glider Gun, discovered in 1970, was the first known pattern that grows without bound. It fires a new glider every 30 generations. Think about that: a fixed structure that manufactures mobile objects, entirely from four rules about counting neighbors.

Perhaps the most astonishing result: the Game of Life is Turing complete. You can build logic gates, memory, and — in theory — an entire computer inside the Game of Life. The simplest possible rules can simulate anything computable.

My Implementation

I couldn’t resist building my own version. My implementation is written in TypeScript with a canvas-based renderer and a cyberpunk-inspired aesthetic.

Architecture

The code separates concerns cleanly:

GameOfLife — the pure simulation engine. It knows nothing about rendering. It holds a 2D boolean grid and implements the rules:

nextGeneration(): void {
  const newGrid = this.createEmptyGrid();
  for (let row = 0; row < this.rows; row++) {
    for (let col = 0; col < this.cols; col++) {
      const neighbors = this.countNeighbors(row, col);
      const isAlive = this.grid[row][col];
      if (isAlive) {
        newGrid[row][col] = this.survivalRule.has(neighbors);
      } else {
        newGrid[row][col] = this.birthRule.has(neighbors);
      }
    }
  }
  this.grid = newGrid;
}

CanvasRenderer — handles all the visual output with glow effects and a neon color palette.
GameController — wires up the UI: buttons, speed control, grid resizing, keyboard shortcuts, and the animation loop.

Customizable Rules

One feature I particularly enjoy is rule customization. The classic Game of Life uses B3/S23 notation (Birth with 3 neighbors, Survival with 2 or 3). But the engine supports arbitrary rules, opening the door to entirely different cellular automata:

Rule Set	Notation	Behavior
Conway	B3/S23	The classic — rich, balanced dynamics
HighLife	B36/S23	Like Conway but with a self-replicating pattern
Day & Night	B3678/S34678	Symmetric — dead and alive behave identically
Seeds	B2/S—	Explosive, chaotic — every cell dies each turn
Diamoeba	B35678/S5678	Produces large, amoeba-like blobs

Same grid, same renderer — totally different universes, just by changing which numbers go into the birth and survival sets.

Try It Yourself

Below is a compact interactive demo. For the full experience with speed control, grid resizing, drag-to-resize edges, rule presets, keyboard shortcuts, and more — open the full version in a new tab.

Click or drag to draw cells, then hit Start to watch them evolve.

    Gen: 0  |  Pop: 0
  

    Click/drag to draw • Scroll to zoom
  

The Deeper Lesson

What fascinates me most about Conway’s Game of Life isn’t the pretty patterns — it’s the philosophical implication.

Our universe appears to run on relatively simple physical laws. Particles interact according to a handful of fundamental forces. Yet from those interactions emerge atoms, molecules, proteins, cells, organisms, brains, and consciousness. The Game of Life is a toy model of this exact phenomenon.

It makes you wonder: How much complexity is hiding inside the simple systems we overlook every day?

A few lines of code. Four rules about counting neighbors. And from that, an entire cosmos of structure, motion, and surprise. That’s why I keep coming back to it.

The full source code for my implementation is available on GitHub. Feel free to fork it, experiment with custom rules, or just watch gliders fly.