Conway’s Game of Life: Simulating a binary life form in SFML

This semester I was tasked in my Design and Analysis of Algorithms course to convert an algorithm into a game. And we chose Conway’s Game of Life because it perfectly demonstrates how simple rules can create complex, emergent behavior—a fundamental concept in algorithm design. What started as a classroom assignment evolved into a full-featured interactive experience that explores cellular automaton through three distinct gameplay modes.

Conway’s Game of Life isn’t really a “game” in the traditional sense. There are no winners, no opponents, and no levels to beat. Created by mathematician John Horton Conway in 1970, it’s a zero-player game where an initial configuration of cells evolves based on four elegant rules. Yet within this simplicity lies infinite complexity: patterns that oscillate, glide across the grid, or remain perfectly still. It’s mesmerizing to watch, educational to study, and endlessly fascinating to experiment with.

Check out the code at: https://github.com/thehamzaihsan/game-of-life

The Challenge: Making Zero-Player Engaging

The biggest challenge wasn’t implementing the algorithm—that’s straightforward. The real question was: how do you make a zero-player game engaging? How do you transform a mathematical curiosity into something interactive and fun?

My solution was to create three distinct modes, each offering a different way to experience the Game of Life:

1. Levels Mode: Goal-Oriented Gameplay

I designed five progressively challenging levels where players must place a specific number of living cells to achieve a target population after 10 seconds. Level 1 asks you to place 10 cells and reach 15 living cells. By Level 5, you’re placing 30 cells trying to reach 35.

This mode transforms the Game of Life into a puzzle. You’re not just watching patterns—you’re architecting them. Will you create stable “block” patterns that preserve your cell count? Or design “gliders” that march across the grid, potentially spawning new life? The 10-second timer adds urgency, and the real-time statistics keep you engaged as your creation evolves.

2. Randomize Mode: Chaos and Discovery

Sometimes you just want to watch the world burn—or in this case, watch random patterns emerge and collapse. Randomize mode starts with a randomly populated grid and lets it run. The beauty here is in the unpredictability. Random configurations often create surprising patterns: oscillators appear from nowhere, gliders emerge from chaos, and stable structures crystallize from disorder.

What makes this mode special is that it remains interactive. Even as the simulation runs, you can click to add or remove cells, injecting new chaos into the system. It’s like being a deity with the power to nudge evolution in real-time.

3. Creative Mode: The Pattern Laboratory

This is where the Game of Life becomes an art form. Creative mode gives you a blank canvas to design patterns without time pressure. The simulation doesn’t start until you press spacebar, giving you time to carefully place each cell.

The killer feature here is the visual feedback system. Cells that form “still life” patterns—configurations that never change—turn red. Living cells glow green. This immediate feedback helps you understand the rules intuitively. You can experiment with classic patterns like blinkers, beacons, and toads, or invent your own designs.

Technical Implementation: Bringing Cells to Life

The Core Algorithm

At the heart of the project is the GOL class, which manages the cellular automaton. The grid is a 30×30 array of “blocks,” each tracking whether it’s alive or dead. Every update cycle, the algorithm counts neighbors for each cell and applies Conway’s four rules:

1. Underpopulation: Cells with fewer than 2 neighbors die
2. Survival: Cells with 2-3 neighbors survive
3. Overpopulation: Cells with more than 3 neighbors die
4. Reproduction: Dead cells with exactly 3 neighbors come alive

The neighbor-counting algorithm uses directional arrays to check all eight adjacent cells efficiently—a classic O(1) operation per cell, making the full update O(n²) where n is the grid dimension.

Interestingly, I also implemented a deliberately inefficient O(n⁴) “slow update” method for educational comparison. It’s a reminder that algorithm complexity matters, even in a simple grid-based simulation.

The Visual Experience

I chose SFML (Simple and Fast Multimedia Library) for graphics because it provides low-level control while remaining beginner-friendly. Each cell is rendered as a colored square, with colors changing based on state and mode:

• Green: Living cells in creative mode
• Blue: Living cells in randomize mode
• Red: Still life patterns (stable configurations)
• Black: Dead cells

TGUI handles the user interface—buttons, labels, and text rendering. The start screen features an animated Game of Life simulation in the background, immediately showing players what they’re about to experience.

Audio Feedback

Sound effects add satisfying tactile feedback. When you click to place a cell, you hear a subtle “birth” sound. Remove a cell, and you hear a “death” sound. These audio cues make the interaction feel more tangible, transforming abstract cellular automaton into something that feels alive.

