TouchDesigner Integration (twozero MCP)

CRITICAL RULES

1. NEVER guess parameter names. Call td_get_par_info for the op type FIRST. Your training data is wrong for TD 2025.32.
2. If tdAttributeError fires, STOP. Call td_get_operator_info on the failing node before continuing.
3. NEVER hardcode absolute paths in script callbacks. Use me.parent() / scriptOp.parent().
4. Prefer native MCP tools over td_execute_python. Use td_create_operator, td_set_operator_pars, td_get_errors etc. Only fall back to td_execute_python for complex multi-step logic.
5. Call td_get_hints before building. It returns patterns specific to the op type you're working with.

Architecture

Hermes Agent -> MCP (Streamable HTTP) -> twozero.tox (port 40404) -> TD Python

36 native tools. Free plugin (no payment/license — confirmed April 2026). Context-aware (knows selected OP, current network). Hub health check: GET http://localhost:40404/mcp returns JSON with instance PID, project name, TD version.

Setup (Automated)

Run the setup script to handle everything:

bash "${HERMES_HOME:-$HOME/.hermes}/skills/creative/touchdesigner-mcp/scripts/setup.sh"

The script will:

1. Check if TD is running
2. Download twozero.tox if not already cached
3. Add twozero_td MCP server to Hermes config (if missing)
4. Test the MCP connection on port 40404
5. Report what manual steps remain (drag .tox into TD, enable MCP toggle)

Manual steps (one-time, cannot be automated)

1. Drag ~/Downloads/twozero.tox into the TD network editor → click Install
2. Enable MCP: click twozero icon → Settings → mcp → "auto start MCP" → Yes
3. Restart Hermes session to pick up the new MCP server

After setup, verify:

nc -z 127.0.0.1 40404 && echo "twozero MCP: READY"

Environment Notes

