Notchback Integration in TouchDesigner

Notch is a GPU-accelerated node-based tool that excels at volumetric particle systems, fluid simulations, and real-time VFX rendering that would be expensive or impossible to replicate in TouchDesigner’s native toolkit. Notchback is the plugin — developed and maintained by Notch — that embeds a compiled Notch block (.dfx file) inside a TouchDesigner network as a TOP operator.

What Notch Is and Why You’d Use It

Notch’s rendering architecture is fundamentally different from TD’s. Where TD builds its render pipeline around OpenGL and GLSL shaders authored by the user, Notch uses a proprietary GPU deferred renderer with first-class support for:

• Particle systems with millions of GPU-simulated particles, physically correct collisions, and force fields
• Fluid simulations (SPH, FLIP, and grid-based) running entirely on GPU
• Volumetric rendering: OpenVDB import, real-time smoke simulation, volumetric lighting
• Motion blur, depth of field, and screen-space effects baked into the renderer rather than added as post-process shaders

The use case for Notchback is clear: when a visual effect is natively complex to implement in GLSL and TD’s SOP/geometry pipeline, but Notch has a built-in node for it, you author it in Notch, export a .dfx block, and drive its parameters from TD where your data and logic already live.

Licence Requirements

Notchback requires:

1. A Notch Builder or Notch Builder Pro licence — playback-only licences will not load blocks in Notchback for real-time parameter editing
2. TouchDesigner Pro or higher — Notchback uses the CPlusPlus TOP SDK and is not available in the free/non-commercial tier
3. The Notchback plugin itself — downloaded separately from the Notch website and installed into %USERPROFILE%\Documents\Derivative\Plugins\

After installing, restart TD. The Notch TOP will appear in the TOP create dialog. If it doesn’t, check that the .dll is in the plugins directory and that the Notch licence server is reachable (Notchback validates the licence on startup).

The Notch TOP

Create a Notch TOP and set Block File to your .dfx path. The TOP will immediately begin rendering. Key parameters:

• Resolution: Notch renders at the resolution set here — this is independent of TD’s project resolution and is expensive to change at runtime
• FPS Mode: Match to project (recommended), Free-run, or Manual. Match to project locks Notch’s simulation clock to TD’s frame rate, ensuring deterministic simulation state
• GPU Device: Notchback runs on a specific GPU; on a multi-GPU system, ensure this matches the device that your TD rendering pipeline is also using
• Cook on Demand: when disabled, the Notch block renders every frame regardless of downstream demand — useful for keeping simulation state alive even when the output isn’t visible

Passing Inputs to Notch

The Notch TOP accepts up to 8 TOP inputs. In your Notch block, add Video Layer nodes and set their source to Notchback Input 1 through Notchback Input 8. These video layers become fully composited elements inside Notch’s renderer — they can be mapped to geometry, used as displacement maps, or composited in Notch’s layer stack.

Connection order in TD: Input 0 on the Notch TOP maps to Notchback Input 1 in Notch (one-indexed in Notch, zero-indexed in TD). Document this offset in your project; it is a common source of confusion.

Exposing Notch Parameters to TD

Any numerical or colour parameter in a Notch block can be exposed by right-clicking it in Notch Builder and selecting Expose to Notchback. Exposed parameters appear as custom parameters on the Notch TOP in TD. The parameter name, type (float, integer, boolean, colour, 2D vector, 3D vector), and default value are all set in Notch.

This is the primary control mechanism — TD drives Notch parameters, not the other way around. You reference TD CHOPs and DATs in the parameter fields using TD’s standard expression syntax:

# In Notch TOP parameter "Particle_Emit_Rate"
op('audio_analysis')['kick_energy'][0] * 5000

Sending CHOP Data to Notch

Scalar CHOP values map directly to exposed float parameters via expressions. For array data (e.g., 33 body landmark positions), you need to aggregate them into a custom parameter set or use Notch’s Data Array input, which accepts a structured binary blob via the Notchback TOP data pin.

For most production cases, you expose 10–20 scalar parameters covering the key control dimensions (scale, speed, colour temperature, emission rate, attractor strength) and drive them from TD CHOPs:

# Evaluate in Notch TOP's "Attractor_X" parameter
op('hand_tracker')['index_tip_x'][0]

# Evaluate in "Fluid_Viscosity" parameter  
op('audio_rms_smooth')['rms'][0] * 0.8 + 0.1

Performance Considerations

Notchback runs inside TD’s render pipeline but allocates its own GPU resources separately from TD. The two key things to monitor:

VRAM usage: Notch’s particle systems and fluid simulations are VRAM-intensive. A 2-million-particle simulation with 3D collisions can use 2–4 GB of VRAM. If TD and Notch are fighting for VRAM on the same GPU, you’ll see stuttering as the driver swaps resources. Use a machine with at least 16 GB VRAM (RTX 4090 or A5000 class) for complex Notchback rigs.

Simulation state: Notch simulations must run continuously to maintain physical state (particle positions, fluid cells, etc.). If the Notch TOP stops cooking — because a Cook flag is turned off or the OP is not connected to a visible output — the simulation freezes. When it resumes, there may be a discontinuity. For live shows, keep the Notch TOP cooking always, even when not displayed, by routing it to a Null TOP with the Cook flag on.

Full Example: Audio-Reactive Particle System

This example runs a Notch particle attractor simulation where the physics responds to TD audio analysis, rendered back into TD’s compositing pipeline.

In Notch Builder, set up:

1. A GPU particle system with 1,000,000 particles
2. A spherical attractor node — expose its Strength and Radius parameters to Notchback
3. A turbulence force field — expose its Scale and Speed
4. A colour gradient mapped to particle age — expose the gradient’s Hue Shift
5. Set the render output to Notchback Output

In TouchDesigner, the audio analysis network:

Audio File In CHOP → Analyze CHOP (RMS) → Filter CHOP (lag=0.1) → rms_smooth
                   → Math CHOP (FFT) → Select CHOP (0-80Hz) → Analyze (max) → bass_peak

Wire the Notch TOP parameters:

# Notch TOP parameter: Attractor_Strength
op('bass_peak')['chan1'][0] * 3000 + 500

# Notch TOP parameter: Turbulence_Scale
op('rms_smooth')['chan1'][0] * 4.0 + 0.5

# Notch TOP parameter: Hue_Shift
absTime.seconds * 0.05 % 1.0

The compositing chain in TD:

Background TOP ──────────────────────────┐
                                          → Composite TOP (Over) → Output
Notch TOP (particle render, RGBA) ───────┘
     ↑
 [8 TOP inputs: none needed for this example]

Add a Bloom TOP and Color Correct TOP after the Composite to bring the Notch render into the same colour space as your TD background. Notch’s internal tonemapper outputs linear light by default — apply a gamma of 2.2 in the Color Correct TOP unless you’re working in a linear pipeline end-to-end.

For shows where the Notch block needs to change (different scenes in a cue list), use two Notch TOPs with different .dfx files loaded and a Switch TOP between them. Preload both blocks at startup so the Switch is instantaneous — loading a new .dfx at runtime takes 1–3 seconds during which the simulation is offline.