Design Decisions and Trade-offs

Grid Size: Finding the Sweet Spot

I settled on a 30×30 grid after experimentation. Smaller grids felt limiting—patterns couldn’t fully develop before hitting boundaries. Larger grids made individual cells too small to interact with comfortably. 30×30 provides 900 cells—enough space for complex patterns while keeping each cell large enough to click precisely.

Update Rate: Balancing Speed and Observation

The simulation updates every 100 milliseconds (10 FPS). This feels natural for observation—fast enough to see evolution happen, slow enough to track individual changes. Faster rates make patterns blur together; slower rates feel sluggish.

Click Debouncing: Preventing Accidents

Early versions suffered from accidental double-clicks. A single click would sometimes register as two rapid clicks, toggling a cell on then immediately off. I added a 300-500ms debounce delay, eliminating this frustration while keeping interaction responsive.

Color Coding: Visual Communication

Different modes use different color schemes to communicate state. In creative mode, red still-life detection helps players understand stability intuitively. In randomize mode, blue distinguishes it visually from other modes. These aren’t arbitrary aesthetic choices—they’re functional design decisions that make the game more intuitive.

Patterns Worth Exploring

If you’re new to Conway’s Game of Life, here are some classic patterns to try:

Blinker: Place three cells in a horizontal or vertical line. They’ll oscillate between horizontal and vertical forever.

Block: A 2×2 square of cells. This is a still life—it never changes.

Glider: A five-cell pattern that moves diagonally across the grid. It’s the simplest spaceship pattern.

Toad: Two rows of three cells, offset by one position. This oscillates with a period of two.

Beacon: Two 2×2 blocks touching diagonally. Another period-2 oscillator.

Each pattern demonstrates different aspects of the Game of Life’s emergent complexity. Experiment with placing them near each other—interactions between patterns can create surprising results.

What I Learned

Algorithms Are Everywhere

The Game of Life seems simple—just four rules. But implementing it required thinking about data structures (2D arrays), optimization (efficient neighbor counting), and state management (tracking changes across generations). These are fundamental algorithmic concepts that apply far beyond cellular automaton.

User Experience Matters

Making something “work” and making it “feel good” are different challenges. The technical implementation was straightforward, but the refinement—adding sound effects, color coding, debouncing clicks, designing engaging modes—took longer than writing the core algorithm.

Emergent Complexity Is Beautiful

Watching patterns emerge from randomness never gets old. The Game of Life demonstrates how complexity arises from simplicity, how order emerges from chaos, and how small changes can cascade into dramatic differences. These are lessons that extend beyond code into philosophy and science.

Building and Running

The project runs on Linux and requires SFML 3.1 and TGUI 1.9.0. I included an installation script that handles dependencies:

./install.sh

Then compile and run:

g++ -std=c++17 main.cpp -o game \
    -I./SFML/include -I./TGUI/include \
    -L./SFML/build/lib -L./TGUI/lib \
    -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio \
    -ltgui -lpthread

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./SFML/build/lib:./TGUI/lib && ./game

The full source code is available in the project repository, complete with detailed comments explaining the implementation.

Future Directions

There’s always room for improvement. Future enhancements could include:

• Pattern Library: Pre-built patterns players can place with one click
• Save/Load: Store and share grid configurations
• Variable Speed: Adjust simulation speed in real-time
• Heat Map: Visualize cell activity over time
• Larger Grids: Support for 50×50 or 100×100 grids with zooming
• Pattern Recognition: Automatically identify known patterns

Conclusion

Conway’s Game of Life taught me that the best educational projects are the ones you can play with. By transforming a mathematical concept into an interactive experience, I created something that’s simultaneously a learning tool, a puzzle game, and a creative sandbox.

The Game of Life demonstrates a profound truth about computation and complexity: simple rules, applied consistently, can generate infinite variety. Whether you’re placing cells to win a level, watching chaos unfold in randomize mode, or carefully crafting patterns in creative mode, you’re exploring the boundaries between order and chaos, simplicity and complexity, rules and emergence.

That’s what makes it timeless. That’s what makes it fascinating. And that’s why, over 50 years after Conway first described it, the Game of Life continues to captivate programmers, mathematicians, and curious minds around the world.

Try the game yourself what patterns emerge from your designs. Sometimes the most interesting results come from happy accidents. https://github.com/thehamzaihsan/game-of-life