Cellular automaton
I like to think of cellular automaton (CA) as a state and a set of rules. The rules dictate how the state is transformed from the current state to the next state. There is a strong connection between CAs and permutation-based cryptography.
Details
For my parallel computing class at UNL, I chose to implement the game of life CA on a compute cluster. The red lines separate the individual nodes. In this case, there are four compute nodes each handling one piece of the grid. The compute nodes communicate on the boundaries using MPI.
Ramping it up to nine compute nodes, and adding coloring.
To make things interesting, I implemented non-trivial colorization rules to visualize the influence of each node on the overall state. In other words, each node's color can now creep outside of its original box of responsibility. It gets interesting after letting it run awhile. In addition, I changed the visualization technique to use individual points instead of a texture.
Branched off the code to make a local version that doesn't run on a remote compute cluster. Experimenting with different color palettes, and adding 3D perspective.
Ported the application to Direct3D and began experimenting with using append buffers from compute shaders. The program can handle large dimensions at blazing fast speeds.
Experimenting with different visualization techniques.
I migrated back to a grid-based visualization. The compute shader calculates the next state, and then the buffer is fed into a fragment shader which produces the below, entirely procedurally. The CPU does very little work.
