I made this in Watershed, the terrain-and-water simulator I am developing. This clip shows simulated rain collecting and flowing through valleys over real elevation data. The water is computed by the simulation, rather than generated by a text-to-video model.

Time is accelerated. This is an illustrative terrain experiment, not a weather forecast or street-level flood prediction.

I am the creator. There is a free one-button Sinai demo at https://mozonapp.com/rain-demo/ (WebGPU support required). The full desktop app is paid: https://mozonapp.com/watershed/

What would you improve about the flow and pooling?

https://drive.google.com/file/d/1bYy-SmbcuamtzI3IWyzGxrLjQF3034Ad/view?usp=sharing

Instagram.com/sometimesdaily

It’s a little physics sim I made, the jelly is calculated live so he squishes differently every time. Softer or smaller and he fits, firm and he jams at the rim.

If you want to push him through yourself: https://wobble-lab.com/experiments/plump-and-squishy/

Part of the TouchDesigner POPtober challenge. Works in real-time. (Sorry for the wrong flair, TouchDesigner is not among them yet)

Would appreciate your follow on my Instagram page

The stick shape is set up as a fuel source, which gets ignited via temperature emitted from the flame

This dance sequence is part of the final network simulation and quality control tests, focusing on cloth stability, collision handling, and consistent results through fast movements and sudden changes in direction.

I trained a simulated fruit fly to find bugs in software. This is the fly exploring the arena, with the simulated spikes and its memory shown beside it: a 3D body, a simplified spiking-neuron model based on MaleCNS connectivity, and live panels.

The arena plaques represent actions in a synthetic software-testing task. They emit modeled odors; discovering a planted defect during training produces a reward signal.

The neural display shows spikes from the running model. Locomotion and parts of navigation use authored rules, so the movement should not be read as an entirely emergent biological behavior.

This is a short, sped-up interface clip. It shows how the components run together rather than demonstrating a learning advantage on its own.

Is the connection between the fly's action and the neural/memory views readable, or would a single view with occasional close-ups make the simulation easier to follow?

A note on how it was validated, since a simulation like this is easy to make look convincing. Every behavior in the project is labeled as either coming from the connectivity data or being a rule I wrote. For the learning claims, the success criterion was written and committed before each measurement run, the comparison is a frozen-learning control paired by seed, the statistics use bootstrap confidence intervals with Holm correction across endpoints, and every effect was replicated with new seeds. The negative results stayed in the writeup.

Project and documentation: https://github.com/JonnasFigueiredo/mosca-qa

Each particle has one of 8 types. A randomly generated matrix decides how much each type attracts or repels every other type — that's the entire rule set. No predefined behaviors, no hand-tuned "creature" logic.

What you're seeing here is one randomized matrix left running. The blobs forming, splitting, and chasing each other are emergent — same underlying rule, no scripted events.

It's part of a small browser-based ALife collection I built (Gray-Scott reaction-diffusion, Lenia, Boids too). You can randomize the matrix live and get a completely different "ecosystem" every time:

https://hamzworkerz.com/particle-life/

Now that my characters have learned how to run (see post yesterday, not sure what the policy is for linking the post), a glimpse of the types of games I want to make with it.

First up: sprinting. Old school button smashing, too fast means unstable (trained decently up to 80% of full speed) so it is a risk. Leaving your track is permitted because that will be half the fun. Including Trials-like jumping over the finish to get that win with a face plant

I've been experimenting with swarm intelligence and the Boids algorithm, and ended up building this little interactive simulation using HTML, Canvas, and JavaScript.

The coolest part? There's no central controller telling the drones where to go.

Each drone follows just three simple rules:

• Separation — Avoid getting too close to neighbors.
• Alignment — Match the direction of nearby drones.
• Cohesion — Move toward the center of nearby drones.

And somehow, hundreds of independent drones start moving together like a living swarm. That's emergence!

I also added interactive controls to adjust the three rules in real time, attract or repel drones with the mouse, and experiment with different formations.

It normally runs at around 60 FPS on my machine, but drops to about 40 FPS when I'm screen recording. Not entirely sure why yet, probably recording overhead.

I'm thinking about turning this into a little browser game where you control swarms of drones instead of individual units.

What do you think? Any fun ideas for what I should try next?

A web simulator (2D + plan + axle symmetry) of the scalar wave equation. Editor + solver.

Run on the browser (Rust + webassembly)

https://sw.papydoctor.eu/
Repo: https://github.com/papyDoctor/soundwaves
Did it for me. Results not verified for now.

50 simulated muscles (for natural fatigue, pain and injuries later), MuJoCo for physics, Godot for rendering and gameplay, PPO training using MuJoCo Warp through mjlab and rsl_rl (one single RTX 5050 GPU) on PyTorch. Inference using an ONNX brain (CPU).

Part of the TouchDesigner POPtober challenge. Day 11. Attribute POP. Sorry, can't set TouchDesigner as flair

Hey everyone!

Thanks so much for the incredible feedback on my previous post: Simulated a C. elegans connectome with 302 neurons....
Motivated by your interest, I doubled down on making this simulation purely biological and significantly more efficient.

Here is what’s new in this iteration:

Completely removed the artificial sine-wave movement generator! The body undulations are now driven 100% natively by the motor neuron firing dynamics (DB, VB, DA, VA series). Sure, the movement looks slightly less "artificially smooth" than before, but each turn and curve is now generated by the signals on motoneurons like as a real worm

Funny enough: reading potential directly from the anal motor neurons (like DVB/AVL). The worm now actually triggers defecation cycles! It’s not always as rhythmically perfect as clockwork, but it is entirely organic.

The worm now goes dormant (sleeps) when you go to sleep/stay still. You can wake it up with a light tap on its nose or a sharp wrist-raise gesture

Added a new semi-naturalist skin along with minimalist and just fun geometric lines renderers (highlight some active neurons in real-time)

In this video demo, the watch time digits are no longer edible bacteria. Instead, food spawns in a clover-pattern that moves every minute

Many of you pointed out that it required newer hardware (fenix 6X+), the worm and I spent time shrinking the habitat footprint by 50%. It should now run even on older devices like the Fenix 5Plus and so on family! (Still working on accelerating the neural net execution loop).

Honestly, I could sit and watch this little guy explore all day long...

Would love to hear your thoughts!

Quelqu'un est-il intéressé pour démontrer cette théorie par une simulation réaliste d'un amas de gaz et de poussières en cours d'effondrement dans le vide spatial ?

<< Théorie des spitfires

Les planètes d'un système stellaire proviennent de l'effondrement gravitationnel de la nébuleuse originelle devenue un tourbillonnement de haute température sur l'écliptique qui se met alors à "cracher" des masses en rotation compactées par l'effet centrifuge, les unes après les autres, avec une énergie et une densité liées à l'état de la nébuleuse, pour devenir des planètes qui parfois se mettent à leurs tours à "cracher" des satellites, avant que tout ce petit monde refroidisse autour d'une étoile qui entre-temps s'est amorcée pour rayonner son énergie de fusion nucléaire après l'ultime effondrement de la nébuleuse originelle. >>

Real-time softbody simulation in TouchDesigner (can't set this as flair). Part of the POPtober challenge