complife/complife.org

• Restructure simulation
  • Refactor brainfuck interpreter
  • Refactor simulation
• Fix segfaults with 64 byte programs
• Parallelise even more
  • Ensure workers aren't working on the same programs
  • Implement threading on the simulation

DONE Restructure simulation

DONE: 2026-03-18.

Instead of going for one massive tape with "lines" being programs, go for 8x8 chunks.

The idea is to draw each individual command in motion instead of the composite program. The visualisation will look amazing.

DONE Refactor brainfuck interpreter

The "catalytic process" (take two programs, concatenate them, execute the program, split them back) is now completely standalone. The only assertions it makes about the input programs is that they are contiguous. Essentially the same as our previous implementation.

Now we just need to do the hard bit!

DONE Refactor simulation

TODO Fix segfaults with 64 byte programs   bugs

For some reason we can segfault when executing simulations where we have 64 byte programs. Characteristics:

• It happens seemingly randomly throughout execution, and has backtraces that aren't really helpful:

  • EndDrawing of Raylib.
  • abort somewhere on the stack

  • Some nvidia code???

    • Tested on an integrated Intel graphics machine, same issue but doesn't report nvidia code as the cause, so unlikely to be due to that.
• Not nearly as present with higher or lower sized programs, though can happen.

TODO Parallelise even more

Simulations are now at a point where we can see interesting emergent behaviour, that is different depending on the environmental conditions we setup (mutation rate, size of programs, number of programs).

However for larger sized workloads, though the simulation is rendering really fast, progression of the simulation with regards to this emergent behaviour can be quite slow. I believe adding a few thread workers to perform reactions simultaneously would help boost the throughput up a bit.

Notes:

• Mutation can happen independently of reaction. If the concatenation structure has already been made, then the changes from mutation are written over. If it hasn't been made, mutation gets propagated. Either case can and will happen.
• We should reduce locking as much as possible.

TODO Ensure workers aren't working on the same programs

We need to ensure any two workers aren't working on the same programs as:

1. Whoever writes last wins the race, and we could have a really unfortunate situation where one component from one worker each gets written (worst case).
2. It's wasted effort

So we'll need a way to intercept the program picking process of each worker.

TODO Implement threading on the simulation