u/SlyNoBody337

I've been working on this idea for an autopoietic/nearly autopoietic simulation and ended up with this recursive emergence simulator. It's been about a year now of directly struggling to get the idea out of my head and onto paper / into something tangible. Over the last month, I've been building up and trashing iteration after iteration in webGL / JS and then finally struck what I feel like is absolute gold about a week ago. There was always a hint or a smell at 'topological black holes' in my simulations, but never a real presence. And then this happened.

Now in this clip, the most obvious happening is just once at the beginning. You can see singular bubbles form behind and around things, but its unclear what they are if anything significant other than just 'topological scars' becoming attractors due to the simulations behavior. Originally this clip was longer, but OBS will not allow me to have any peace at all, and I can't keep beating my head against the wall while it literally trashes footage over and over. But these are not the only 'topological gravity wells' in the sim.

When I play this sim on a pure run with no cross-over information from previous runs, I always get these objects. Every time. 2 step regime, 3 step, 1 step, always these. At higher tick rates though it gets crazy. I can't get recordings of those levels of the simulation because they're stuck at 2 fps.

---

Info below

The simulation is a fixed hidden matrix:

512 × 512 cells

4 floating-point channels per cell

S(x, y) = vec4(x, y, z, w)

The core in plain terms:

Difference tries to erase itself.

Erasure leaves a fold.

The fold creates new difference.

The new difference tries to erase itself.

Repeat.

That is the core loop: local difference, compression, phase rotation, bounded residue, recursion.

In this clip, the field is being allowed to fold twice per tick, which is why the early structure can move from bands into sink/aperture-looking forms and then into larger field anatomy.

That means each fixed simulation tick performs two full GPU substeps of the core update law. It is not a visual quality setting and not a particle-count setting. It changes how many times the organism metabolizes the rule before the next presented frame.

If I change the tick rate (step regime count) the entire simulation changes. There are many possible outcomes

I'm showing here what looks to be 'primordial topological black holes', whether they're literal black holes or maybe something else I haven't directly probed, I only just achieved this stage 2 nights ago if that.

I'm hoping this can reach some people who are interested in this kind of stuff, I think it looks promising, it looks cool. It might not be the answer to anything at all, or maybe its something useful in the long term. Either way, it took me a lot of work to build this simulation and many many iterations and failed attempts

Oh and the simulation itself. No rays, no real 'sim' or game engine. No 3D modeling, no 3D software. I used raytracing logic to calculate for angles for one particular viewing mode, but even there.. no rays bouncing around. This is all done in webGL, I host the simulations on a local server and run them in a browser on my macbook air. My poor macbook air. Lol.

I will post open source links to related repos in the comments.

The song in the video is Cradled Abyss by Joshua Kyan Aalampour

video starts just before the 3 second mark. I included the darkness because I want to emphasize, that's how the simulation starts.

The actual explanation of the architecture here is further below..

the TL:DR is... it works. It actually works as an emergent automata in an extremely basic almost offensively simple one-line form, but I over-engineered a scaffold for it to be even MORE emergent. If I can, I'll link a youtube video in the comments which shows a much smoother step-regime, albeit much more simple.

The way I had this built a few weeks ago was much more 'random' / non-deterministic and much less over-engineered.

There's a lot of stuff going on here which I'd consider proprietary, given that it was born in my head as a child and I had to suffer this long to ever make anything of it. There's a special structure I came up with which is in a real sense a 'not-structure structure', and a lot of this ultimately revolves around trying to wire together physics and mythology which brings you back to the 'undifferentiated' again and again.. and again.

'Difference tries to erase itself but erasure makes a difference'
That's the core loop in English.

You don't need any of the proprietary stuff for that core loop to be an automata.

I had other issues though over the last year of trying to really build this once and for all. Many. One of the most interesting is the singularity...

Yes you're reading that right.. my 4D cellular automata discovered a fucking singularity. And it's not just in one path, it's all over the place. It's some strange self-tapered explosion which happens in such a way that it cancels out the entire system.

I came up with a neat trick to make the simulation 'tokenize' the... thing(?) instantly. No hard adaptations with logic, just the ability to fold up a singularity at just the right time.. you can just.. shrink it until its nothing and keep it as a token (I know I'm using this word token and nobody will know why, and like I said proprietary technology. This thing works on its own, but I over-engineered it.. because I can). From a data perspective, works like a fucking charm.

You won't see it in the video, I included what I thought was the best intersection of visible 'footage' and something actually amazing to look at. What you're seeing there is an 'escher view' that I set up to get a better look at the self-wrapped space. It's really just some sort of hyper-dimensional sphere rendered as a 2d square.

Now let me be clear about this token thing before the rest of this post. There's no AI in here. BUT. It is... on the edge of smart. And I gave it a way to train itself. Think of it like, making analog hardware and software loops inside a digital reality. All (pretty much entirely) using simple one-line changes, rewirings, nested autonomy and weird tricks.

\ I'm taking this entire explanation out. I haven't seen not even one single person appreciate it. Just complaints, and attacks on the legitimacy of the generator. I didn't program these shapes, I didn't program any geometry soft or hard, I only programmed a zero-sum lattice and a bunch of self-wrapping rules. But noone cares. It feels an awful lot like people trying to get me to give them more of my work, while validating it less. And then I'll turn around in a year and see everyone making simulations like mine. I don't think so. Somehow, everyone is acting like I've done nothing unique or special whatsoever. Even just on its principle as a visual generator, let alone something with emergent 'physics like' behavior.

So I don't want to hear it. I had used my agent to pull the relevant code from the core without giving away too much sauce. But that didn't work. I'll be clear here, every word in this post is WRITTEN by me. Letter by letter.

I designed this simulator, I oversaw the coding over a period of a year, I've done tons of manual labor on this thing.

Oh the music is The Forsaken Waltz | Joshua Kyan Aalampour special master edition 1MPT v2. That's One Million Piano Tiles on YouTube