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.

One rule: each cell counts the labels in a disc around it and takes the most common one, with air counting for less. Bubbles grow from seeds, meet, and the borders pull taut into films that join three at a time.
code: https://github.com/geotyper/taut

A better view with some motion and insight into a few of the layers that are used to run the Sim and compose the render.

One small NCA grows 24 plant species and a lawn. Every seed looks the same, and the species is encoded inside the seed.

The video is of the wallpaper running on my laptop. A grass seed drops and the lawn spreads over the dirt. Then seeds fall one at a time down columns that are clear of other plants, and each one grows into whatever it was encoded to be. When there's no room left, that layer recedes toward the horizon and a fresh strip of dirt comes in.

The model wasn't trained with plant to plant interactions in mind, so I space them out so they don't touch.

Every Life-like rule without B0 (131,072 of them) gets two random 40×40 soups and two tiny seeds in empty space. The ~1,500 most promising get bigger soups and a census: every isolated object is replayed alone, and if it returns to its own shape within 16 generations it's catalogued as a still life, an oscillator or a spaceship (with its speed). A full sweep takes about two minutes on a 16-core laptop.

The scoring trick that made it work: compare each soup with itself 12 generations earlier. Every oscillator with period 1, 2, 3, 4, 6 or 12 cancels out, so what's left is change that goes somewhere: ships, growing debris, or noise. The first version scored "never settles and compresses well", and it put boiling blob rules on top.

What it found (seed 1):

