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)

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/

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

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?

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).

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