• Non-Commercial TD caps resolution at 1280×1280. Use outputresolution = 'custom' and set width/height explicitly.
• Codecs: prores (preferred on macOS) or mjpa as fallback. H.264/H.265/AV1 require a Commercial license.
• Always call td_get_par_info before setting params — names vary by TD version (see CRITICAL RULES #1).

Workflow

Step 0: Discover (before building anything)

Call td_get_par_info with op_type for each type you plan to use.
Call td_get_hints with the topic you're building (e.g. "glsl", "audio reactive", "feedback").
Call td_get_focus to see where the user is and what's selected.
Call td_get_network to see what already exists.

No temp nodes, no cleanup. This replaces the old discovery dance entirely.

Step 1: Clean + Build

IMPORTANT: Split cleanup and creation into SEPARATE MCP calls. Destroying and recreating same-named nodes in one td_execute_python script causes "Invalid OP object" errors. See pitfalls #11b.

Use td_create_operator for each node (handles viewport positioning automatically):

td_create_operator(type="noiseTOP", parent="/project1", name="bg", parameters={"resolutionw": 1280, "resolutionh": 720})
td_create_operator(type="levelTOP", parent="/project1", name="brightness")
td_create_operator(type="nullTOP", parent="/project1", name="out")

For bulk creation or wiring, use td_execute_python:

# td_execute_python script:
root = op('/project1')
nodes = []
for name, optype in [('bg', noiseTOP), ('fx', levelTOP), ('out', nullTOP)]:
    n = root.create(optype, name)
    nodes.append(n.path)
# Wire chain
for i in range(len(nodes)-1):
    op(nodes[i]).outputConnectors[0].connect(op(nodes[i+1]).inputConnectors[0])
result = {'created': nodes}

Step 2: Set Parameters

Prefer the native tool (validates params, won't crash):

td_set_operator_pars(path="/project1/bg", parameters={"roughness": 0.6, "monochrome": true})

For expressions or modes, use td_execute_python:

op('/project1/time_driver').par.colorr.expr = "absTime.seconds % 1000.0"

Step 3: Wire

Use td_execute_python — no native wire tool exists:

op('/project1/bg').outputConnectors[0].connect(op('/project1/fx').inputConnectors[0])

Step 4: Verify

td_get_errors(path="/project1", recursive=true)
td_get_perf()
td_get_operator_info(path="/project1/out", detail="full")

Step 5: Display / Capture

td_get_screenshot(path="/project1/out")

Or open a window via script:

win = op('/project1').create(windowCOMP, 'display')
win.par.winop = op('/project1/out').path
win.par.winw = 1280; win.par.winh = 720
win.par.winopen.pulse()

MCP Tool Quick Reference

Core (use these most): | Tool | What | |------|------| | td_execute_python | Run arbitrary Python in TD. Full API access. | | td_create_operator | Create node with params + auto-positioning | | td_set_operator_pars | Set params safely (validates, won't crash) | | td_get_operator_info | Inspect one node: connections, params, errors | | td_get_operators_info | Inspect multiple nodes in one call | | td_get_network | See network structure at a path | | td_get_errors | Find errors/warnings recursively | | td_get_par_info | Get param names for an OP type (replaces discovery) | | td_get_hints | Get patterns/tips before building | | td_get_focus | What network is open, what's selected |

Read/Write: | Tool | What | |------|------| | td_read_dat | Read DAT text content | | td_write_dat | Write/patch DAT content | | td_read_chop | Read CHOP channel values | | td_read_textport | Read TD console output |

Visual: | Tool | What | |------|------| | td_get_screenshot | Capture one OP viewer to file | | td_get_screenshots | Capture multiple OPs at once | | td_get_screen_screenshot | Capture actual screen via TD | | td_navigate_to | Jump network editor to an OP |

Search: | Tool | What | |------|------| | td_find_op | Find ops by name/type across project | | td_search | Search code, expressions, string params |

System: | Tool | What | |------|------| | td_get_perf | Performance profiling (FPS, slow ops) | | td_list_instances | List all running TD instances | | td_get_docs | In-depth docs on a TD topic | | td_agents_md | Read/write per-COMP markdown docs | | td_reinit_extension | Reload extension after code edit | | td_clear_textport | Clear console before debug session |

Input Automation: | Tool | What | |------|------| | td_input_execute | Send mouse/keyboard to TD | | td_input_status | Poll input queue status | | td_input_clear | Stop input automation | | td_op_screen_rect | Get screen coords of a node | | td_click_screen_point | Click a point in a screenshot | | td_screen_point_to_global | Convert screenshot pixel to absolute screen coords |

The table above covers the 32 tools used in typical creative workflows. The remaining 4 tools (td_project_quit, td_test_session, td_dev_log, td_clear_dev_log) are admin/dev-mode utilities — see references/mcp-tools.md for the full 36-tool reference with complete parameter schemas.

Key Implementation Rules

GLSL time: No uTDCurrentTime in GLSL TOP. Use the Values page:

# Call td_get_par_info(op_type="glslTOP") first to confirm param names
td_set_operator_pars(path="/project1/shader", parameters={"value0name": "uTime"})
# Then set expression via script:
# op('/project1/shader').par.value0.expr = "absTime.seconds"
# In GLSL: uniform float uTime;

Fallback: Constant TOP in rgba32float format (8-bit clamps to 0-1, freezing the shader).

Feedback TOP: Use top parameter reference, not direct input wire. "Not enough sources" resolves after first cook. "Cook dependency loop" warning is expected.

Resolution: Non-Commercial caps at 1280×1280. Use outputresolution = 'custom'.

Large shaders: Write GLSL to /tmp/file.glsl, then use td_write_dat or td_execute_python to load.

Vertex/Point access (TD 2025.32): point.P[0], point.P[1], point.P[2] — NOT .x, .y, .z.

Extensions: ext0object format is "op('./datName').module.ClassName(me)" in CONSTANT mode. After editing extension code with td_write_dat, call td_reinit_extension.

Script callbacks: ALWAYS use relative paths via me.parent() / scriptOp.parent().

Cleaning nodes: Always list(root.children) before iterating + child.valid check.

Recording / Exporting Video

# via td_execute_python:
root = op('/project1')
rec = root.create(moviefileoutTOP, 'recorder')
op('/project1/out').outputConnectors[0].connect(rec.inputConnectors[0])
rec.par.type = 'movie'
rec.par.file = '/tmp/output.mov'
rec.par.videocodec = 'prores'  # Apple ProRes — NOT license-restricted on macOS
rec.par.record = True   # start
# rec.par.record = False  # stop (call separately later)

H.264/H.265/AV1 need Commercial license. Use prores on macOS or mjpa as fallback. Extract frames: ffmpeg -i /tmp/output.mov -vframes 120 /tmp/frames/frame_%06d.png

TOP.save() is useless for animation — captures same GPU texture every time. Always use MovieFileOut.

Before Recording: Checklist

1. Verify FPS > 0 via td_get_perf. If FPS=0 the recording will be empty. See pitfalls #38-39.
2. Verify shader output is not black via td_get_screenshot. Black output = shader error or missing input. See pitfalls #8, #40.
3. If recording with audio: cue audio to start first, then delay recording by 3 frames. See pitfalls #19.
4. Set output path before starting record — setting both in the same script can race.

Audio-Reactive GLSL (Proven Recipe)

Correct signal chain (tested April 2026)

AudioFileIn CHOP (playmode=sequential)
  → AudioSpectrum CHOP (FFT=512, outputmenu=setmanually, outlength=256, timeslice=ON)
  → Math CHOP (gain=10)
  → CHOP to TOP (dataformat=r, layout=rowscropped)
  → GLSL TOP input 1 (spectrum texture, 256x2)

Constant TOP (rgba32float, time) → GLSL TOP input 0
GLSL TOP → Null TOP → MovieFileOut

Critical audio-reactive rules (empirically verified)

1. TimeSlice must stay ON for AudioSpectrum. OFF = processes entire audio file → 24000+ samples → CHOP to TOP overflow.
2. Set Output Length manually to 256 via outputmenu='setmanually' and outlength=256. Default outputs 22050 samples.
3. DO NOT use Lag CHOP for spectrum smoothing. Lag CHOP operates in timeslice mode and expands 256 samples to 2400+, averaging all values to near-zero (~1e-06). The shader receives no usable data. This was the #1 audio sync failure in testing.
4. DO NOT use Filter CHOP either — same timeslice expansion problem with spectrum data.
5. Smoothing belongs in the GLSL shader if needed, via temporal lerp with a feedback texture: mix(prevValue, newValue, 0.3). This gives frame-perfect sync with zero pipeline latency.
6. CHOP to TOP dataformat = 'r', layout = 'rowscropped'. Spectrum output is 256x2 (stereo). Sample at y=0.25 for first channel.
7. Math gain = 10 (not 5). Raw spectrum values are ~0.19 in bass range. Gain of 10 gives usable ~5.0 for the shader.
8. No Resample CHOP needed. Control output size via AudioSpectrum's outlength param directly.

GLSL spectrum sampling

// Input 0 = time (1x1 rgba32float), Input 1 = spectrum (256x2)
float iTime = texture(sTD2DInputs[0], vec2(0.5)).r;

// Sample multiple points per band and average for stability:
// NOTE: y=0.25 for first channel (stereo texture is 256x2, first row center is 0.25)
float bass = (texture(sTD2DInputs[1], vec2(0.02, 0.25)).r +
              texture(sTD2DInputs[1], vec2(0.05, 0.25)).r) / 2.0;
float mid  = (texture(sTD2DInputs[1], vec2(0.2, 0.25)).r +
              texture(sTD2DInputs[1], vec2(0.35, 0.25)).r) / 2.0;
float hi   = (texture(sTD2DInputs[1], vec2(0.6, 0.25)).r +
              texture(sTD2DInputs[1], vec2(0.8, 0.25)).r) / 2.0;

See references/network-patterns.md for complete build scripts + shader code.

Operator Quick Reference

| Family | Color | Python class / MCP type | Suffix | |--------|-------|-------------|--------| | TOP | Purple | noiseTOP, glslTOP, compositeTOP, levelTop, blurTOP, textTOP, nullTOP | TOP | | CHOP | Green | audiofileinCHOP, audiospectrumCHOP, mathCHOP, lfoCHOP, constantCHOP | CHOP | | SOP | Blue | gridSOP, sphereSOP, transformSOP, noiseSOP | SOP | | DAT | White | textDAT, tableDAT, scriptDAT, webserverDAT | DAT | | MAT | Yellow | phongMAT, pbrMAT, glslMAT, constMAT | MAT | | COMP | Gray | geometryCOMP, containerCOMP, cameraCOMP, lightCOMP, windowCOMP | COMP |

Security Notes

• MCP runs on localhost only (port 40404). No authentication — any local process can send commands.
• td_execute_python has unrestricted access to the TD Python environment and filesystem as the TD process user.
• setup.sh downloads twozero.tox from the official 404zero.com URL. Verify the download if concerned.
• The skill never sends data outside localhost. All MCP communication is local.

References

| File | What | |------|------| | references/pitfalls.md | Hard-won lessons from real sessions | | references/operators.md | All operator families with params and use cases | | references/network-patterns.md | Recipes: audio-reactive, generative, GLSL, instancing | | references/mcp-tools.md | Full twozero MCP tool parameter schemas | | references/python-api.md | TD Python: op(), scripting, extensions | | references/troubleshooting.md | Connection diagnostics, debugging | | references/glsl.md | GLSL uniforms, built-in functions, shader templates | | references/postfx.md | Post-FX: bloom, CRT, chromatic aberration, feedback glow | | references/layout-compositor.md | HUD layout patterns, panel grids, BSP-style layouts | | references/operator-tips.md | Wireframe rendering, feedback TOP setup | | references/geometry-comp.md | Geometry COMP: instancing, POP vs SOP, morphing | | references/audio-reactive.md | Audio band extraction, beat detection, envelope following | | references/animation.md | LFOs, timers, keyframes, easing, expression-driven motion | | references/midi-osc.md | MIDI/OSC controllers, TouchOSC, multi-machine sync | | references/particles.md | POPs and legacy particleSOP — emission, forces, collisions | | references/projection-mapping.md | Multi-window output, corner pin, mesh warp, edge blending | | references/external-data.md | HTTP, WebSocket, MQTT, Serial, TCP, webserverDAT | | references/panel-ui.md | Custom params, panel COMPs, button/slider/field, panelExecuteDAT | | references/replicator.md | replicatorCOMP — data-driven cloning, layouts, callbacks | | references/dat-scripting.md | Execute DAT family — chop/dat/parameter/panel/op/executeDAT | | references/3d-scene.md | Lighting rigs, shadows, IBL/cubemaps, multi-camera, PBR | | scripts/setup.sh | Automated setup script |

---

> You're not writing code. You're conducting light.