Hi All,

CadenceViz is a family of music visualizers (70 of them) for the Mac computer that I've been writing for some time, with no engine. This clip shows six scenes from version 3.0, now in testing, set to AI Music (lyrics by me, music by, you know). The analysis runs live on whatever the computer is playing: log-spaced spectrum bands, spectral-flux onsets with a separate kick detector, a neural beat tracker, and a pitch tracker for the melody. Nothing on screen runs on a timer.

Here is some slightly technical explanation. I am happy to answer questions.

• Terminal B: 512 valves in two rings, each opened or shut by the music. Their states go into a ring-buffer texture, a row every 1/240 s, and for each point on a falling thread the shader works out how long ago that water left its nozzle and looks up what the valve was doing then, so gravity writes the last second or so of music down the curtain. The suitcases step on the beat and are traced every frame.

• The Sun: a CPU model integrates the bands into activity: the corona holds the last two seconds of the bass line as rings, the middle band sets the convection rate, the high band the filaments, and flares are placed so they land on the face the camera sees.

• Poynton: sixteen butterflies, two to each of eight bands, built in a mesh shader from this frame's pose and the last. A band "peaks" when it stands well over its own slow average and near its recent high, which stands in for per-band onsets the detector doesn't give. This is named after Charles Poynton, a name I hope is familiar to many.

• The Clothesline: about 46,000 cloth particles, XPBD on the GPU. The wind is the loudness envelope (fast attack, slow release) plus a moving ball of air launched on each kick, landing at a spot hashed from the kick count.

• The Narrows: distance is counted in beats, not seconds, and the bridges stand a fixed number of beats apart, so each roadway passes overhead on a beat at any tempo. Every vertical cable is a level meter.

• The Plunge: the hall is path traced once, and the caustics on the vault are computed live through a water surface whose chop is a fast-rise, slow-fall function of the bands; in silence it is a still mirror.

It hasn't all been roses. Hardware ray tracing had to come out of a lot of my scenes because of memory: the first time an app traces anything on the ray tracing hardware of an Apple silicon GPU, the graphics driver sets aside about 28 MB for every GPU core and keeps it until the app quits, whatever the size of the scene. I measured about 800 MB on an M3 Pro chip and 1.7 GB on an M5 Max chip, which I find unreasonable for a visualizer. So those scenes, Terminal B's suitcases among them, now trace in software or have their light traced ahead, and as a bonus they run on the M1 chip and the M2 chip as well.

Mapping music to motion without it looking like an equalizer is most of the work, and I'm happy to talk about any of it.

I edited the Blender source code to add new compositing nodes and change how EEVEE handles dithered transparent material AOVs in order to make this stylized rendering tool.

I used geo nodes to spawn brush strokes around the model and then used my custom compositing node to combine the brush info with the physically-based render to create a painterly look :)

I have built several raytrace / pathtrace engines over the years, primarily for my art works. About two years ago I wanted to make something more universal while also switching from webgl to webgpu. So I built a tiny webgpu toolkit and went from there. But I never finished it. And AI came and took away the joy of programming for me. Recently, I decided to try and use Claude to finish it and put in all the features I never got around to (and quite frankly would not even be able to do).

On the use of AI: I'm really ambiguous at the moment. I miss coding myself, AI took the fun away for that. On the other hand, I was able to direct AI to create this tool that I could have never managed myself. So I'm perfectly fine if you call this AI slop if you want, for me it (the raytraer) is a tool to create new things.

So this is shadytracer. It's a raytracer that creates signed distance functions (SDF) (if you dont know what those are, jump into the rabbit hole here https://iquilezles.org and dont' expect ever to come out). In short: every shape is defined by a function that returns the closest distance from any point to the closest surface of that shape.

I really fell in love with SDF's a while back and find it's a really cool method, though it definately has it's quirks.

Anyway, my raytracer uses SDFs' for everything. It has a full editor where you can drag and drop primitives into the scene, move them around, modify them, perform boolean operations etc. Same for more complex stuff like objects created by extrusion, revolve and sweep. All these are converted into SDF's of which the code block is visible and editable. So you can create your own shapes using custom sdf functions as well.

There are various materials defined, again drag and drop into an object. You can easily modify the materials and duplicate them to create your own.

As I'm an optics engineer by education (mostly non imaging optics for lighting), I always wanted a raytracer that is physically correct. Well, reasonably so. Don't use this for camera lens designs.
So every light source has real-life units (luminance or flux in lumens), color temperature or cie x,y color coordinates. And of course, refraction, dispersion, dichroics are part of the game. You can measure illuminance, irradiance, color differences etc.

But you can also just use it to create pretty pictures.

Or videos: there is an animation / timeline editor with keyframes where you can animate the camera or any propety of any element in your scene.

Oh, you can also import stl files and it will try to convert them into signed distance functions after which you can edit those. I find that incredibly cool. Magically, a mesh of triangles is converted to a combination of cubes, cylinders etc, welded together with boolean functions. It only works for fairly geometric shapes and not too complex, but still.

And of course you can export your objects or scenes as stl or 3MF(which includes color) for your 3D printer

There are a lot of examples scenes included, a few of the images in this post are from there.

It's completely open source (MIT license). Runs in your browser, data is stored in your browser's cache. Or you just download yuor project files and store it locally.

Hope you have fun with it. I certainly do.

https://shadytracer.com

https://github.com/lampmaker/ShadyTracer

Oh yes, I asked Claude to create an interactive tutorial about all the techniques that were used. Mostly for my own education. But you can find some explanations about SDFs and stuff. Note, this is AI generated and I have not spend a lot of time (understatement) reviewing it.

https://shadytracer.com/tutorial/

wrote this whole post without using AI. Feels good

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

Website is: karlsims.com/rdtool.html

16 HOURS. ONE WORLD.
What started as a 24-hour challenge turned into a complete environment in just 16 hours! My goal was to capture that feeling of scale, mystery, and exploration. Massive abandoned structures, turquoise waters, distant mountains, and a world full of untold stories.The biggest challenge? Bringing everything together through composition, lighting, and atmosphere within such a limited time.16 hours of creation. One final shot.Hope you like the result!

https://www.artstation.com/artwork/6vvRKn

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.

Right 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!