crobgol

Conway's Game of Life terminal simulation (Unicode) in action

Table of Contents

• What is crobgol?
• Features
• Quick Start
• Requirements
• Make Options
• Command Line Options
• Optimizations
• License

What is crobgol?

The name was made like this: C Robkoo's Game Of Life

It is a high-performance terminal-based Conway's Game of Life simulator written entirely in C

Features

• Optimized grid implemenation that uses bit operations and a bitmap to store game data
• Adjustable grid size and frame rate
• Unicode and ASCII rendering modes
• benchmark built-in
• Custom CLI argument parser

Quick start

Build from source

git clone https://codeberg.org/Robkoo/crobgol

cd crobgol


# compile and run
make  &∓& make run


# OR with parallel compilation
make -jj$(nproc) &∓& make run

If you have Nix with flakes available, you can also run the project directly:

$ nix run git+https://codeberg.org/Robkoo/crobgol.git

Use pre-built binaries

• head over to the releases and download the correct archive for your OS

Requirements

Linux

• C23 compiler (gcc)
• GNU make utility

Windows

• MSYS2 UCRT64 shell installed (install from msys2.org)
• the following dependencies installed:

pacman -S mingw-w64-ucrt-x86_64-gcc \

          mingw-w64-ucrt-x86_64-make

Make options overview

Note

The default option is release

Command line options overview

Note

You can run the executable with --help for an overview right in your terminal.

Examples

# Run at 30 FPS with larger grid
./bin/crobgol -f  30 -w 120 -h 40


# Run with ASCII characters
./bin/crobgol --ascii



# Run benchmark with 10000 iterations
./bin/crobgol --bench  10000

Optimizations

1) Bitmap instead of char*

• The initial implementation (struct grid_t) used a char to store each cell's value, which takes up 8 bits per cell.
• The new implementation (struct grid_new_t) uses a bitmap, which stores each cell's value inside a single bit.
• This is a whopping 8x memory reduction in the data structure. For example, for a 100x100 grid, the initial implementation would've used 10,000 bytes of space, while the new one would use 1,256 bytes of memory.

2) Optimized function for computing next generation

• The initial implementation of the function ComputeNextGeneration(...) contains function call overhead (calls functions to get cell's value, set cell's value and get neighbor count). The neighbor count function also calls some functions, further increasing the overhead.
• The new implementation of the function BitmapComputeNextGeneration(...) inlines these functions, so they're directly inside this function. It also uses efficient bit operations >>t;>, &, etc.
• Based on my testing, the new implementation is about 3x-4x FASTER than the initial implementation. You can test it for yourself by running the executable with the option --bench er>, where er> is your desired amount of iterations to test the functions.

License

• GPLv3 (see License)