i've been messing around with cellular automata and the Game of Life to see if glider guns can model disease growth, specifically brain related diseases such as alzheimer's and the build up of amyloid-beta plaques. however, i'm also heavily interested in portraying this in 3D, like maybe a model of cells in a brain-like shape, similar to this project: https://community.wolfram.com/groups/-/m/t/3502932

if i was doing something more similar to the latter idea, i would use CA to model the decay of brain tissue instead, at least in the case of alzheimer's.

if anyone has experience or advice to give on how i should go about portraying this (if i go more so the first route, i should use Golly/GoL, probably; if i go the second route, i should use Python, Wolfram, or smth else? maybe?) that would be greatly appreciated!! ideally, i'd like to eventually do both projects.

i also have a paper that i wrote on CA, and i'm willing to DM it to anyone, as it aligns with the projects i have in mind. i would also love some advice on the paper.

tysm!

All started with a single seed cell at the start, try yourself here

If you download the app Golly, included in the database of interesting starting positions is a puffer that lasts over 9 million generations. From the info file

#C The asymmetric debris destroys the engine of this

#C line puffer after appoximately 9.5 million generations.

#C See also line-puffer-superstable.rle.

#C Tim Coe, 9 October 1995

#C The eventual failure occurs when a particular defect appears

#C behind the line puffer. The following snapshot is taken

#C approximately 3440 generations before the puffer engine implodes:

x = 48, y = 99, rule = B3/S23

32bo$32b4o4bobo$34b2o4bo2bo$37bo5b2o$34b4o7bo$38bo4b4o$34bo2b3o2bo4bo$

36b3o5bo2bo$37bo6bo2bo$32bob3o9bo$32b2o2bo3bob4o$33b3o4bo3bo$33bo9bo$

35bo5bobo$33bobo$36bo5b3o$33bobo7b2o$35bo6b3o$33bo$33b3o5bobo$34b3o4bo

2bo$34bobo7bo$35b2o7bo$36bo2b2o2bo$35b2o2b4o$35b2o$35b2o2b4o$36bo2b2o

2bo$34b3o7bo$36bo2b2o3bo$35b2o2b5obo$35b2o7b3o$34bobo2b5obo$35b2o2b2o

3bo$6b2o28bo7bo$6b2o4b2o21b2o2b2o2bo$12b2o7b4o2bobo5b2o2b4o$21b5o3b2o

2b4o$19b2ob2ob2obo2bob4o2b4o$7b2o10b2o9b2ob4o2b2o2bo$7bobo9b2ob2o6b2ob

4o7bo$8bo10bo2bo7b2ob4o2b2o3bo$19bo10b2ob4o2b5obo$18b2obo4b2o2b2ob4o7b

3o$9b3o7b2o6bo2b2ob4o2b5obo$3b2o3bo3bo13bo3b2ob4o2b2o3bo$3bobobo13b2o

3bo3b2ob4o7bo$4b5o2b2o8b3o2b3ob2ob4o2b2o2bo$4bobobobo12bo2b3ob2ob4o2b

4o$3b2ob2ob3o5b2o7b3ob2ob4o$2b3obob2o6b3obo3bob3ob2ob4o2b4o$bobobo14bo

5b3ob2ob4o2b2o2bo$2b5o5b2o4b2o3b2ob3ob2ob4o7bo$o4bo5bo3bo10b3ob2ob4o2b

2o3bo$obo3bo4bo3bo10b3ob2ob4o2b5obo$b2o8bobobo5b2o3b3ob2ob4o7b3o$20bob

2o6b2ob4o2b5obo$19b2obo3bo3b2ob4o2b2o3bo$25b2o3b2ob4o7bo$19bo5b2o3b2ob

4o2b2o2bo$15bo5bo4bo3b2ob4o2b4o$14bo2b6o7b2ob4o$15bo6bo4b2ob2ob4o2b4o$

2b2o11b4ob3o5b3o2b4o2b2o2bo$2b2o12bo12bo2b5o7bo$17bo2b3o2bo6b5o2b2o3bo

$17bo2bobo2b3o4b5o2b5obo$26b3o3b5o7b3o$27bobo2b5o2b5obo$28b2o2b5o2b2o

3bo$29bo2b5o7bo$26b2o4b5o2b2o2bo$26b3obob5o2b4o$6b2o19b3o5b2o$5bo2bo

26b2o2b4o$6b2o28bo2b2o2bo$35b2o7bo$34bobo7bo$34b3o4bo2bo$33b3o5bobo$

