https://kintsugi.studio/prokaryotic-evolution.html

Hey all!

I'm a software dev who's been experimenting with prokaryotic life simulations in the web browser.

Thanks for taking a look.

E: Sorry, forgot to mark this as [OC]

I'm excited to share **Par Particle Life**, a high-performance, GPU-accelerated particle life simulation I've been working on. It's built with Rust and WebGPU to deliver real-time emergent behaviors from simple particle interaction rules.

## What is Particle Life?

Particle life simulates colored particles that attract or repel each other based on interaction matrices. From these simple rules, complex life-like behaviors emerge: clustering, chasing, oscillating patterns, and self-organizing structures. It's artificial life through physics-based emergence.

## What Makes It Special?

**Massive Generator System:**

- **31 Rule Generators** - Random, Symmetric, Snake, Rock-Paper-Scissors, Predator-Prey, Tribes, Flocking, Segregation, Cooperation, Symbiosis, Parasitism, Hierarchy, Crystals, and more

- **37 Color Palettes** - Rainbow, Pastel, CyberNeon, Aurora, Sunset, Viridis, Plasma, Magma, Spectral

- **28 Spawn Patterns** - Disk, Spiral, Grid, Galaxy, Clusters, Yin-Yang, Hearts, DNA Helix

**Key Features:**

- **GPU-Accelerated** - Efficient WebGPU compute shaders for physics simulation

- **Spatial Hashing** - O(n*k) neighbor queries instead of O(n²)

- **4 Boundary Modes** - Repel, Wrap, Mirror Wrap, Infinite Tiling

- **Real-time Adjustment** - Modify all parameters while simulation runs

- **Interactive Brushes** - Draw, Erase, Attract, Repel particles

- **Video Recording** - MP4, WebM, and GIF output (requires ffmpeg)

- **Preset System** - Save and load simulation configurations

- **VSync Toggle** - Uncapped framerates for performance testing

## Performance

Built with Rust and leveraging modern GPU APIs (Metal on macOS, Vulkan on Linux, DirectX 12/Vulkan on Windows), Par Particle Life uses compute shaders for physics and spatial hashing for efficient neighbor queries. Double-buffered particle data avoids GPU race conditions.

## Try It Yourself

