Conway's Game of Life — Cellular Automaton Simulator
Three simple rules — birth, survival, death — drive an entire universe. Place gliders, guns and oscillators to explore emergent complexity.
Controls
Simulation Speed15 fps
Cell Size10 px
Random Fill Density30%
Appearance
Preset Patterns
The Three Rules
Birth: Dead cell with exactly 3 live neighbors → becomes alive
Survival: Live cell with 2–3 live neighbors → stays alive
Death: All other cases → cell dies (overcrowding or isolation)
0
Generation
0
Live Cells
0.0%
Density
0
Peak Population
Click/drag to draw cells | Right-click to erase
What is Conway's Game of Life?
🧑🎓
So, this is a "game" with no players? What exactly is it simulating?
🎓
Basically, it's a simulation of a universe defined by a grid of cells. Each cell can be "alive" (on) or "dead" (off). The entire system evolves in steps, with the next state determined by three simple rules applied to every cell simultaneously. Try clicking on the grid above to draw some live cells and hit "Start" to see it evolve.
🧑🎓
Wait, really? Just three rules can create all those complex moving patterns? What are they?
🎓
Exactly! The rules are based on how many living neighbors a cell has. For a living cell: if it has 2 or 3 living neighbors, it survives to the next generation; otherwise, it dies from loneliness or overcrowding. For a dead cell: if it has exactly 3 living neighbors, a new cell is born there. That's it! Try using the "Random Fill" button with a low density to see these rules play out from a random start.
🧑🎓
Okay, but what's the point of the "Simulation Speed" and "Cell Size" sliders? They don't change the rules, right?
🎓
Right, the rules are fixed. Those controls are about how we *observe* the universe. A faster speed lets you see long-term evolution quickly. A larger cell size makes it easier to see small, intricate patterns like "gliders" move. Try slowing the speed right down and drawing a small 3x3 block of cells to watch the rule application in slow-motion detail.
Physical Model & Key Equations
The Game of Life is a deterministic cellular automaton. Its state is defined by a 2D grid. The transition from one discrete time step to the next is governed by a rule function applied to each cell, based on its current state and the sum of its eight neighboring cells' states.
$$s_{t+1}(x, y) = f( s_t(x, y), \, N_t(x, y) )$$
Where:
• $s_t(x, y)$ is the state of the cell at grid position (x, y) at time $t$ (1 for alive, 0 for dead).
• $N_t(x, y)$ is the sum of the states of the eight neighboring cells (the "Moore neighborhood").
• $f$ is the rule function defined by Conway's three laws.
The rule function $f$ can be written concisely as a condition:
$$
s_{t+1}=
\begin{cases}1 & \text{if }(s_t = 1 \text{ and }N_t \in \{2,3\}) \text{ or }(s_t = 0 \text{ and }N_t = 3) \\
0 & \text{otherwise}\end{cases}
$$
This mathematical formulation captures the essence of birth, survival, and death. Despite its simplicity, this local rule can generate non-local, emergent patterns and complex global behavior that is impossible to predict without running the simulation—a key concept in complex systems.
Real-World Applications
Complex Systems & Emergence Research: The Game of Life is a foundational model for studying how simple, local interactions can lead to complex global order, chaos, or computation. It's used to understand phenomena in biology (like cell colony growth), sociology (pattern formation in crowds), and physics (crystal growth).
Computational Theory: It has been proven to be Turing complete. This means that with the right initial configuration (like a "glider gun" and logic gates built from patterns), it can simulate any computer algorithm. It's a powerful demonstration of how computation can emerge from simple physical laws.
Algorithmic Art & Generative Design: Artists and designers use cellular automata like the Game of Life to create evolving, organic patterns for visual art, music, architecture, and texture generation. The unpredictable yet rule-bound evolution is a rich source of inspiration.
Parallel Computing Models: The update rule, where every cell's new state depends only on its local neighborhood, makes it a perfect model for studying and testing massively parallel computing architectures and synchronization algorithms.
Common Misconceptions and Points to Note
First, don't think of the Game of Life too literally as a "simulation of life." It is fundamentally an abstract model for experiencing the concepts of "emergence" and "self-organization." When you use it in practical work, missing this point can lead you to misunderstand its essence. Let me list three specific points to note.
1. The "Random Density" setting significantly changes the outcome: When generating a random initial state, you might think the default around 50% density is the most chaotic and interesting. However, if the density is too low (e.g., below 10%), almost everything dies out quickly, and if it's too high (e.g., above 80%), you tend to get static, overcrowded clumps. To see orderly dynamic patterns, the trick is to adjust it between 30% and 60%. You'll find similar parameter tuning is necessary in simulations like material microstructure generation.
2. Be mindful of boundary conditions: The grid in this simulator is finite—what happens at the edges? Most implementations use either a fixed boundary (where edges are treated as perpetually dead cells) or a periodic boundary (where opposite edges connect). A glider disappearing when it hits the edge is due to a fixed boundary. When you use cellular automata in practical work, these boundary condition settings directly impact the results, so get into the habit of checking them first.
3. Don't be misled by the word "Life": Even though a cell is "alive," it doesn't have energy or genes. It's simply a bit with a state of 1 or 0, and the rules are simple switches based on the count of neighboring bits. The very structure—"complex global behavior arising from simple local rules"—is what makes the essence of "discrete state updates on a mesh" in CAE so fascinating.
Related Engineering Fields
The "cellular automaton" concept behind the Game of Life is applied as a modeling technique for discrete phenomena in various engineering fields, including CAE. Let me explain with some specific technology names.
First, in materials engineering. A cellular automaton called the "Potts model" is used to simulate metal grain growth or phase transitions. Each cell represents a crystal orientation, and its state changes based on energy differences with neighboring cells. This is exactly the same process as the Game of Life: "the next state is determined by the surrounding states."
Next, in fluid engineering, the "Lattice Boltzmann Method (LBM)" is a prime example. It models the behavior of fluid molecules using a probabilistic cellular automaton and excels at calculating flow around complex shapes (e.g., inside filters or microchannels). The distribution function at each lattice point (cell) is updated by collision and advection rules, and the macroscopic flow "emerges"—a concept that aligns with the philosophy of the Game of Life.
Furthermore, it's also applied in urban engineering and evacuation simulations. Each pedestrian is treated as an agent on a cell, with local rules like "determining movement direction based on surrounding congestion." This naturally reproduces crowd flow and bottlenecks. The underlying idea is the same as patterns moving and colliding in the Game of Life.
For Further Learning
If you get hooked on the Game of Life, try expanding your thinking within the broader framework of "cellular automata." Starting with generalizing the rules is recommended. The Game of Life is one specific form: "2 states (alive/dead), 8-cell neighborhood, specific birth/survival rules." You can try increasing the number of states to three or more (multi-valued CA), changing the neighborhood shape (e.g., von Neumann neighborhood), or defining your own rule table. For example, if you create a simple rule with three states (0, 1, 2) where the next state is determined by your own state and the sum of your neighbors, you might generate waves or spiral patterns completely different from the Game of Life.
If you want to know the mathematical background, look into "Turing completeness." You'll discover the astonishing fact that specific initial configurations in the Game of Life (like glider guns) can construct logic gates (AND, OR, etc.) and even a computer CPU itself. This is an excellent case study showing how rich the expressive power of a simple dynamical system can be.
For a practical next step, try experimenting with cellular automaton modeling in existing CAE software or code. For instance, you could write your own simulator in a general-purpose programming language (easily done with `numpy` in Python) to mimic material structure generation. Alternatively, you could move into the related field of "Agent-Based Modeling (ABM)." Here, each agent has more complex internal states and rules, used for simulating market trends or ecosystems. The sense you develop in the Game of Life for "reading global behavior from local rules" will be immensely useful here too.