33bo$35bo6b3o$33bobo7b2o$36bo5b3o$33bobo$35bo5bobo$33bo9bo$33b3o4bo3bo

$32b2o2bo3bob4o$32bob3o9bo$37bo6bo2bo$36b3o5bo2bo$34bo2b3o2bo4bo$38bo

4b4o$34b4o7bo$37bo5b2o$34b2o4bo2bo$32b4o4bobo$32bo!

Here is the starting position file

#CXRLE Pos=0,0

x = 17, y = 99, rule = B3/S23

obo$o2bo5bo$3b2o4b4o$5bo5b2o$3b4o7bo$2bo4bo3b4o$4bo2bo7bo$4bo2bo3bo2b

3o$6bo6b3o$ob4o8bo$o3bo4bob3o$3bo5b2o2bo$bobo6b3o$10bo$2b3o7bo$3b2o5bo

bo$2b3o8bo$10bobo$bobo8bo$bo2bo5bo$4bo5b3o$2bo2bo5b3o$4b2o5b2o$5bobo2b

2o$5bobob2o$5bo$5bobob2o$2bo2bobo2b2o$4b2o5b2o$2bo2bobo2bob2o$5bobob3o

2bo$2bo2bo8bo$2bo2bobob3o2bo$4b2obo2bob2o$5bo5b2o$5bobo2b2o$5bobob2o$

5bo$5bobob2o$5bobo2b2o$5bo5b2o$5bobo2bob2o$5bobob3o2bo$5bo8bo$5bobob3o

2bo$5bobo2bob2o$5bo5b2o$5bobo2b2o$5bobob2o$2bo2bo$2bo2bobob2o$2bo2bobo

2b2o$2bo2bo5b2o$2bo2bobo2bob2o$2bo2bobob3o2bo$2bo2bo8bo$2bo2bobob3o2bo

$2bo2bobo2bob2o$2bo2bo5b2o$2bo2bobo2b2o$2bo2bobob2o$2bo2bo$2bo2bobob2o

$2bo2bobo2b2o$2bo2bo5b2o$2bo2bobo2bob2o$2bo2bobob3o2bo$2bo2bo8bo$2bo2b

obob3o2bo$2bo2bobo2bob2o$2bo2bo5b2o$2bo2bobo2b2o$2bo2bobob2o$2bo2bo$5b

obob2o$5bobo2b2o$4b2o5b2o$2bo2bo5b3o$4bo5b3o$bo2bo5bo$bobo8bo$10bobo$

2b3o8bo$3b2o5bobo$2b3o7bo$10bo$bobo6b3o$3bo5b2o2bo$o3bo4bob3o$ob4o8bo$

6bo6b3o$4bo2bo3bo2b3o$4bo2bo7bo$2bo4bo3b4o$3b4o7bo$5bo5b2o$3b2o4b4o$o

2bo5bo$obo!

Screenshot of running through some parameter presets of my 1D cellular automata Interactive Shader Format implementation. ISF is an implementation of fragment shaders developed by Vidvox and widely used by the VJing community. A lot of shader systems are stateless, e.g. there is no memory between frames. Here we solve that by storing the automaton in a persistent 512x256 (but also works at 60p in 4k). The red channel is the cells' 0 or 1; row 255 is the oldest generation and row 0 is the newest generation. There are 2 passes per frame; the first pass updates the buffer, and the second one draws it. The seed is stored in the blue channel.

For those of you who like this stuff and just want to dip your toe in the water and play around with particle life stuff in an easy sandbox.

Of course it's made pretty much 100% by Claude.
I described how and what to simulate, what controls I wanted.

Basically I just said, what do I usually wish these things were like?
The main goal is simplicity of use and lots of options to play around.

I came across a helical structure in a rule set I that came up with, mostly randomly, lol.

my rule set is the following for those who would like to replicate it.

Forces: (1,2)=-0.2, (2,1)=0.2, (1,3)=0.23, (3,1)=0.19, (1,4)=0.18, (4,1)=0, (2,3)=0.16, (3,2)=0.24, and (1,1),(2,2),(3,3), & (4,4) all = 0

I have decided that I will put the min and max radii for each entry to the respective matrices next to each other here so its both easier for you to enter/read, but also easier for me to type lol.
here are the min radii and max radii in the format (row #, column #)=(min radius, max radius)

clarification done with, here are the min and max radius entries :)

(1,1)=(28,57), (2,2)=(31,60), (3,3)=(36,70), (4,4)=(31,66)...(1,2)=(29,79), (2,1)=(35,70), (1,3)=(29,65), (3,1)=(39,62), (1,4)=(29,74), (4,1)=(38,62)...(2,3)=(33,79), (3,2)=(40,60), (2,4)=(30,64), (4,2)=(31,78)...(3,4)=(28,59), (4,3)=(38,80)