- 7 of the top 10 are rules already named on LifeWiki: EightLife (#1), Conway's Life (#2), HoneyLife, IronLife, Pedestrian Life, LowDeath and HighLife. All of them passed the first screen on their own.

- 34 kinds of spaceship across 27 rules, including c/7 diagonal ships in B36/S245, B3/S245 and B38/S02458, and a 13-cell c/8 orthogonal ship in B347/S268.

- Seed 2 reshuffles the order (Pedestrian Life comes first), but Life's family still holds 9 of the top 12.

**Live field guide** (every rule runs in your browser, next to the creatures it caught): https://r-hatim.github.io/rule-safari/

**Code** (Rust, MIT): https://github.com/R-Hatim/rule-safari

The census is tiny next to Catagolue (objects up to 16×16, periods up to 16), so this is a quick map of the rule space, not a serious search. I'd love ideas for better "interestingness" measures, or rules you think it unfairly buried.

I'm a PhD student who models plants by day, and this started as something to stare at that has great patterns from simple rules. A sweep line plays every live cell under it as a pentatonic note, so gliders and oscillators turn into loops.

Other things in it:

- Lookahead colours cells by fate (green lives, red dies, grey is about to be born) and previews 1–55 generations ahead

- Aura colours cells by age, with fading trails

- Rule Lab: HighLife, Day & Night, Seeds, plus 11 puzzles (survive, hold a zone, cross the board)

Free in the browser, nothing to install: https://lifegameproject.com/life.html

iPhone/iPad (free, no ads, no tracking): https://apps.apple.com/app/id6821541367

I'd love to hear which patterns sound best to you XD!

Hello quite new to this community some very cool stuff. I have been investigating this celluar automata, which came about it quite a convoluted way but produces some interesting patterns. Quite happy, as all my previous attempts at making interesting simulations have been floops. It's such a good felling, like exploring a new alien world.

So this one has 14 states, which change based on a lookup matrix that maps each possible pair to a new state. So say state 3 and state 4 gives state 7. An exception is if it goes to 0 or 15 (I call these foribben state), basically as when I allowed these they would completly dominate.

To detimine which 2 neighbours they look at i have a cycle of different pairs each state looks at each turn. I use the morre neighborhood so each cell has 8 neighbours. So say state 1 might look to neighbours (1, 2), (3, 4), (4, 3) and then back again to (1, 2)

In the beginning I tried random neighbours each time, which produces more chaotic blobs that grow and shrink over time. With the fixed cycle of neighbours you get more structure, but as you probably expext many produce random noise or quickly become static/flickering.

A surprising amount though looks interesting, with patterns that change over time. The second image ( I call them sandbars) continually changes, with those arching patterns lengthing, breaking and forming elsewhere remaining me of sandunes.

Lots still to do if I ever get time would like to try some generic algorithms to search more precisely for interesting neighborhood rules and explore different lookup tables.

I would be very interested to know if people have seen a CA like this before for me to also look at.

Here is a GitHub link to a tidied up version of the code for anyone who wants to have a look and make some animations and explore themselves:

https://github.com/FionnWyn42/14state-CA/tree/main

A follow-up to the 2D clustering post, now in a voxel field. Each group of nearby stones gets its own membrane, coloured by cluster.

It is one local rule applied by every cell at once. Nearby stones agree on a common label, and each group's membrane starts as a fat blob and pulls taut around its stones. Membranes of different groups never merge.

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

Continuing experiments with a cellular automaton that stretches rubber bands around clusters of stones. Before, each cell could belong to only one band, so neighbouring bands dented each other. Now a cell holds several bands at once, and the clusters sort themselves into separate layers, so each band reaches its full convex hull and passes over its neighbours.

It is still one local rule, with every cell updating at the same time.

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

A follow-up to the 2D rubber band post. Now there is one band per group of stones instead of one around everything.

It is a single local rule: every cell looks only at its 8 neighbours. Nearby stones agree on a common label, and each group gets its own band that pulls taut around it. Bands of different groups never merge.

Code: https://github.com/geotyper/taut/tree/clusters-single-field

i made this rule

(Apologies if bad grammar, English as second language.)

I made a cellular automaton brainstorming in school, and I cannot find if I came up with it first or if somebody else has made this before me.

The rules are pretty simple:

• Each tile can point in 4 directions, they can point in multiple directions.
• An activated tile activates tiles that it points to.
• If multiple tiles try to activate a tile it will not activate, aka a tile turns on if specifically one tiles activates it.

Addisonaly I vibe coded a simulator:

https://xblowdame.github.io/cell_auto/

Does anybody know if this exists?

All primes till 10,000 are represented here, primes are the white squares, reminds me of game of life patterns.

A follow-up to 2D rubber band post. Same idea in a voxel field: a membrane starts as a ball and tightens around a few stones.

The rule is local: a cell stays inside if, along at least one of 49 lines through it, most cells within reach are inside. A direct 3D port of the 2D rule didn't work.

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

A binary outside/inside grid under one rule applied to every cell at once: flip to “inside” if the blurred neighbourhood crosses a threshold, with stones frozen so the front can never cross them. A wave released from the border contracts inward, concave stretches pulling in faster than convex ones, until it goes taut between the stones

Hey everyone,

I'm making my own cellular automata engine in C++. I recently added support for thermodynamics and rigid body physics (implemented using the Box2D library).

The video shows an engine test; occasionally I toggle the heat map to demonstrate how temperature changes across different areas. If you drop an iron cube into lava, it heats up heavily and turns red. If you drop it into water, it cools down and heats up the water. If you place a red-hot cube into liquid nitrogen, it cools down much faster.

Box2D rigid bodies can also interact with particles and exchange heat with them: wood floats in water, iron sinks, and other materials can be easily added with individually tuned densities.

It's a data-driven approach: all physics, reactions, and phase transitions (like water turning into steam or lava into obsidian) are defined in JSON configs, with no hardcoding in C++.

I tried to optimize the engine as much as possible; watching so many interactions happen on screen at once is really satisfying.

Would love to hear your feedback or thoughts!

Really interesting experiment performed by Murat shown on his X post

https://twitter.com/mayfer/status/1556502182173675522

I spent 5 days of straight coding to recreate the game of life in the block programming website scratch. No AI was used as well as no tools to assist the coding. All rules of the game are created the same.

yes i took the idea from a carykh video

Hey,

Just wanted to share a little project. Not claiming any crazy math proof here, just a representation of Collatz using **balanced ternary** (`+`, `o`, `-`) instead of normal binary or base-10.

Because of how balanced ternary works, you can basically bypass normal CPU math and run the operations as simple text replacement rules on a string.

How it works:

• Parity: If the count of non-zero trits (`+` or `-`) is even, the number is even.
• 3x+1: Just append a `+` to the end of the little-endian string. O(1) time, no real math needed.
• Divide by 2: The string splits from left to right into blocks bounded by non-zero trits. Then it just uses two basic substitution rules:

1. Same signs: a(0...n)a` ➔ `aa'... (n+1) times` (e.g., `+000+` becomes `+----`)
2. Opposite signs: a(0...n)a'` ➔ `0a... (n+1) times` (e.g., `+000-` becomes `0++++`)

Piped the output through `sed` to colorize the trits (`o` = green, `+` = white, `-` = red) so it generates a neat cellular automaton history grid in the terminal as it collapses down to 1.

The photos are seeds of 100, 2³¹ -1, and 27 respectively

Just a cool toy. Let me know what you think or if anyone else has messed with block decomposition for base-3 halving.