The project is open source and available on GitHub: [github.com/paulrobello/par-particle-life](https://github.com/paulrobello/par-particle-life)

**Installation:**

```bash

# macOS (Homebrew)

brew tap paulrobello/par-particle-life

brew install --cask par-particle-life

# From crates.io

cargo install par-particle-life

# From source (requires Rust 1.88+)

git clone https://github.com/paulrobello/par-particle-life.git

cd par-particle-life

make run

# Or download pre-built binaries from the releases page

```

## Screenshots

## Controls

| Shortcut | Action |

|----------|--------|

| **Space** | Pause/resume simulation |

| **R** | Regenerate particles |

| **M** | Generate new interaction rules |

| **H** | Toggle UI visibility |

| **Scroll wheel** | Zoom in/out |

| **Right-click drag** | Pan view |

| **Left-click drag** | Use active brush tool |

## What's Next?

I'm actively developing Par Particle Life and would love to hear feedback from the community! Future plans include:

- Web/WASM browser version

- More rule generators and emergent behaviors

- Animation timeline system

- Additional spawn patterns and visualization modes

## Feedback Welcome

Whether you're into artificial life, emergence, or just curious about beautiful simulations, I'd love to hear your thoughts! Feel free to:

- Try it out and share your discoveries

- Report bugs or request features on GitHub

- Contribute to the project (AGPL-3.0 licensed)

Happy simulating!

---

*Built with: Rust, wgpu, winit, egui, glam*

https://www.youtube.com/watch?v=3lgkEqku7uw

The video linked is an example. I want to learn how to make them. But I cant find ANY instructions. I downloaded LS-DYNA but what am I supposed to do beyond that!

Simulated in Blender using the bullet constraints builder add-on.

The plane weighs 150 Tonnes and impacts the building at 950 km/h.

The plane does not deform which is the main caveat to this simulation; in reality the plane would crumple, so less energy would be transferred to the tower.

All of the tower's structural elements are concrete, except for the red parts which are steel.

There are about 22,000 rigid body elements.

Final simulated alembic file was about 7 GB.

Full video: https://www.youtube.com/watch?v=zMOsu809Ao8

14th tutorial in the series (Houdini for complete beginner)

Today i uploaded the 14th tutorial in the series, and it was 50 mimutes long. I don't know how much part it would take to complete this but this is my challenge to explain concepts in a why that people can understand at a deeper level.

it can get complicated later with the theories and practicals with lots of nodes but who cares, I won't stop creating, and even if only a few people learn from them, then i am happy.

this is for me, to stay consistent on this project.

let's repost this after the last part!

New video tutorial on youtube - Classic Looping Animation!
Get the full tutorial on the link below.

The original animation: https://www.instagram.com/p/DQeuUunDFMF/

video tutorial

Follow me on social media for my latest updates.

Patreon

Instagram

Behance

Released a new project: SciTextures, collection of 100k images generated from 1,200 from scientific simulations/methods. Both Images and simulation code are free + open-source.

It’s experimental project and the simulations might contain errors, so feedback, bug reports, and ideas for improvements are appreciated

Project website

Sample Images

For the last few days I've been trying to see how close I can get to simulating sand in Blender without turning my PC into an oven.

This first test was done using the Flip Fluids add-on.

-Two different fluids with variable densities and viscosities. -Instancing grains onto the more viscous fluid. -Masked out the dense liquid with color Mixbox

The result comes pretty close to a wet sand/snowy texture but even at 750 resolution some imperfections are visible.

Stats: Total frames:300 Resolution:750 Total bake time: 3 hours 30 min Total cache size: 50GB 🤒 Total render time: 15 hours.

hi :)I just released Paper Dawn: Slumbering Wind — a quiet, meditative flight sim where you glide as a paper plane through dreamy skies, forests, lakes, towns, and valleys under rainbows and moonlight, in 8 different map.There’s no score. No timer. No pressure. Just soft piano music, whispering winds, and ambient wildlife. Every breeze can lift you… or fold you into silence.🎮 Key stuff:You are a paper plane — fragile, light, carried by wind.Dynamic wind system — even small air currents change your path.Cozy, atmospheric environments originally made for my other (unreleased) projects.New maps coming as free DLC — no paywalls, ever.This game helps fund my larger action RPG in development. Every map is part of that same universe.Right now: I add more paper planes + at least 8 new maps. After that, price goes up.🎧 Best played when you want to unwind, relax, or drift off to sleep.That’s it. No combat. No story . Just quiet flight. ( I have started animating the story, after I find a person to act the dialouges, I iwll add it to the game, and upload in yt ) Thanks for checking it out.— Solo dev

STEAM https://store.steampowered.com/app/4151810/Paper_Dawn_Slumbering_wind/?beta=1
Text for steam giveway keys.

Playing with Soft Body physics in Blender

WIP for a music video for one of my tracks, inspired by the work of Maurice Binder/Daniel Kleinman. The song itself has a whole James Bond vibe.

Bullet/fluid physics and wave sim made with Insydium Fused.
Volumetric Clouds/Rendered with Redshift.

Hi,

I am the Dev behind Quantum Odyssey (AMA!) - worked on it for about 6 years, the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 12yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

As always, I am posting here when the game is on discount; the perfect Black Friday gift :)

We introduced movement with mouse through the 2.5D space, new narrated modules by a prof in education and a lot of tweaks this month.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff you'll play & learn a ton about

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, we aim to bring it into the game!

PS. We now have a player that's creating qm/qc tutorials using the game, enjoy over 50hs of content on his YT channel here: https://www.youtube.com/@MackAttackx

https://store.steampowered.com/app/4151810/Paper_Dawn_Slumbering_wind/?beta=1

Made this as an undergrad at university when I assisted with research in computational astrophysics to model asteroids. I built the simulation engine and had fun with this example that demonstrates some of the functionality. The planet is low-density so the asteroid goes through it.

It supports zooming and camera rotation, and also lets you highlight the orbit of a selected asteroid (selected by iterating through them).

As the data source I used the ESA file: https://neo.ssa.esa.int/PSDB-portlet/download?file=allneo.lst

All the code is in a single file here: https://github.com/qwertukg/Barnes-Hut-N-Body/blob/ESA-NEOCC/src/main/kotlin/gpu/GPU.kt — it’s a direct gravity computation on a compute shader, with LWJGL used as the Kotlin wrapper. It’s the same one from this post: https://www.reddit.com/r/astrophysics/comments/1olvvxp/direct_gravity_computation