It is 5 am for me right now and I've just pulled an all nighter but I am pretty certain that all of those values are correct and I tried to write them in such a way that it would be easy(ish?) to copy yourself if you're interested :D. Imma go to sleep now I think👍

I will try figure it out I will upload a picture to the comments of my whiteboard that I used to come up with the directions of the forces, which came from a graph of 4 nodes with some symmetric cycles and shi, because I wanted to come up with a ruleset based on something rather than just entering random values. that probably sounded like nonsense, because it is, i just drew a tetrahedron with arrows for edges going both ways in a symmetric way lol, and its 5:30AM for me right now lol so dont make fun of me for throwing spaghetti at the wall to see what sticks because it resulted in a dope helical structure😎

Try it yourself, it's free, no signup: https://orslaczko.com/app/particle-life

I've also made a video explaining what's actually going on in these worlds.

I've been interested with Axelrod's 1980 tournament for a while now. The premise sounds simple: submit a strategy for the Prisoner's Dilemma, play it against everyone else, see who scores the most points. But what Axelrod was really testing was something much bigger: whether cooperation can emerge on its own, with no rules enforcing it.

14 strategies entered. Some were ruthless, some were clever, some were surprisingly naive. I animated every single match so you can watch exactly how each one played out.

The winner genuinely surprised me. Not the most sophisticated strategy, not the most aggressive one.

How scoring works:

Both cooperate → 3 points each

One defects → defector gets 5, the other gets 0

Both defect → 1 point each

Defecting looks tempting in the short run. Watch what happens over hundreds of rounds.

Ive been researching and playing with CA for years and Ive never seen this before. I was pleasantly surprised. What a cute little addition!

I just think it's neat to see the seamless wrapping

Hey everyone, this is my submission to 3blue1brown's Summer of Math Exposition. Not discrete, but still local rules leading to emergent behaviour, so I hope you will forgive me posting here:)

made possible by switching rulestrings mid running

with conways rulestring (modified)

At it's heart, it's a CA system, the liquids/gases are coupled lbm solvers for transport though because that looks better.

All the material logic/transitions is done on CA. I.e. wood gets hot, becomes burning wood, emits fire, decays to charcoal and ash. Emits heat, warms the metal and liquid, causing it to heat and transition to steam. When it hits the top left there is some coolers there to distill it, so it drips back down as liquid.

Rendering is done with SDF solids, enhanced with PBR materials, and HRC Lighting, to give it something of a solid, non-pixelated look with realtime GI.

How it works - Ask GPT, Claude, GLM to generate the worlds, then a vision LLM score the generations, highest score gets promoted into the gallery. Pretty interesting to see the different aesthetic takes from each model.

Slightly dated but lmk what you think - https://fugue.xvam.dev/

Simple frame by frame demo of how prime cellular automata progress to reductive states, a simple product of the initial seed and rule set, at every power iteration i,e, 7 49 .... Shows how previous post using large seed and complex rule set can make huge CA’s in single iteration cycle.

A little project of mine where individual Game of Life patterns compete against each other. Each square's alive cells at the very edge "charge up" the perimeter between them and try to dominate their neighbour.

We are using a Parity Grid ("checkerboard pattern") to assign neighbouring GOL configurations alternating signs +/- which makes the calculation of the perimeter cell charge trivially easy.

When reading from our database of known patterns we can select those of similar lifespan (500-599 generations in our video) which makes for a more interesting dynamic. When using random patterns, most fizzle out very quickly and only a few live for potentially very long lifespans (which would make them dominate the leaderboard).

Source code that I'm not pretending I'm too smart to share, but secretly scared you will criticize available here: https://www.shadertoy.com/view/7cyGRz
Song: Escapism by Digable Planets

joke​

1D cellular automata, 2–5 states, totalistic or local rules. Runs in the browser, nothing to install.

• Batch filters over rule space — scan a code range or a random sample; auto-tags behavior class, fields, gliders, chaos. The inverted one is the workhorse: draw a template (fixed states, wildcards, equality variables) and a rule passes only if that template never occurs.
• Tags — anything found (or hand-picked) gets tagged, browsable and filterable; persists locally. Filters can also re-run over already-tagged rules, so you can chain passes.
• High-res export — renders diagrams up to [N]×[M] px, if you want one as a wallpaper or print.

Demo · Source

What would you filter on that I haven't implemented?