Made in TouchDesigner (sorry the flair doesn't exist) as part of the POPtober challenge. Today: field POP

Planetary scale explosion created using various assets from Kris Brad
https://www.instagram.com/kris_bradd/

We're continuing to do more R&D for our upcoming release of EmberGen 2 and these are a few explosions I did today that I thought were interesting enough to compile into a little video. Forgive the flickering at the start, we're still having some auto-exposure issues with our camera.

I was reading up on Newton for something I'm working on and realised nearly everything I could find was launch coverage or NVIDIA's own blog.

Barely anyone talking about actually using it. So I ended up going through the release notes myself.

If you haven't been following, the Newton physics engine hit 1.0 at GTC in March. It's the open-source engine NVIDIA built with DeepMind and Disney Research, and Isaac Lab 3.0 lets you swap it in as the physics backend instead of PhysX. MuJoCo Warp for rigid bodies, a separate solver for cables and cloth, and hydroelastic contact from Drake, which in theory should help a lot with insertion.

NVIDIA's number was 475x faster than MJX on manipulation. That was on their newest Blackwell workstation card though, so I'm not reading too much into it. The one independent benchmark I found (GPUSimBench, from July) didn't have a clear winner, it changed depending on the scenario.

What I actually found more interesting was the 1.1.0 changelog. A big chunk of it is import fixes. Mass and inertia, fixed joints, joint properties not parsing right between USD, URDF and MJCF.

Which kind of matters if the whole point is running one environment on different physics backends? If the inertia comes in slightly different on each one you've got a slightly different robot, and you probably won't notice until something doesn't transfer.

This is a problem we deal with at work. I'm at Rigyd, where we convert 3D models, Images and Text descriptions into simulation-ready USD and MJCF assets for Isaac Sim and MuJoCo, with the collision meshes, mass and inertia set up so the same asset behaves the same across engines.

So I'm biased toward thinking import is the bigger story than the speedup.

Skild is apparently using Newton for connector insertion and Samsung for cable handling with Lightwheel, but those are announced partnerships. I haven't seen anyone else write up switching over from PhysX.

So if you've tried it, did contact-heavy stuff actually transfer better or was it mostly faster? And how much did you have to retune assets that were already set up for PhysX?

Also if anyone's seen the same task run on PhysX and Newton with real robot results, please link it, would love to go through it

Custom physics sim written in JAX (waves, wind, grid fins, fuel slosh), rendered in three.js. Not AI-generated video: every booster you see is a real simulated attempt from the agent’s training.

One Houdini node that builds a human body in real units (age in years, height in cm, weight in kg) and animates it from a sentence.

- Body: open-source SOMA and Anny body models, solved to hit the exact height and weight

- Shape: gender, muscle, breasts, buttocks, surface smoothing

- Motion: NVIDIA Kimodo text-to-motion, running locally on my GPU

- Path: draw a curve, and Kimodo generates the motion on it

Built by Alaa Belghith, working as Anything Visual.

Music: "Raving Energy" Kevin MacLeod (incompetech.com), licensed under Creative Commons: By Attribution 4.0 License

Hi, I'm the developer of LIT Creature Forge, a small Windows sandbox on Steam inspired by Karl Sims' 1994 evolving virtual creatures.

Each run starts with random segmented bodies and controllers. Creatures are evaluated, the better performers reproduce, and mutation and crossover change both their bodies and how they move. The gaits evolve along with the body plans.

Version 1.1 adds swimmers and competition over a cube, alongside the original land locomotion. This clip replays a saved swimming champion after evolution. Swimming uses Sims-style analytical drag, with the articulated bodies simulated in MuJoCo.

You can change the population size, trial duration and gravity, save champions, and replay them in a separate showcase. There is no creature editor, so you get to see what evolution comes up with from the starting population.

I thought it might interest people here who enjoy evolved morphology and locomotion. The Steam page has more footage and details about the sandbox:

https://store.steampowered.com/app/4701600/LIT_Creature_Forge/

The boat isn’t animated: everything is computed in real time in Swift (SceneKit), from the forces on the boat. Wind on the mainsail and jib (trim, reefing, apparent wind), heel, leeway, rudder, engine thrust, and waves that the hull rides. In the clip you can see a tack: the sails luff head to wind and fill again on the other side.

The 3D models, sea and sky are drawn in code too. No AI-generated graphics or video. Coast and harbours come from OpenStreetMap.

Free, no ads, no data collection. Mac, iPhone and iPad, English and Spanish.

https://apps.apple.com/app/id6822390196

Next step after the dividing cells: each amoeba is a bubble of the same foam rule. Its skin pulls taut and it keeps its area. On top of that its edge reaches out:

- By smell: food gives off a smell that spreads and fades. The edge bulges where the smell is stronger than its own average, so a pseudopod reaches towards food and the back pulls in. In blind mode it wanders at random and only finds food by touching it.

- Eat, grow, divide, starve: what it eats becomes area. Living burns that area away. At twice its size it divides, and starved to a third it dies.

Try it: https://geotyper.github.io/taut/amoeba.html

Try it: https://kerr-black-hole-roan.vercel.app

Real-time general-relativistic ray tracing. The disk brightens on the side moving toward you, reddens near the hole, and the stars behind it bend into an Einstein ring. Drag to orbit, scroll to zoom.

Built with Claude Code (Opus 5.5). Code: https://github.com/SkyWalkerPS/kerr-black-hole

I'm the creator of Cbirds, a bird flock simulator that runs in the terminal, written in C99 with no dependencies and inspired by Craig Reynolds' Boids algorithm. This is its 3D mode, running in Ghostty on macOS.

How the 3D flock works: each bird only listens to its nearest neighbours, seven by default as real starlings do, instead of everyone within a radius. On top of Reynolds' three rules (alignment, cohesion, separation) there is a pull toward a roost that keeps the flock in view, and a slow drift in the air over the roost. The bands, the splits and the folds in the video all come out of those rules. The camera goes once round the flock every two minutes, and nearer birds are drawn bigger and brighter.

Everything is simulated and drawn on the CPU and sent to the terminal as images through the Kitty graphics protocol. The panel in the corner shows what a frame costs: in this clip about 15 ms to simulate, draw and send, about 54 KB to the terminal, at 59 fps. The sliders tune the simulation while it runs.

I started the 2D version in September 2025, mostly out of curiosity, after seeing antirez's C64 terminal emulator (https://github.com/antirez/c64-kitty) and a lecture by Pier Luca Lanzi on multi agent systems at Politecnico di Milano. I did get quite a bit of help from coding agents along the way. One useful thing I ended up building was a custom GIF encoder, so the agents could visually inspect the simulation and check whether their changes worked.

It also has hawks that chase the flock, multiple flocks that merge or avoid each other, text piped in that takes flight (`cat file.txt | cbirds`), Braille rendering for any terminal, and birds that fly between terminal windows.

Source: https://github.com/clainstone/cbirds
Command: `cbirds --render kitty --3d --color prism`
Install: `brew install clainstone/tap/cbirds` (also MacPorts, apt and Nix)

Hey guys! Quick update on my renderer, which I've been working on and off for the past 7–8 months or so.

The library is quite opinionated about DOD (data-oriented design) and the explicit nature of WebGPU, and I've recently added support for neural inference and training.

1. Neural networks for agent behavior

You can now train small neural networks (MLPs), around 1–4 layers deep, using supervised learning directly as part of the library.

In the herd and wolves example below, the agents have simple behavioral rules, like chasing prey when it's nearby or fleeing when a predator gets close. The idea is to train a small model to learn these behaviors and then use it to drive the agents.

For this example, we're talking about a model with roughly 2,000 weights, so obviously not a general-purpose AI model, but enough for these kinds of behaviors.

The library also supports ONNX Runtime for working with larger models or models trained externally with something like PyTorch. For these smaller, more specialized models, though, the built-in MLP implementation will generally be faster in my use case.

Live demo (WebGPU-supported browsers only):

https://nullgraph.dev/dashboard/agents/herd-wolves-gpu

Github

https://github.com/flarelink-in/NullGraph

1. Offline rendering and simulation baking

Another feature I've been working on is offline rendering, with a workflow somewhat similar to what's available in tools like Blender or Houdini.

It's split into two phases:

\- Compute records: Run the expensive simulation and bake the data that needs to be simulated.

\- Render records: Replay those records through the rendering execution chain using a screen texture, generating frames/tracks that can then be stitched together.

The goal is to handle simulations or visuals that would otherwise be too expensive to run in real time, or would take a long time to render, and then replay the result at 60 FPS.

I have a demo of this on my YouTube channel. The bake took up close to 30 GB of space, while the final result was around 500 MB.

Offline rendering demo:

https://youtu.be/pTD-7PCPGrg?si=vfENWIpR9YU-JEbZ

I've also added another demo to the video, this time focusing more on visual aesthetics rather than the science/simulation side.

1. What's next?

NullGraph exists as part of a larger web-native open-world simulation runtime that I work on from time to time.

Rightn now, I'm looking into improving my neural network implementation to better match or potentially outperform ONNX Runtime for my use cases. One of the things I've noticed is that the ONNX integration can introduce a 1–3 frame delay in my current setup, along with an additional runtime download of around 6.4 MB.

I'm also starting research into co-evolution, with the goal of bringing evolutionary learning and reinforcement learning into the runtime. The co-evolution approach draws on ideas from OpenAI research and the hall-of-fame technique. I've written some design docs for this, but I'll share more once there's a working implementation to show.

One thing I'd love to get your thoughts on:

Would you guys be interested in offline rendering driven by AI prompts directly in the browser? The idea is to let you generate demos or visually complex scenes through code, spend as much time as needed baking them locally, and then replay the results smoothly. I'm also exploring ways for the system to verify its own output rather than just blindly generating code.

I'm curious whether this kind of workflow would be useful to people working on creative coding, simulations, procedural graphics, or web-based experiences.

Let me know what you think!

After natural running, now more varied movement on different surfaces.

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

This is Little Bricks, a browser sandbox I made for Openbench. The horizontal demo shows building with toy bricks and then disturbing the structure with table shaking, a hammer and explosions. The falling blocks are simulated rather than keyframe-animated.

I am interested in how readable the physical behaviour feels: do unstable overhangs, toppling towers and chain collapses behave as you would expect?

Interactive demo: https://openbench.fun/bricks/, free, no installation or account. You can also save and load builds.

Development was AI-assisted; this is a recording of the running interactive simulation.

#LittleBricks #Physics #Simulation