Hi everyone I did a talk at the Peckham Digital festival yesterday! It's about spatial programming! I come in at 42:59 :) https://www.youtube.com/live/L2U_Sd1qMJ4?feature=share&t=2579

brilliant talk/demo! it seems like those rules work really well on the GPU (although the cell splitting would take some gymnastics) -- is that what you're doing / have you tried that?

Thank you very much! Yes I reckon there's some scope to run them on the GPU, but it might be harder than expected. So, just for context - the engine's main bottleneck currently is rendering, because it's just using javascript canvas. The renderer could be sped up loads by using webgl instead, and then the bottleneck would become the computation behind it. At that point, GPU would be a consideration! Cellular automatons are usually great for GPU optimisations, because all the classic (like game of life) involve rules where only the 'middle' of an 'event window' gets edited. Which is perfect for shaders. One of the challenges of an engine like CellPond (which stems from Dave Ackley's Moveable Feast Machine engine) is this: When a rule gets applied, it can affect any cell in the event window. This doesn't work so well with shaders. However, with the rise of GPU compute, eg: webgpu, it might become easier to leverage the GPU for this kind of thing! I need to look into it more! Another challenge is this: Most cellular automatons are deterministic. But CellPond (and the Moveable Feast Machine) are non-deterministic. So parallelising 'events' involves having to make sure that any randomly-picked locations don't overlap with each other. You can't just get away with a classic block cellular automata approach. I did manage to do a dodgy solution to that once on the GPU with this experiment though. And I made two videos about it: 1. . 2. . Big answer but it's an interesting topic, thanks for asking :)

Oh fascinating, thanks for the details response! So these nondeterministic event windows; do they pick a single rule to evaluate at random? Or do they evaluate all available rules? And is it critical that the window be a fixed size, or could it adapt to the size of the largest rule?

So, in CellPond, I was hoping to do this: 1. Pick a random position (within the 0.0 -> 1.0 range of x and y) 2. Apply a random rule (if it matches). However, for some performance reasons, it actually does this: 1. Pick a random position. 2. Shuffle all rules. 3. Apply the first rule that matches. The 'variable event window size' was a key new thing for the engine to do! The Moveable Feast Machine (MFM) has a fixed diamond-shaped window. SandPond has a square shaped one. CellPond needs to be flexible. The way it gets around this is... When you make a rule with the drag-and-drop interface, it actually gets compiled down into multiple rules -- one for each cell in the diagram silhouette. The classic sand rule... 🟨➡️⬛ ⬛➡️🟨 ... would produce two rules on the virtual machine. One where the top cell (yellow) is the 'center/origin' of the event window. And one where the bottom cell (black) is the origin.

hmm yeah that's neat! I wonder how it would be to have one (or several!) "hidden" or "background" layers for metadata, and rules that could take them into account, but the fore-most layer is the one that gets rendered 🤔

Yes that would be great to try out! I was originally planning for every cell to be controlled by its own mini 9x9 cellular automata world, and the middle cell was the only one that got rendered when zoomed out. But when I started trying it out, I got tempted by the dynamic splitting/merging idea 🙂

Very interesting. I had no idea how large the influence of Dave Ackley and his MFM was here.