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!

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

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

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

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/

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?

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

Instagram.com/sometimesdaily

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

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

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/