Wire a live microphone or a camera into the graph. Either one can drive any parameter in it.
Explore at the speed of prompts. Refine with the precision of code.
Build live visual effects where every node is real, editable code, written by the coding agents you already run.
Open source. macOS 15.0+. Works with Claude Code or Codex.
* 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.
Every node has a chat tab that works the way Codex and Claude Code already do. 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
Drag an image or a video onto the graph. It arrives as a wired source node.
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.
Codex
Claude Codequestions
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 or Codex 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 and Codex are supported today; OpenCode and Pi are coming.
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. For now the output lives inside the app: exporting rendered video, or your effect as a standalone app, is not there yet — both are coming.
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 node feeds an audio-fft node, which feeds an audio-bands node exposing ten band outputs, and any of those can drive any parameter in the graph. You can also drag images or video onto the canvas and they arrive as source nodes.
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 CLI or the Codex CLI. The current beta is 0.2.1.
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.