Systems Deep Dive · Current as of ISO week 2026-30
Organon is a real-time generative visual engine that lives inside a DAW — and keeps its renderer in a separate process.
One Rust crate compiles into seven binaries. A thin plugin writes an eight-kilobyte snapshot; a second process owns the clocks, the camera, twenty-seven mathematical generators and the entire GPU pipeline. The thing being lit is not a mesh someone modelled — it is the output of a parametric system evaluated fresh every frame. This report dissects the whole machine: the contract, the generators, the light stack, the honesty ledger — and where the seams are.
Single fact source: the project’s own architecture record, graded primary · Technical Overview, July 2026 · Preserves hedged wording; in-flight work marked as such
§0 · Key findings
Three decisions explain everything else in the system: it lives inside a DAW, its renderer is a separate OS process, and its physically based light transport is pointed at mathematics rather than at modelled meshes.
Organon ships as a VST3/CLAP audio plugin. Every one of its ≈1,370 parameters is host-automatable, MIDI-learnable and preset-captured, and the host supplies tempo and transport for free. The plugin itself is thin: a second binary owns the fullscreen window, the animation clocks, the camera and the whole render pipeline, and the two communicate through a shared-memory snapshot of about 8 KB, written once per audio block and read once per frame.
What that pipeline renders is the output of 27 interchangeable generators behind one geometry contract — from the founding cube field of 2000 to Maxwell fields, aperiodic tilings, arbitrary field equations with a PDE solver, and the live internals of a language model. The founding algorithm is still generator zero; everything else grew around it.
§1 · What Organon is
A DAW plugin, a two-process architecture, and a physically based renderer whose subject is a parametric mathematical system.
It lives inside a host
The product is a VST3/CLAP plugin (plus a standalone build of the same editor).
Every parameter is host-automatable, MIDI-learnable and preset-captured; the host keeps native ownership of automation, mapping and MIDI learn, and supplies tempo and transport for free.
Hover for the full story
Two processes, one snapshot
The plugin is a thin control surface; a second binary owns the window and the render pipeline.
They communicate through a shared-memory snapshot the plugin writes once per audio block and the visual reads once per frame. A reverse channel carries resolution, frame rate, GPU timing and capability flags back to the editor.
Hover for the full story
Light transport, pointed at math
The thing being lit is a generator’s output — a parametric system evaluated fresh every frame.
Metallic-roughness Cook–Torrance under split-sum IBL, a computed atmosphere, hardware ray tracing, a spectral path tracer and an SVGF + neural denoising ladder — all behind one generator-agnostic pipeline.
Hover for the full story
Two deliverables share the algorithm: the native crate — the current focus and the live visual — and the web port, whose original React-Three-Fiber app still runs the old form of the algorithm and has diverged; a WebGPU rewrite is a separate, in-progress line of work. Everything in this report describes the native engine unless stated otherwise.
Organon (the visualizer) and Organon Mind (a standalone instrument for analysing local language models) are the same crate with a different front-of-house, selected at build time by a cargo feature. This is an edition, not a fork: the algorithm, every shader, the snapshot layout, the preset store and the visual binary are byte-identical between them. An edition drives exactly three things — the product name, the IPC namespace, and which editor tabs are visible.
§2 · Shape of the system
A plugin cannot set its own parameters from the audio thread — so anything that must drive the look at audio rate bypasses the host parameter layer and writes the shared snapshot directly.
The snapshot is a flat, C-layout, plain-old-data struct memory-mapped into a file. It is append-only: new features add blocks at the end and existing offsets never move, which is what lets a running plugin and a running visual survive a rebuild of one side. When an incompatible change is genuinely needed, a layout version is bumped and both binaries are rebuilt together. Golden tests pin the struct size, key offsets and a hash of the entire default snapshot — so a refactor that claims to be byte-identical has to prove it.
Two further channels stay off the snapshot on purpose, because their rates are wrong for a control-rate block: an activation ring carrying per-token LLM activations, and an audio sample ring streaming the plugin’s post-synth stereo output to the visual’s recorder.
§3 · The control layer
The packing from parameters into the snapshot used to be hand-written twice; it is now generated from one ordered slot table — and that same table generates the action catalog the AI agent speaks.
A preset is the complete serializable parameter state, recalled through the host’s parameter setter so it is automation-recordable and undoable. Three details matter: atomic recall (a sequence-lock makes the visual see the new look in one step rather than half-applied states), a tab partition (the editor’s tabs partition the preset state, so you can recall a whole Scene and swap a different Look on top), and beat-quantized recall scheduled to the next bar or beat boundary — which is what makes preset changes musical rather than jarring.
The audio thread’s process() is allocation-free throughout: pre-allocated state, lock-free reads, atomics.
§4 · The generator system
A generator emits strands — ordered polylines of oriented frames — and declares a topology. Everything downstream is generator-agnostic, which is the property that makes the engine’s breadth affordable.
Most generators are a pure function of (parameters, phase), evaluated fresh each frame and unit-tested offline. A few carry persistent simulation state — flocking, the soft-body bell, the neural cascade — and the pattern for those is settled: the visual owns the simulation, rebuilds it on a structural change, and steps it before laying geometry. A handful are not node fields at all: per-pixel raymarched, on sibling render paths that still share the whole PBR/IBL/HDR/camera/beat stack.
The organic motion in generator zero comes from two things a naïve port gets wrong. Rotate, then translate: translation happens inside the already-rotated frame, so every step is a small screw motion and a loop whose rotation grows with its index sweeps its nodes around an arc — spirals, coils, helices instead of a lattice. And the accumulating strand: a fourth loop compounds transforms without ever resetting — turtle graphics read as differential geometry, the discrete integration of a moving frame along a path. The angle driving it is a phase gradient, which is a travelling wave — which is how most of the sea swims without fins.
A second, concurrent generator category runs alongside the primary one with its own material, surface and palette: Zone, a beat-parametrized corridor, and Terra, a flowing landscape whose channel meanders on a lateral treadmill — geometry is generated channel-relative, so the camera flies straight while the valley sweeps beneath, and a navigable channel is exactly guaranteed open.
§5 · Materials & light transport
The default environment is a physically based single-scattering atmosphere computed in-shader and baked through the IBL pipeline — geometry is lit by a derived sky at the real sun angle, re-baked as the day cycle turns.
Eight material types all reflect the environment and, where enabled, the traced scene: Standard, Chrome, Glass, Refractive (Beer–Lambert absorption over the measured chord, so thickness reads honestly), Anisotropic, Clearcoat, Velvet and Subsurface. Layered on top: physical thin-film interference with a gravity-drainage gradient, spectral glass with three-tap dispersion, microstructure glitter and diffraction, spectral emission, and screen-space refraction. Because most Organon geometry has no UVs, texture projection defaults to triplanar in world space.
Because the field’s whole identity is self-illumination, the brightest nodes are promoted to actual point lights — hysteresis-stabilized, or with an optional ReSTIR mode that gives every emitter a luminance-proportional chance so dim and off-screen emitters rotate into the set over time.
§6 · Media, world, and the frame
The medium is coupled into the light transport in both directions — dye shadows the geometry, geometry shades the smoke, and the structure sways in its own wake.
The scene lives in linear 16-bit-float radiance from the first fragment to the final operator. On macOS the swapchain goes to extended dynamic range: the SDR look is preserved below a knee and highlights re-expand into the display’s measured headroom. The in-app recorder pipes the production texture to ffmpeg — H.264 Rec.709 for SDR, PQ-encoded 10-bit HEVC for HDR — so the file is the render itself, not a re-tone-mapped screen grab.
§7 · It plays in time
A phase-locked loop slaves the beat clock to the host transport — tempo changes feel like a drummer adjusting rather than a metronome snapping.
Each beat crossing kicks angular velocity into an orbiting camera that carries momentum and rings down; above that, a shot sequencer cycles camera moves on bar boundaries with glide or cut transitions, an authored storyboard, and a bar-quantized “next shot” trigger. Pulse routing sends a decaying beat envelope into any target parameter with bipolar depth. Running beside the expressive analyzer is a metrologically honest measurement layer — BS.1770-4 K-weighting, momentary/short/integrated LUFS with proper gating, 4× oversampled true peak — unit-tested against the standard’s defined values.
The field speaks, too: a synthesis engine sonifies the same field kernels the renderer draws — field-probe listener microphones, an oscillator lattice, modal struck cavities, a granular aura, a scanned-geometry wavetable. And the audio-driven path runs the other way: five band envelopes drive distinct multipole moments, so the field’s spatial shape encodes the spectrum through honest interference.
The stance throughout: audio modulates the parameters of a source; the rendered field mathematics stays real. The 20 Hz–20 kHz carrier is never itself rendered — and that is stated rather than glossed.
— Technical Overview, §10, James’ Workshop
Context Every reactive path in the engine modulates a physical source term rather than drawing the waveform. Why it matters It is the same honesty discipline that later defines the Mind edition’s provenance ledger.
§8 · Watching a mind think
A GGUF reader builds the model’s true wiring from the tensor directory alone — without ever touching a weight byte — and feeds it into exactly the same neural-graph rendering path the connectome lenses use.
An embedded llama.cpp runtime (an opt-in feature, so the default build never links C++) loads the .gguf, runs live inference on a typed prompt, and streams per-token frames into a dedicated activation ring — per-layer norms, MLP activity, per-head summaries — while a model-free synthetic writer exercises the entire live path with zero inference. Editor-side widgets read the ring directly: peak-hold activation displays, per-token effort, tokens per second. Every prompt, reply, plan, action and rejection is appended to a JSONL corpus.
Organon Mind Phase A is currently two open pull requests — the edition shell and the embedding galaxy (a GGUF payload reader with dequantization, plus a bit-deterministic streamed PCA projecting the embedding matrix into a navigable point cloud, labelled in the UI as a projection). Both are green offline and gated on a Mac pass.
In flight means in flight. Anything not yet merged to main is explicitly marked in flight in the source document; this report preserves that marking rather than smoothing it over.
§9 · The agent lane & engineering discipline
Organon can be played by an agent as well as by hands, through the same last-touched-wins discipline as every other input — and the vocabulary is generated, not maintained.
An in-process performer runs an agentic loop against an OpenAI-compatible localhost endpoint; its actions dispatch onto the same override lane pulse routing uses, then mirror back to the editor so sliders follow the agent and presets capture what it did. The action catalog comes mechanically from the same slot table that generates the packers — a new parameter enters the agent’s vocabulary automatically, and a curated one-line gloss per actuatable parameter is enforced by a test. The organon CLI opens the same lane to the terminal with no daemon and no protocol server; snap and record close the see→act→see loop.
| Invariant | How it is enforced mechanically |
|---|
Green and ready to deploy — never “verified working”. What the cloud cannot verify is stated as such: GPU look, feel and performance, DAW integration, MIDI behaviour, true-HDR output and projector-resolution performance are all verified on the machine, by hand.
§10 · The extension seams
The architecture is shaped so that adding a natural law is cheap. Four patterns cover every kind of extension.
Organon is a parametric generative visual engine that runs as a DAW plugin with its renderer in a separate process, so a physically based light-transport pipeline can be pointed at twenty-seven interchangeable mathematical generators behind one geometry contract.
— Technical Overview, §15 · In one paragraph, abridged
Context The source document’s closing summary. Why it matters Every load-bearing claim in this report traces back to it through the K anchors below.