Recently I've been exploring how simple rules can create lifelike emergent beauty. Under the hood there is a 28,000 agent simulation with seasonal migratory and reproductive behaviour.

Looks neat! I also made an app that sort of does that with camera

hey cool effect! is it done in compute

Yes, you can check it out here: (:

1) what 2) cool

That is visually a very nice idea to have the quadrants cells of the newly divided Octree flash white like that, I'm making mine evalute faster & have the camera fly into it like a canyon mandelbrot set style.

What do the different size square mean? What does the fill mean? How does it connect to Conway's version?

Hey Wil, its unrelated to conways game - just similar aesthetics. The smaller the cube, the greater density of the agents, then they move away from a section the grid 'undivides' and when you have lots of tiny cubes there is a large density of agents there.

Cool stuff. In case you haven’t, you should look into Conways game of life there’s tons of stuff on this topic - big rabbit hole of mine 20 years ago. Also fractals of course and visualizing ant colony optimization algorithms. There’s also very cool stuff on bird swarm simulation - murmurarion and crowd simulation. Same principle - simple local behavior leading to beautiful emergent behavior. Happy coding!

C'est beau

It’s beautiful Simon!

Thank you Anna 🖤

can you explain some of the rules? Like, why is the quadtree splitting and merging etc? It looks amazing

yeah man there are 28k 'individual agents' on the grid, attracted or repelled based on current 'season', with a bit of herding logic also. the quadtree represents agent density - many small squares means many agents, subdiving to make room, and then rejoining when they leave. runs 60fps realtime thanks to webgpu compute

ah so the bigger squares are big "heards" and then they split into multiple based on seasons?

actually the other way around -> no agents = big square, otherwise subdivide to represent the herds

yesss exactly

this is so insanely cool ! dropping a follow to see what you’ll come up with next :))

@marcinignac 28,000 agents? Hmm

@marcinignac 'agents' meaning: - individual actor computing its own outcomes not: - ai agent running an llm. its a simple algo running in compute shaders :D

@lush_amorelli @marcinignac yeah soz i take the L on this, i was coming out of a meeting only had LLM's on brain hahaha - apologies my guy

@lush_amorelli @marcinignac i think we are all a bit LLM brained atm. thanks for saying it’s a cool pattern 😎😎

Bit beautiful! Yet, real human compute seems to have some fuzzy edges and logic, that may not be represented in simulations like these.

Good place to be. Complexity arises from simplicity.

🪽🖤🖤🪽

Ahh yes the agents of just being a fucking square... you're allow to say you made a cool pattern based on an algorithm

🥱

Itu adalh fibonnaci, aku baru saja memikirkannya, sekarang ini muncul di timeline🤣🤣🤣

looks like cellular automaton

Literally working on likewise projects, exploring gen art as something absolutely astonishing and fundamental to understand the laws of the universe. And build it yourself.. kinda. :D

hell yeah - very nice!

Yep, it is beautiful - like Life 🌿

It looks like Archean life making bacon!

This is the magic: simple local rules, then consequences you can actually watch. We are exploring that in a restaurant city—agents price, stock, hire, expand, and learn from the rush.

Check out

Looks like my brain

How many of those 28,000 agents are just vibing and ignoring the migration rules?

28k is wild

The emergent beauty is mesmerizing indeed. But what are the agents simulating? What are the rules?

what happens with fixed seeds, because emergent beauty often hides brittle parameter tuning

How about you find an efficient system for a growing and evolving system, then interpret the behavior into a agentic workflow to self improve your “agentic brain”? 🤔

cc @mZargham

Yes makes sense

Hello, could you share a paper or a light documentation of it, with the theory, I'd would be highly interested in understanding.

what do you use for the simulation?

compute shaders in webgpu

that's cool, thanks simon

That's so cool the way simple rules can give rise to complex patterns and behaviors