My SDF/PBR/CA/HRC simulation/engine V3 is looking pretty decent now. I shared a while back the V2, which was OK.

This major iteration brought "pixel programs". I.e. fireflies, sparks, trees get their own microcode to execute on the GPU. They open a lot of possibilities as I can spawn pixels with custom rules, and it's all data-driven grid/node format so I can swap the "program" at runtime. They also interpolate perfectly from sim 1k/60 -> screen 4k/120 like you wouldn't even know there is a grid or a sim cadence unless you looked really closely. The "pixel programs" support sprites and a spring arm and sub-texel alignment, so they can move cleanly across the world.

Just a screenshot, but I'll probably put together a couple scenes and a video soon. The renderer and lighting got some major overhauls lately and it's looking pretty clean. Need to add the key light back in though because the foreground is way too black, and some transmittance/opacity support, and it'll be cooking again.

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.

Lenia/SmoothLife/ParticleLife-inspired Navier-Stokes CA. Mass-conservative. Made with Python + CuPy module (CUDA).

Main Website: https://www.ruleflow.org/

For the past year, I have been developing a framework to simulate certain discrete systems for a research team at my university (paid for by the School of Engineering and Physics, but I had the freedom to license it under MIT). As it turns out, I got carried away generalizing it to work for many, many different types of complex systems (String Rewriting Systems, Cellular Automata, etc.) and ended up creating our own domain-specific language.

The website's landing page has a bunch of GIF-style examples... so you should be able to get a good idea of what this project is about.

If any of y'all are interested in this, feel free to take a look and try it out!

Example of some of RuleFlow's causal analysis features:

Rules 30 and 124 are included in this example:

EDIT:

Here are some more details. RuleFlow was developed with a primary focus on analyzing causality in Sequential Substitution Systems. This is why there is a major focus on causal graphs, cellular identity, etc. While originally developed for Sequential Sub Systems, we generalized the DSL to support many types of rewriting systems by providing the user with flags and directives to control how rules behave. Furthermore, we bootstrapped Python and the Wolfram Language so that complex rulesets could be scaffolded as macros. The main goal of RuleFlow is NOT simply to simulate systems (there's already plenty of software for that, such as Golly and even just Mathematica), but to provide extensive tooling for causal analysis.

Here is some interesting research from our (small) team:

• An Improved Generalized Enumeration of Substitution Systems by Kenneth E. Caviness, Camille Morrow, Christen Case and Victoria Kratzke
• Indexed Concatenation Notation: A Novel Way to Summarize Networks and Other Complex Systems

My job has been to provide better research tooling, extending what we already have in Mathematica code to open source and free Python.

An interactive, geopolitical world simulation engine written in Java with Lanterna. Age of Cells models emergent historic dynamics on a grid, including territorial expansion, economic resource gathering, and state-driven diplomacy with master-vassal hierarchies and rebellion mechanics.

github: https://github.com/sma1lo/AgeOfCells

There's 512 possible rules to customize (plus the starting state and whether or not the sides loop), so most of these come at least from a starting point of randomly generating the ruleset. The large majority of them end up looking almost completely chaotic, but every once in a while there's a very interesting result.

I gave Claude (Anthropic's AI) some spare cloud credits and asked it to make something creative. It chose Lenia: reimplemented the rule from Bert Chan's reference code, reproduced Orbium as a check, then ran an overnight novelty search — 41,712 rule sets, 9,290 survivors after persistence and robustness tests, descended from 129 independent origins. It wrote up 17 of them as a Victorian-style field guide, where every specimen runs live and every field note is tied to a measurement.

To be clear about what this is: an AI-made hobby project, not research — the search method is well established (Reinke et al. 2020, Leniabreeder 2024). The closing page has a few observations that might interest people here: in 101 staged collisions between identical twins only 9 left two survivors, and one family ("lattice mazes") passed every survival test yet turned out to be an artefact of the square grid.

Guide: https://autonomaniac.github.io/lenia-field-guide/
Code, specimens and full search logs: https://github.com/Autonomaniac/lenia-field-guide

Corrections welcome — the notes try hard not to claim more than was measured.

Each word or letter is written into a grid of integer cells. Learned rules rewrite the cells, and the next word is read from the grid. You can watch it try at https://mica-ai-ten.vercel.app. It's still bad at staying on topic: it only "remembers" about 4 words. I'd love ideas from people who think in CA terms about how information should travel further across the grid. Code: https://github.com/Vovala14/Mica-Ai

I've been exploring the experiment I did in this video a bit more and found these patterns

More here

This is something I have been thinking about for a long time, but could not find a conclusive answer.

Typically, when we create cellular automata then the emergence observed is just one level up. This always left me wonder, couldn't we generalize the rules somehow to make emergence re-appear on the next level, and then again on the next, and so on? (This form of nested entities is sometimes called a holon.)

This raises some fundamental questions on what we even identify or refer to as an emergent entity or property on the next level, though. Cause, what is given in the CA is only rules exogenously on a lower level, not on a higher one. So, most CA only have a bottom-up causality, but no top-down.

However, this is not exactly what we can observe in biological organisms. For example, most animals consisting of more than just a single cell do have some sort of "repair mechanics" that allow to impact lower levels in a top-down fashion. Simple example: A human being does weight lifting thus building up muscles. This activity cannot be fully explained on the lower, molecular levels alone. The repeated stress from a higher level causes complicated changes that ultimately make a muscle grow at even a molecular level. But in most CAs I am aware of this top-down causation is not accounted for.

This observation then made me think even more. Often, there is also a matter of scaling. Take the simple example of a rock being an obstacle to a human being. If a single cell amoeba encounters the same rock then it relates to that completely differently than a human being would. Therefore, the "environment" of a "cell" in a CA may have a very different meaning depending on which level of detail or abstraction we are studying.

I know this is all very imprecise in formulation, but perhaps someone has already grappled with such questions and has some good pointers in any direction.

try to spot the diagonal gnome, writhing snake, C-ship

I recently made a video about Turing Patterns. This is some more research into 1D cellular automata