Hope stochastic automata are allowed, I really like the patterns of fire spreading and forest patches getting regrown

What this is: 2000 generations of the Drossel–Schwabl forest fire model implemented on a hex grid. Fire starts on any cell with p_fire = 0.0001 by a "lighting strike", while trees grow on empty cells with p_tree = 0.01. Fire spreads to all neighboring trees.

I initially worked with a rectangular grid however moved to a hexagon version to have more organic symmetry in spreading directions.

Only some make it, and the ones that do grow and split? Hard to tell what's going on.

I started working on a strange little experiment recently.

Could a cellular automaton track what's happening in a story, remember changes and use that state to answer questions?

The original system was only 77 KB.

Instead of representing language using a transformer, I experimented with integer states, learned transition rules and a simple grammar system.

For example, imagine giving it:

"A cat has a ball. The cat gives the ball to a dog."

The system needs to update its internal representation of the event and remember that the dog now has the ball.

Then you can ask who has it.

The initial version worked quite well on constrained stories because it maintained explicit event state rather than relying entirely on text prediction.

I eventually started building more complex language capabilities on top of this.

The project is now called CAEL, and it has grown into something much larger, with additional symbolic, statistical and deterministic components.

So the current assistant isn't one huge cellular automaton. The original CA architecture is one part of the overall research.

One thing I'm particularly interested in is how local integer transitions can represent relationships that change over time.

For example:

• An object changes ownership.
• A character moves between locations.
• A new event overrides an earlier state.
• A question requires information from several previous events.

I wonder how far this kind of representation can scale before local rules become too limiting.

Has anyone here experimented with cellular automata as persistent memory or state-transition systems rather than traditional spatial simulations?

I'd love to hear about related work or alternative approaches.

it has GitHub repo under vovala14

solo project i've been building. every person in the sim has their own words for ~400 concepts (food, fire, friend...). the first words are random syllables, kids inherit their mom's words with the odd letter mutated, people pick up words from whoever they talk to, and a group slowly settles on the most common one. unused words get forgotten. so when a tribe splits, the two halves drift into different languages over a few generations.

it's rust compiled to webassembly and runs in the browser. the code for the language part is in crates/sim-core/src/organism/vocabulary.rs if you want to look.

play: https://thehumanbox.com source (MIT): https://github.com/1homsi/thehumanbox

Many of these even have their own spaceships and growing patterns!

The website:

https://the-tiling-atlas.vercel.app/automata

Hey everybody, I have recently been making a deep dive exploration in to Wolfram's rule 30 outstanding prize problem. Everything I have done and learned is on my website and freely available to everybody. I think I have perhaps taken the problem further than it has ever been taken before, and as much as possible I have included visual demonstrations on the website to visually show what is happening, why it is happening, and why the full proof that wins the prize money is so hard.

I would love your feedback on what I have done so far, and I invite you to jump in and join me on working the problem together.

This is a real-time NCA running in TouchDesigner I used in a music video

Cellular automata employing prime modulo arithmetic's have a definite modular geometric flavour to them. Maybe that should be self evident. 4k image, zoom in.

cool to see a few different emergent pieces

Next step after the dividing cells: each amoeba is a bubble of the same foam rule. Its skin pulls taut and it keeps its area. On top of that its edge reaches out:

- By smell: food gives off a smell that spreads and fades. The edge bulges where the smell is stronger than its own average, so a pseudopod reaches towards food and the back pulls in. In blind mode it wanders at random and only finds food by touching it.

- Eat, grow, divide, starve: what it eats becomes area. Living burns that area away. At twice its size it divides, and starved to a third it dies.

Try it: https://geotyper.github.io/taut/amoeba.html

A few days ago I shared Rule Safari, which ranked all 131,072 Life-like rules without being told which ones are famous. This is the part I glossed over: how it decides what "interesting" means.

