Capture the microphone, a camera, or whatever the Mac is playing, with no virtual audio driver. Frequency bands drive levels; an onset detector turns kicks, snares and hats into triggers.
The agentic node editor for live visual effects
Explore at the speed of prompts. Refine with the precision of code.
* demo video disclaimer
In the interest of conveying a point and being fun to watch, the videos have been edited and often cut or sped up. The viewport rendering always runs in real time. Depending on your underlying AI provider settings, things can go much faster... or take a while - but you probably already know this :-)
01 · describe
Say what you want. It divides and conquers.
A Director agent reads your prompt, splits it into typed nodes and wires them together. Each node draws its own interface from that contract before a line of code exists. Then the Director dispatches a coding agent to every node at once, each one implementing its own file in parallel.
02 · iterate
Chat with a node. It generates its own UI.
One chat runs the whole project, and you reach a node by @mentioning it. Attach files by dropping, pasting or picking them, and @mention any node, or the whole project, to pull it into context. Ask for a control and the node builds the interface for it alongside the code: UI generated from context, not picked from a palette.
03 · combine
Wire an idea into a running graph.
Half your canvas can be finished code while the other half is still a sentence. A prompt node is a node that does not exist yet. Wire it into nodes that already render, and grow the graph where the picture is already moving. Compile isolation keeps it safe: a node that fails to build never takes the rest down.
04 · own it
Every node is code you own.
Work at whichever level the problem deserves. Stay high and prompt the node into shape, or drop all the way down and open its source. Change a constant, save, and it hot reloads. Nothing is a black box, and moving between the two levels costs you nothing.
but wait, there’s more
Press Learn, move a knob on your controller, and it binds to the port you pointed at. Every parameter an agent generates is a hardware target.
One press on the record dot saves a take. Frame it with a crop overlay first, mix in the app or the system sound, and find it in the project’s recordings.
Drag an image or a video onto the graph. It arrives as a wired source node, copied into the project so the project travels whole.
Ask for one node to become two, or for two to fold back into one. The agents work out where the seam goes, and every constituent keeps rendering.
Read the source, fork it, write your own nodes. What you make in SubjectiveZero is yours: client work, commercial productions and live shows need no separate licence.
SubjectiveZero ships no model and resells no tokens. It drives the coding agent you already pay for, so your prompts and your code stay on your machine. A routing profile decides which model does which kind of work, so routine tasks stop paying for the top tier.
Codex
Claude Code
Grok
Pi
OpenCodelearn it in one sitting
Build your first effect, start to finish.
Thirteen unhurried minutes from an empty project to a running effect: a prompt becomes a graph, the graph becomes a picture, and a control gets added by asking for it. Watch it once and you can do it yourself.
questions
How is this different from TouchDesigner or vvvv?
The node graph is the familiar part. The difference is that you do not hunt for an operator and wire it by hand. You describe the effect, and a coding agent writes a node that implements it in native code. There is no fixed operator library to outgrow: a node is whatever the agent can compile, and you can open and edit every line of it.
Does it work with my existing Claude Code, Codex, Grok, Pi, OpenCode or Muse Code subscription?
Yes. SubjectiveZero drives the coding-agent CLI you already have, using your own account and your own rate limits. It does not ship a model or resell tokens. Claude Code, Codex, Grok, Pi, OpenCode and Muse Code are all supported, and a routing profile can hand routine work to a cheaper model so only the hard parts pay for the top tier.
What does it actually generate, and can I edit the code?
Real Swift and Metal, one implementation per node. Every node is editable source you can open and change by hand; the agent and your edits operate on the same files. The render itself you can record straight from the viewport, framed and with sound, as a video file in your project. Exporting an effect as a standalone app is not there yet.
Can I use it for commercial work?
Yes. What you make in SubjectiveZero is yours: nodes, graphs and projects authored with the app are explicitly not covered by the AGPL, so client work, commercial productions and live shows need no separate licence. The licence applies to the app itself, not to your work.
What happens when a node fails to compile?
Nodes compile in isolation. A node that fails to build is contained, and the rest of the graph keeps rendering, so a broken shader never blanks your whole scene.
How fast is the edit-to-pixels loop?
The app watches your node source and hot-reloads on change, polling file modification times roughly every 300 milliseconds. There is no manual rebuild and no restart.
Can audio or dragged-in media drive the visuals?
Yes. A Microphone or System Audio node captures sound, the whole Mac mix or a single app, with no virtual audio driver to install. Frequency bands turn it into levels, and an Onset Detector turns it into kick, snare and hat triggers, so visuals hit on the beat instead of wobbling with the volume. Any of those outputs can drive any parameter in the graph. You can also drag images or video onto the canvas and they arrive as source nodes, copied into the project so it travels whole.
Can I play it live from a MIDI controller?
Yes. MIDI and OSC input nodes bind hardware to any port in the graph: press Learn, move a knob or fader, and it is wired to the parameter you pointed at. Every control an agent generates is a hardware target from that moment on.
What are the system requirements?
macOS 15.0 or later on an Apple Silicon or Intel Mac, plus one supported coding agent: the Claude Code, Codex, Grok, Pi, OpenCode or Muse Code CLI. The current beta is 0.4.0.
Is it available on Windows or Linux?
Not yet. SubjectiveZero is an early prototype and currently a native macOS app. Depending on interest from the community, versions for other platforms will absolutely be considered.
Is this an Electron app?
No. SubjectiveZero is native through and through: SwiftUI for the interface, Metal for the renderer, Swift for the nodes. Part of the point of agentic coding is that going fully native no longer costs extra, so we did.
Is it "SubjectiveZero" or "Subjective Zero"?
The app is written as one word, SubjectiveZero, and shortened to SubZ. "Subjective Zero" is the same product.