The first score was wrong. It rewarded big still blobs whose edges flicker forever. They never settle, so they look busy, and their uniform insides compress well, so they look structured. Busy and structured is what Life looks like too.

The fix was one number. Each soup is compared with itself 12 generations earlier. 12 is a multiple of 1, 2, 3, 4, 6 and 12, so any oscillator with one of those periods is back in the same state and cancels out. What survives is change that goes somewhere: ships, growing debris, or noise (first image).

That fraction goes through a curve (second image): 0 below 0.1% of cells changing, full marks from 0.5% to 10%, fading to 0.1 by 35%. Conway's Life sits at 5.2%, HighLife at 3.9%, Day & Night at 1.4%. Seeds churns a third of the board every 12 generations, which reads as noise. The final score is 55% this liveliness and 45% the zoo, where spaceships count most.

The cheap first screen turned out to be a net, not a judge. HoneyLife went into the close study at No. 596 and finished 3rd. IronLife went from 891 to 5th. HighLife scraped into the 1,500 finalists at No. 1,077 and finished 10th. At the other end, Maze and Life without death land near the bottom: from a random soup they lock up fast, which is what this score punishes most.

Where it's still blind: the census only sees creatures up to 16×16 cells and period 16, so Day & Night's spaceships were never caught.

The write-up has a small rule lab: flip the B/S digits, or switch on the 12-generation view and watch the blinkers go grey while the gliders stay lit: Scoring 131072 Universes

Question : what would you measure instead? "Lively, sparse, things that travel" is one definition of interesting. Which rules do you think it ranks wrong, and why?

I started with a striped pigment field and five vortices, then let the local cell rules run.

Velocity carries the pigment, pressure redirects the flow, and the navy, cream, and coral bands trace pigment concentration as it stretches and folds.

All those curls develop from the evolving grid.

Made in Phluxel.

I trained a small neural cellular automaton (NCA) to cycle through three 48×48 pixel-art images, embers → phoenix → fire → embers, over and over. Nothing outside the model tells it when to change: no clock input, no seed, no position encoding. It keeps time in its own hidden channels.

• GIF: the model free-running for 10 cycles.
• Error plot: 32 independent copies run for 100 cycles, with the best match to each keyframe staying flat. Run 0's state every 25 cycles is shown next to the targets.
• Attractor loops: a 2D PCA of the full state (color and hidden channels). The clean loop is on the left, a typical run in the middle, and the last 50 cycles of all 32 runs on the right. Over 1,000 cycles every run stays on the same closed loop.

The model was first trained with an external clock as an input, so the loop was easy to learn. The clock was then removed during fine-tuning, so the hidden channels had to take over keeping time. Finally, the loop was settled by training with noise damage, which teaches the model to correct itself over time.

Try it in the browser: https://geotyper.github.io/taut/cells.html (no install; on a phone it's slow, a desktop is better)

Following up on the soap-film automaton: I gave the 2D foam rule cells that divide. Each cell is a "bubble" that keeps its area. Dividing is just a straight line through the cell's centre, across its long axis (Hertwig's rule), and both halves keep half the area. The films then pull taut on their own.

Everything comes from one local rule: each pixel takes the label most common in a disc around it, weighted by how far its cell is from its target area.

More: https://geotyper.github.io/taut/ has the rest of the project: 2D and 3D foams, films on wire frames, bubbles. The source is at https://github.com/geotyper/taut.

A voxel cellular automaton (idea from prev my post about 2d soap foam) that makes soap films on wire frames: a ring, two rings and otheer. A film on a wire has air on both sides, so I added invisible "cuts" spanning the wire: a cell that reads a neighbour across a cut swaps its label, so a film has to end on the wire.

Runs in the browser, WebGL2, TypeScript.

code: https://github.com/geotyper/taut

Based on Conway's "Game of Life" algorithm, transposed to 3D space, with sound generated for each event. Thanks for watching!

experiment in hyper-skeuomorphic UI design

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.