Transactionally add, edit, delete, sort, and organize a COMP's custom parameters through an authenticated structured TouchDesigner route. Legacy page+params calls remain valid. Supports Float, Int, Toggle, Str, Menu, Pulse, Header, OP, TOP, File, Folder, XYZW, RGBA, RGB, and XYZ; EXPRESSION and BIND are reversible and require TDMCP_RAW_PYTHON=on plus TDMCP_BRIDGE_ALLOW_EXEC=1 because their source is caller-supplied code. Constant and page-lifecycle operations remain available in restricted mode. EXPORT is explicitly HELD and returns an error without mutation. Built-ins are protected and failures roll back to the exact prior custom-page snapshot.

Overlay a running HH:MM:SS:FF timecode (or a countdown) onto an input TOP as VISUAL pixels — a Text TOP whose text expression re-evaluates every frame, composited 'over' the source with a Composite TOP. Modes: clock (show time since project start — NOT the OS wall clock — as HH:MM:SS:FF), count_up (elapsed time since this overlay was built, from zero), count_down (counts down from target_seconds to 00:00:00:00 and clamps there). The formatter lives in a Text DAT module (mod('fmt').tc(...)) so it re-cooks live inside TD. FPS is probed live (me.time.rate -> project.cookRate -> 60 fallback) and reported. Distinct from sync_timecode, which syncs a CLOCK SIGNAL (no pixels) — this tool draws the timecode into the image. Ends with a Null TOP 'out'.

Diagnose a network for cleanup: report likely-dead operators (zero wired outputs, unreferenced, not displayed), broken external-file dependencies (file parameters pointing at missing files), orphan COMPs, and a dependency map of which operators reference which. Read-only and conservative — every flagged item carries a human-readable reason. Complements plan_visual (which plans a build) and snapshot_td_graph (which dumps structure).

Drive one or more node parameters over time with an LFO (sine/triangle/ramp/square/pulse/random). Creates an LFO CHOP and binds each target so it oscillates between min and max with the given period — movement without manual keyframing.

Build a self-contained GLSL TOP network from a pre-translated mapping (fragment + uniforms + channels + controls). Caller fragment source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. Foundation primitive used by Shadertoy and ISF importers; also reachable directly for power users with a hand-translated fragment.

Apply a colour Look-Up Table (LUT) to an existing TOP inside a self-contained baseCOMP. Prefers an OpenColorIO TOP for .cube/.3dl/.cc/.ccc files; falls back to a Movie File In + Lookup TOP for image LUTs or when OCIO is unavailable. A .cube file with no OCIO is parsed in Python into a Script TOP ramp. Exposes Strength and Bypass controls on a custom page. Pass source_path to grade an existing TOP, or omit it for a standalone preview on a grey Constant TOP.

Chain post-processing effects (bloom, glitch, rgb_split, vignette, etc.) onto an existing TOP, applied in the order given. Creates a new baseCOMP under parent_path that pulls the source in via a Select TOP, wires each effect (built-in TOPs or inline-GLSL passes) in series, and ends in a Null TOP. Returns a summary plus a JSON block with the container path, all created node paths, the output Null path, any node errors, warnings, and an inline preview image. Use create_color_grade or create_glitch instead when you want a single dedicated effect with its own exposed controls.

Instantiate a built-in recipe by id (from list_recipes) inside a COMP — a tested, ready-made network you can build in one call, then tweak. Creates a new baseCOMP under parent_path, adds and wires every node the recipe declares, exposes its controls, then auto-layouts, verifies, and previews. Returns a summary plus a JSON block with the container path, all created node paths, the output path, the recipe id, exposed controls, any node errors, warnings, and an inline preview image. Returns a friendly error listing available ids if id is unknown.

READ a shader note from the Obsidian vault (a glsl fragment block, optional glslvert vertex block, and optional uniforms/resolution/name frontmatter) and CREATE a GLSL TOP in TouchDesigner from it. Side effect is node creation in TD, not file writes. Use this to apply a shader you keep in the vault; to supply shader code inline instead, use create_glsl_shader. Returns the created GLSL TOP (same result as create_glsl_shader). Requires a configured TDMCP_VAULT_PATH, TDMCP_RAW_PYTHON=on, and TDMCP_BRIDGE_ALLOW_EXEC=1.

Tidy an existing network into a readable left→right data-flow layout, or use layout_mode=explicit for one bounded, atomic exact-coordinate mutation with stale-context checks, readback and rollback. Annotation-aware automatic layout remains available, and omission of layout_mode preserves the legacy response. It never adds, deletes, or rewires nodes.

Create an OSC control preset for an ATEM switcher routed through atemOSC, Bitfocus Companion, or another OSC relay. This does not use the Blackmagic SDK directly; it builds an offline-safe TouchDesigner OSC matrix for cut/auto/FTB and program/preview input selection.

Copy documentation files into a package and register them in its manifest's docs list. Use after make_portable_tox to bundle a README or usage notes with a component so they travel with it; writes into the package folder (destructive).

Sample a few seconds of audio inside TouchDesigner, compute a 4-feature fingerprint (tempo, spectral centroid, onset density, dynamic range), run a deterministic heuristic mapping to pick a matching Layer 1 generator (create_glitch / create_audio_reactive / create_kaleidoscope / create_feedback_tunnel / create_feedback_network / create_gpu_particle_field), and dispatch it with parameters tuned to the fingerprint. Default audio_source='synthetic' to avoid macOS mic-permission hangs. dry_run=true returns the chosen mapping without building. apply_top_op composites the result over an existing TOP.

Scaffold a Script CHOP/DAT/SOP/TOP with a ready-to-edit onCook(scriptOp) stub and optional custom parameters. Creates the Script op plus its companion callbacks DAT, writes a per-family stub (chan/row/point/numpy) — or your on_cook_body — and appends Float/Toggle/Str custom pars inferred from each default's type. Returns {op_path, callbacks_path, params_added, warnings}. Requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. Note: Script ops only cook when something requests them, so a paused timeline + no downstream consumer means no cook (not a bug).

Driver: scan a subtree for cook errors, cluster them, route each cluster to the right fix (calls repair_network for structural/expression/flag issues; surfaces fix_shader / fix_reactivity as prompt hand-offs the agent must execute next turn), re-check, and iterate until clean, no-progress (stalled), or max_iterations (exhausted). Dry-run by default — one planning iteration, no writes. The loop CANNOT fix shaders or dead reactivity itself; it points the agent at them via recommended_prompts. Returns {status, iterations[], errors_before, errors_after, remaining[], recommended_prompts[], warnings}.

Inspect a captured library asset (a vault recipe/component note, or a live TD COMP) and emit a suggested tag set, difficulty, and one-line description from a deterministic operator-family heuristic; with write:true, merge the suggestion into the note's frontmatter (preserving '*'-pinned user tags). Use this to backfill consistent tags across a library so browse_vault_library can find by category. Requires a configured TDMCP_VAULT_PATH; target='td_comp' additionally requires the bridge.

Generate a performable control panel from an existing node/COMP's primitive parameters. It reads source_path, infers sliders/toggles/text fields, appends them as custom parameters on comp_path (default source_path), and optionally binds each control back to the source parameter. Use when a generated component has useful parameters but no playable UI yet.

Run an ordered list of create / connect / setParam operations in one call (fail-forward, per-operation warnings; not transactional). Exposes the network builder as a general primitive — distinct from set_parameters_batch, which only sets parameters. Names created earlier can be referenced by later connect/setParam operations.

Make a whole COMP react to the music in one call — the core VJ move. Point target at a COMP with numeric custom-parameter knobs and source_chop at an audio-feature CHOP (e.g. an extract_audio_features Null carrying level/bass/mid/treble), and each knob is switched to expression mode tracking an audio band. Omit mappings to auto-map knobs by name heuristic (bright/level/opacity→level, scale/size/zoom→bass, hue/color→treble, speed/rate/rot→mid; unrecognized knobs are skipped), or pass explicit param→channel bindings with per-binding scale/offset. By default appends a master 'Reactivity' float knob (0–2, default = intensity) that scales every binding so the artist can dial the whole network's reactivity from one control. Fail-forward: a missing source CHOP, an absent channel, or an already-bound parameter are warnings, not failures — only a missing/non-COMP target is fatal. This tool only WIRES an existing COMP to an existing CHOP, building no nodes: produce the feature CHOP with extract_audio_features (or create_spectrum) first, use create_audio_reactive when you want a whole new reactive network with its own visual, and bind_to_channel for finer single-parameter control.

Drive one or more node parameters from a CHOP channel by expression — the link that makes a visual react. Point it at an audio_features channel (bass/mid/treble/level) or a tempo_sync channel (ramp/pulse/beat) with a scale and offset, and each target parameter tracks that signal live. This is how you wire extract_audio_features / create_tempo_sync into a visual system. Optionally add attack/release smoothing (in seconds) — or a single smooth time — to insert a Lag CHOP between the channel and the parameter so reactivity follows a clean envelope instead of flickering on raw audio (e.g. a fast attack + slow release for a punchy hit that decays smoothly).

CREATE a Text DAT in TouchDesigner whose file parameter points at a vault note, so the note's text loads into TD (and, with sync:true, stays live as you edit it in Obsidian) — turning the vault into the text/lyrics source for your visuals. Side effect is node creation in TD plus reading the note file; it does not write to the vault. Wire the DAT into a Text TOP to render it. Returns the DAT path, the resolved note, the absolute file path, and whether sync is on. Requires a configured TDMCP_VAULT_PATH, TDMCP_RAW_PYTHON=on, and TDMCP_BRIDGE_ALLOW_EXEC=1.

Create a self-contained TouchDesigner render scaffold for a Blender scene or Blender-exported asset: File In SOP (or fallback primitive), Geometry COMP, PBR material, environment/key lights, Camera, Render TOP, and Null TOP output. Supports .blend/.fbx/.obj/.gltf/.glb/.usd/.usdz paths and warns when a .blend may need export from Blender first.

Browse built-in/vault recipes and optional local component packages. Read-only discovery step before instantiating a recipe (apply_recipe) or installing a package (install_library_package); returns the matching recipes and packages so an agent can pick one by name.

Read-only: list the vault's recipes, shaders, presets, components, and setlists with title, tags, and description so the agent can pick from the library without opening individual notes. Filter by category (kinds) and/or a substring query. Returns a flat items array and per-category counts. No TouchDesigner connection required — reads the local vault on disk. Requires a configured TDMCP_VAULT_PATH.

Declarative Layer-2 builder for an ordered CHOP processing chain. Pass an ops list (type + optional name + optional params); each op[i] is wired output 0 → input 0 of op[i+1] under parent (default /project1). Per-op create/param/connect failures become warnings (fail-forward) — a partial chain still returns useful info. Tip: end the chain in a nullCHOP to make it bind_to_channel-ready.

Declarative Layer-2 builder for an ordered POP (Point OPerator) chain. Pass a chain list of { type, name?, params?, extra_inputs? } entries; each chain[i] is wired output 0 → input 0 of chain[i+1] under parent (default /project1). Per-kind safe defaults are applied before user params; unknown par names become warnings (fail-forward). Multi-input POPs (merge, copy, feedback, proximity, switch, blend) accept extra_inputs paths wired into input 1, 2, …. POPs are Experimental — result carries unverified marker. Tip: end the chain in a null_pop for a stable handoff to Wave-3 render rigs.

Declarative Layer-2 builder for an ordered SOP geometry chain. Pass an ops list (type + optional name + optional params); each op[i] is wired output 0 → input 0 of op[i+1] under parent (default /project1). Per-op create/param/connect failures become warnings (fail-forward) — a partial chain still returns useful info. Tip: end the chain in a nullSOP for a stable handoff to Geometry COMPs, SOP-to-CHOP, or convertSOP. Use connect_nodes for multi-input fan-in (e.g. mergeSOP, copySOP template).

Make a COMP self-contained: recursively scan its subtree for external file references (movie/image files, fonts, LUTs, externaltox links — reusing the collect_project_assets scan), COPY each existing asset into <out_dir>/assets/, rewrite each referencing parameter in the LIVE network to the copied relative path (assets/), then save the COMP as a .tox beside its assets with a tdmcp-component manifest. The result is a folder you can move to another machine and open without broken links. Delta vs make_portable_tox (which saves the .tox only, leaving external assets behind) and collect_project_assets (which only reports refs). Rewriting mutates the live network — set rewrite_refs=false to copy-and-report without touching parameters.

Read-only: render a TOP's preview and return a plain-text description of it — the headless 'is the output alive?' primitive. Two paths: (a) a configured vision LLM endpoint when available, (b) a DETERMINISTIC luma/colour-histogram fallback decoded from the preview PNG pixels (always works, no model needed). Reports dominant colours, mean luma, near-black fraction, a coarse classification ('black'/'very dark'/'dark'/'bright'/'colorful'/'mid'), and a friendly caption. Returns {node_path, width, height, source:'vision'|'histogram', caption, stats{...}, warnings}. Use it after a build to confirm the network is actually rendering instead of a black frame. The vision path is currently inert (no vision field on the tool context) and falls back to the histogram.

Captures a preview still from a TOP and appends it to a dated gallery note in the Obsidian vault, building a visual look-book over time. Each call writes the PNG image under /images/ and appends a new section to /.md (defaulting to today's date so all daily captures land in one note). Use this to document looks, reference frames, or build a browsable gallery of your session's visuals. Requires a configured TDMCP_VAULT_PATH.

Reconcile the operator knowledge base against the RUNNING TouchDesigner's ground-truth creatable-optype list (GET /api/optypes). Flags which documented operators are actually creatable in this build vs deprecated/unavailable, and (optionally) which live optypes the knowledge base doesn't yet document. Pass a single operator name to check just that one. Survives TDMCP_BRIDGE_ALLOW_EXEC=0.

Compute or verify SHA-256 checksums for tdmcp artifacts (.tox, .recipe.json, bundles). action=compute walks a path and writes a tdmcp-checksums.json manifest. action=verify re-hashes files and reports ok/mismatch/missing/extra. No TD bridge required.

Create a synchronized clip transport container: a Movie File In TOP video lane, optional Audio File In CHOP lane, Null outputs, deterministic layout, and Play/Loop/Speed controls bound across both lanes. Use it as a reusable building block before clip launchers, VJ decks, or stream/output chains.

Scan a COMP subtree for every external file dependency (movie/image file pars, fonts, LUTs, externaltox links) and report each referenced file, the node+parameter that references it, and whether the file currently exists on disk. The TouchDesigner scan is read-only and copies/rewrites nothing in the network; when out_manifest is set, this tool writes that local JSON path and may overwrite an existing manifest. File-par detection uses par.style ('File'/'Folder') when readable, falling back to a suffix/exact name heuristic (file, fontfile, lut, externaltox, moviefile, imagefile) — both UNVERIFIED across TD builds; style_supported records whether par.style was available.

Read-only: compress a TD subtree into a structured digest under max_tokens (default 500). Returns {header, nodeCount, connectionCount, primaryOutput, families{count,topTypes}, outputChain, errors{total,topGroups}, warnings, approxTokens}. Uses getNetworkTopology + getNetworkErrors — no new bridge work. Cheaper than get_td_topology / snapshot_td_graph for planning turns.

Read-only: compare two TouchDesigner operator types from the embedded offline knowledge base, including overview metadata plus shared and unique documented parameters. This compares operator documentation, not live node settings; use compare_td_nodes for live node parameter diffs.

Read-only: diff the parameters of two nodes, returning only the values that differ (by default). Returns {type_match, differing_count, differing[], same_count}. Useful for aligning settings across similar operators; compares two live nodes, whereas diff_snapshots compares two whole-network snapshots over time.

Maintains an append-only per-component revision history as a JSONL trail (<component>.trail.jsonl) inside the Obsidian vault, next to the .tox and its provenance sidecar. Three actions: append a new revision entry (with optional sha256 of the .tox, changed-param list, author, and timestamp); read all entries back as JSON; export the trail as a human-readable markdown changelog note rendered into the vault. Offline — no TD bridge required. Pairs with save_component_to_vault and provenance_stamp.

Probe live COMPs in the running project for externaltox paths and report missing or broken linked component files. Read-only diagnostic: run it when externally-linked .tox components may have moved or gone stale, before relying on them in a build.

Turn a natural-language show description into a validated cue list (SetlistSchema, scenes[] variant). Uses the local LLM when configured, falls back to a deterministic grammar parser otherwise. Optionally chains into create_cue_sequencer.

Create an AUTOMATIC1111/Forge Stable Diffusion WebUI handoff scaffold with prompt slots, result maps, ControlNet hints, and adapter notes.

Create an Ableton Link timing scaffold with beat/bar maps for tempo-locked visual systems.

Create an ADS-B aircraft scaffold with sanitized aircraft rows, altitude bands, track history metadata, adapter source, and feed/privacy notes.

Create an Airtable content scaffold with record maps, field maps, sync policy, adapter source, and token/rate-limit safety notes.

Create an AIS vessel scaffold with sanitized vessel rows, zone maps, route hints, adapter source, and receiver/privacy notes.

Create an ARKit Face Capture OSC scaffold with blendshape and head-transform maps for iPhone-driven facial performance.

Create a Blackmagic ATEM command-map scaffold with UDP transport placeholders, input maps, macro maps, and operator approval notes.

Create a BLE beacon proximity scaffold with sanitized beacon rows, zone maps, smoothing policy, adapter source, and device-privacy notes.

Create a venue calendar scaffold with event rows, reminder maps, blackout windows, adapter source, and credential/privacy safety notes.

Create a CasparCG AMCP/playout scaffold with channel/layer command templates and media manifest notes.

Bridge a running ComfyUI server: drops the TDComfyUI .tox if installed, otherwise builds a stock webclientDAT skeleton. The container exposes a Null TOP at /out as the downstream output.

Build an OSC Companion-style button surface inside TouchDesigner: an OSC In CHOP listens for button addresses, each button gets a Select CHOP and Null CHOP row, optional target parameters are expression-bound, and an OSC Out CHOP is configured for feedback. A mapping table records label/address/target/mode/feedback for later editing.

Create a Daydream cloud-hosted StreamDiffusion bridge in TD. A webclientDAT POSTs the encoded source TOP frame to Daydream's REST endpoint; the diffused result is pulled back via a Syphon/Spout/NDI receiver and exposed as a null TOP. API key is read from DAYDREAM_API_KEY in the TD process environment — never inlined. Live probe SKIPPED (requires Daydream account + outbound HTTPS).

Create a Discord interaction scaffold with command rows, message rows, approval policy, adapter source, and bot-token/signature safety notes.

Create a disguise/d3 HTTP and OSC show-control scaffold with timeline, layer, and approval maps.

Create a door-access monitoring scaffold with sanitized door events, door maps, adapter source, and lock-control safety notes.

Create an environmental sensor scaffold with normalized readings, sensor maps, adapter source, and building-control safety notes.

Create a Figma design-token scaffold with token rows, component-review rows, style preview metadata, adapter source, and access-token safety notes.

Create a GeoJSON feature scaffold with feature rows, property maps, style rules, adapter source, and projection/privacy notes.

Create a Google Sheets cue-table scaffold with source adapter, cue rows, column validation, sync policy, and OAuth/writeback safety notes.

Create a GPS/fleet tracking scaffold with sanitized asset rows, geofence maps, privacy policy, adapter source, and credential/privacy notes.

Create a Grafana annotation/event-marker scaffold with dashboard, panel, tag, and annotation maps plus token-safety notes.

Create a GTFS static/realtime transit scaffold with route maps, stop maps, arrival predictions, adapter source, and public-data notes.

Create a Home Assistant state/service scaffold with REST/WebSocket adapter nodes, entity maps, service maps, and physical-action safety notes.

Create a Houdini Engine/HDA/cache handoff scaffold with HDA manifests, parameter maps, cook-status ingest, and geometry cache notes.

Create a Hugging Face Inference Endpoint scaffold with task input maps, output contracts, token-env hints, and adapter notes.

Create an InfluxDB telemetry scaffold with measurement maps, field maps, query/write adapter notes, and token-safety warnings.

Create an Isadora OSC actor, watcher, and scene exchange scaffold with stable namespace mapping.

Create a Kafka/Redpanda event-bus scaffold with adapter ingest, topic maps, schema hints, consumer group metadata, and policy-gated producer notes.

Create a safety-gated OSC command scaffold for grandMA3, ETC Eos, ChamSys, Avolites, or generic lighting consoles without sending direct DMX.

Create a MadMapper OSC surface/media control scaffold with source handoff notes for Syphon/Spout or NDI.

Create a map-tile overlay scaffold with tile layer maps, viewport metadata, attribution rows, adapter source, and token/cache safety notes.

Create a Matrix room scaffold with sanitized room events, reaction maps, approval policy, adapter source, and token/encryption safety notes.

Create a Max/MSP OSC bridge scaffold with parameter and audio-feature channel maps.

Create an expressive MIDI MPE input/output scaffold with zone and expression maps for pressure, timbre, pitch bend, and note channels.

Create a Millumin OSC layer, column, and dashboard control scaffold with command maps and setup notes.

Create an MQTT Client DAT bus scaffold for IoT sensors, installation telemetry, and policy-gated operator commands.

Create an NFC tap scaffold with sanitized tap events, station maps, consent policy, adapter source, and tag-privacy notes.

Wire one node's output connector into another node's input connector inside TouchDesigner, creating a single link between two existing nodes. Uses the bridge's batch endpoint when available and falls back to a Python connect otherwise. Use create_node_chain instead when you are creating several new nodes and want them auto-wired in sequence. Returns the source and target paths, the connector indices used, and which method made the connection.

Create a noise-level telemetry scaffold with aggregate decibel readings, sample windows, adapter source, and PA/safety policy notes.

Create a Notion show-rundown scaffold with scene maps, property maps, approval policy, adapter source, and token-safety notes.

Create a TouchDesigner-side OBS control scaffold with obs-websocket v5 request templates, status/setup DATs, and optional NDI or Syphon/Spout TOP publishing for OBS capture. The optional OBS password is passed only to the bridge payload and is redacted from all returned reports.

Create an NVIDIA Omniverse/USD stage sync scaffold with Nucleus/stage metadata, layer maps, variant maps, and live-session notes.

Create an OPC UA industrial telemetry scaffold with node maps, adapter ingest options, status tables, and read-only safety-policy notes.

Create an OSCQuery HTTP namespace and OSC send/receive scaffold with action maps for live-control apps.

Create a safety-gated Pangolin Beyond laser-control scaffold with zone maps, cue maps, blackout notes, and no live-output claim.

Create a parking/queue occupancy scaffold with zone occupancy, sensor maps, signage policy, adapter source, and privacy safety notes.

Create a people-counting scaffold with aggregate zone counts, sample windows, adapter source, and privacy policy notes.

Create a POS aggregate-telemetry scaffold with sales metrics, revenue buckets, privacy policy, adapter source, and PCI/PII safety notes.

Create a power-meter telemetry scaffold with read-only meter readings, circuit maps, adapter source, and electrical-control safety notes.

Create a Prometheus metrics scaffold with PromQL/client adapter notes, metric maps, alert routes, and operator-dashboard safety guidance.

Create a public-alert scaffold with advisory alert rows, severity maps, routing policy, adapter source, and safety/escalation notes.

Create a QLab OSC cue-stack scaffold with cue command maps, status, and rehearsal-focused setup notes.

Create a QR scan scaffold with sanitized scan events, route maps, sanitization policy, adapter source, and token/URL safety notes.

Create a queue-length scaffold with aggregate queue metrics, sample windows, adapter source, and alert policy notes.

Create a REAPER OSC transport, track, and marker bridge scaffold with operator-approved recording templates.

Create a Redis Pub/Sub/Streams scaffold with adapter ingest, channel maps, keyspace safety notes, and read-first operations policy.

Create a Replicate-style prediction handoff scaffold with request templates, polling/webhook maps, output contracts, and credential-safety notes.

Create a Resolume Arena/Avenue OSC control scaffold with command maps, status DATs, and preview handoff notes. Runtime validation against Resolume remains explicit.

Create an RFID badge-reader scaffold with sanitized badge events, reader maps, privacy policy, adapter source, and access-control safety notes.

Create an RSS/Atom/editorial feed scaffold with sanitized item rows, category maps, refresh policy, adapter source, and copyright/sanitization notes.

Create a Runway-style video generation handoff scaffold with prompt maps, input/result contracts, polling status, and adapter notes.

Create an RVC-style voice conversion scaffold with source audio, model maps, output contracts, latency notes, and consent warnings.

Create an S3-compatible media-bucket scaffold with manifest rows, cache policy, ingest status, adapter source, and credential/signing safety notes.

Create a Serial DAT/CHOP scaffold for microcontrollers, sensors, and show-control devices with parse maps.

Create a Slack operator-alert scaffold with webhook/socket adapter, alert rows, approval-gated command rows, and token/signing safety notes.

Create a platform-gated Syphon/Spout texture-sharing router scaffold with route maps and explicit setup notes.

Create a SuperCollider OSC synth/bus bridge scaffold with explicit port maps and no code-evaluation behavior.

Create a ticketing/check-in scaffold with aggregate gate counts, ticket-tier maps, gate status, adapter source, and PII/token safety notes.

Create a TidalCycles/SuperDirt OSC scaffold with pattern and orbit maps for live-coded audiovisual sets.

Create a TikTok Live-style event scaffold with sanitized event rows, gift tiers, moderation policy, adapter source, and auth/client safety notes.

Create a TouchEngine/Notch bridge scaffold with stable output TOP, control channels, NDI/Syphon fallback modes, and explicit licensing/runtime warnings.

Create a TUIO touch-surface scaffold with TUIO DAT, optional raw OSC, cursor maps, and surface maps.

Create a Twitch EventSub/chat scaffold with sanitized event rows, reward maps, moderation policy, adapter source, and OAuth/webhook safety notes.

Create a UDP In/Out DAT scaffold for telemetry packets, replies, status maps, and diagnostics.

Create a Unity OSC and preview handoff scaffold for object transforms, events, and NDI/Syphon notes.

Create a UWB RTLS scaffold with sanitized tag positions, anchor maps, spatial policy, adapter source, and tag-privacy notes.

Create a VDMX OSC/Syphon workspace scaffold with layer, clip, preview, and setup maps.

Create a Video Stream In TOP scaffold for RTSP, HLS, SRT, or WebRTC ingest with stream maps and setup notes.

Create a vMix HTTP/API production-control scaffold for input switching, overlays, recording, and streaming command templates.

Create a weather forecast/station scaffold with forecast rows, sensor maps, alert maps, adapter source, and safety-policy notes.

Create a browser/WebRTC input scaffold for webcam, screen, pointer, and sensor data supplied by an external signaling app.

Create a WebSocket DAT scaffold with command maps, message schema hints, status, and safety notes.

Create a Whisper-compatible transcription scaffold with audio/file/chunk ingest, segment maps, status tables, and privacy notes.

Create a Wi-Fi presence scaffold with aggregate occupancy rows, dwell buckets, privacy policy, adapter source, and device-privacy notes.

Create an Xsens MVN mocap scaffold with OSC/UDP/TCP ingest, actor/segment mapping, normalized skeleton tables, and coordinate-space notes.

Create a YouTube Live Chat scaffold with sanitized message rows, Super Chat tiers, moderation policy, adapter source, and API/quota safety notes.

Generate a rows×cols grid of quads (or outlined cells) with a single order↔chaos disorder knob: 0 = a perfect grid, 1 = full chaos. The one knob scales per-cell position, rotation, and scale jitter together — each hashed from the cell index in a single GLSL TOP so the pattern is stable and reproducible (the classic generative-design 'controlled randomness' / Schotter study, no external source). Set outline: true for line cells. Creates a new baseCOMP under parent_path. Exposes the live Disorder knob plus CellColor/Background swatches. Returns a summary plus a JSON block with node paths, exposed controls, node errors, warnings, and an inline preview image.

Drive the TouchDesigner project timeline: play, pause, seek to a frame, jump to a named cue, or set playback rate. Returns the timeline state after the action so a copilot can verify the change took effect. NOTE: pausing will freeze any downstream motion/feedback/frame-diff chain — expected behaviour, not a bug.

Capture a TOP as a preview image and ask the configured multimodal LLM a question about it. Numeric-loopback endpoints need no extra opt-in; remote, client-managed, or unknown backends require allow_remote_image_egress=true for that frame. Returns redacted egress locality/transport and calibration: not_checked; this read-only tool is NOT the calibrated visual-mutation authority. Uses ctx.llm.complete() with an image part. Different from caption_top, which is deterministic-by-default.

Build a 3D scene that reacts to sound — the 3D counterpart of create_audio_reactive (use that for a 2D spectrum visual instead). Creates a new baseCOMP under parent_path. An FFT spectrum chain feeds geometry: 'instanced_bars' renders a row of bands boxes/spheres whose individual heights track each frequency bin (a 3D spectrum bar-graph), while 'bass_pulse' swells a single primitive with the low-frequency energy. Includes a Camera, Light, and Render TOP, output as a Null TOP. Exposes Sensitivity (audio gain), Zoom (camera distance), and Spin (whole-scene rotation) knobs. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic oscillator (for testing), or an existing CHOP. Returns a summary plus a JSON block with the container path, created node paths, the spectrum/geometry/camera/render/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Build a renderable 3D scene: a Geometry COMP holding the chosen primitive (sphere/box/grid), a Camera, a Light, and a Render TOP, output as a Null. Creates a new baseCOMP under parent_path holding all of these — optionally instanced into a grid of instances copies via GPU instancing, with scale_variation for per-copy random sizes and spin for per-copy rotation over time. Exposes RotateY (whole-scene spin) and Zoom (camera distance) knobs. The starting point for 3D visuals — bind RotateY to a tempo ramp or an audio feature to make it move. Use create_3d_audio_reactive instead when you want the geometry driven by sound, or create_pbr_scene for physically-based materials. Returns a summary plus a JSON block with the container path, created node paths, the geometry/camera/render/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Layer 1 COMBO: wires the canonical 2026 AI-mirror installation in one MCP call — camera (or synthetic / existing TOP) → StreamDiffusion (img2img live, delegated to drive_streamdiffusion) → Syphon/Spout/NDI/internal output → a prompt+strength+cfg control panel whose sliders and textDATs drive SD pars via .expr expressions. Panel only binds pars present in drive_streamdiffusion's validated_pars; missing pars are warned, not errored. Camera source on macOS triggers the OS permission dialog on first cook; fallback_to_synthetic keeps the rig alive when the camera is unavailable.

Create an Art-Net DAT discovery scaffold with optional DMX In monitor, device maps, and universe maps.

Turn any TOP into a character-grid ASCII render: quantise input luminance into a (W/cell × H/cell) grid, then look up each glyph from a monospace character atlas. Supports mono, source-color (per-cell tint), and two-color (lerp by luminance) modes. Phosphor-green default for the Severance / CRT terminal look. Creates a resolutionTOP (cells), textTOP (atlas), glslTOP, and nullTOP output inside a new baseCOMP. Exposes Mix, CellSize, and Charset controls.

Generate a page of procedural asemic writing — random-but-writing-like glyph strokes that flow left-to-right along stacked baselines but spell nothing. A Script SOP lays out rows × glyphs cells; each glyph is a short chain of strokes control points walking a noise-perturbed pen, with italic slant, per-stroke jitter, and occasional pen-lifts (lift_chance) that break marks apart. The polylines are thickened into tube ink strokes and rendered with an orthographic camera as calligraphic line art on a coloured page. Deterministic per seed. Genuinely distinct from create_growth_system (L-system branches) and create_vector_lines (image-traced contours). Creates a new baseCOMP under parent_path. Exposes Jitter, Slant, Thickness, and Seed controls. Returns a summary plus a JSON block with the container path, created node paths, output path, exposed controls, node errors, warnings, and an inline preview image.

Writes CHOP-reference expressions onto the seq.vec uniform slots of an existing glslTOP, so named channels (low/mid/high/rms etc.) drive shader uniforms every cook. Creates no operators — pure parameter binding. Idempotent and composable with create_glsl_shader.

Build an audio analysis chain (spectrum + level + optional beat) and a spectrum visual driven by it. Creates a new baseCOMP under parent_path holding the audio source, an Audio Spectrum CHOP, an Analyze level, an optional Beat CHOP, a CHOP-to-TOP texture with a Sensitivity gain, the GLSL visual, and a Null output. Each visual_style renders the spectrum its own way: glsl=horizontal bars, geometric=radial bars, particle=dot field, feedback=ring tunnel, instancing=LED grid. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image. This is the only audio tool that produces a built-in visual: use extract_audio_features for level/bass/mid/treble channels or create_spectrum for per-band channels (no visual), and bind_audio_reactive to wire those channels onto an existing COMP's knobs.

Build a per-parameter automation lane that records a live parameter sweep into a circular buffer over N bars, then loops the recording back into the parameter on a bar-phase clock. Two modes: record (sample the target param every cook into a ring buffer) or loop (read the buffer back via Lookup CHOP bound to the target param). Re-calling with the same name and a different mode flips the state without rebuilding the network. Uses Beat CHOP → Select CHOP (rampbar) → Lookup CHOP playback, with COMP storage tracking mode/write_head/armed state. Returns a summary plus a JSON block with container path, mode, samples count, target, and any warnings.

Point at a folder and build a self-running clip montage: scans the folder for clips/stills, builds one Movie File In TOP per file feeding a Switch TOP (fractional-index crossfade) → Null TOP, and adds an auto-advance brain on top — a Beat CHOP (clock='beat' or 'bar' with division) or LFO CHOP (clock='interval') drives a CHOP-Execute DAT that picks the next clip per mode (sequential / random / shuffle-no-repeat / weighted) and animates the Switch index with a crossfade. Exposes Play / Index / Next / Prev / Crossfade / Bpm / Division / Mode / Seed custom pars on the container; emits a state_out Null CHOP so bind_to_channel can read clip_index/beat. Folder is read inside TD. Missing folder → empty pointable montage instead of error.

Build a beat-driven auto-VJ: a Beat CHOP + a CHOP Execute DAT that, every N beats, either randomizes a target COMP's numeric controls (a hands-free drift, set by Amount) or cycles through its stored cues — so a set keeps evolving on its own. Creates a new baseCOMP under parent_path holding the Beat CHOP and the engine DAT; it modifies the target COMP at comp_path (its custom controls or stored cues) live at runtime. Live Active/Beats/Amount knobs let you pause or retune on stage. Reuses the tempo clock, randomize_controls and manage_cue mechanisms. Pair with a generated system (or a control panel) as the target. Returns a summary plus a JSON block with the container path, created node paths, the target, mode, beats, amount, engine path, any node errors, and warnings (no preview image — the output is a CHOP engine, not a TOP).

Create an Azure Kinect body/depth scaffold with Kinect Azure TOP/CHOP placeholders, stream maps, and calibration notes.

Split an audio signal into EQ bands and route each band to its own target parameter(s) — the musician-friendly 'bass -> this, highs -> that' patch. Builds a container with: a Select CHOP isolating the source audio by absolute path (no cross-container wire), N audiofilterCHOP band-pass slices tiling the spectrum in log-frequency space (the same audioFilter idiom extract_audio_features uses), an Analyze CHOP per band measuring its level via rmspower, a Merge + Lag smoothing the per-band envelope (release in seconds), and a Null 'bands_out' carrying one channel per band named band0..bandN-1 (band0 = lowest). Each target route binds a band's smoothed level to a parameter by expression (op('<bands_out>')['band'] * scale + offset). The bands_out Null is also directly bind_to_channel-able for routes you add later. EXTENSION sibling of extract_audio_features (that one extracts named features; this one is the band-split + multi-target router). NOTE: the analyze 'rmspower' function value and the channel-rename pars are UNVERIFIED across TD builds — they are set in guarded tries with fallbacks (abs envelope / upstream channel names), and a single audiospectrumCHOP is the fallback if audiofilterCHOP is unavailable; per-item failures surface as warnings rather than failing the build.

Build a programmable step-grid sequencer driven by a Beat CHOP on the global TD tempo: a Table DAT holds the per-step pattern (values or 1/0 flags), and a CHOP Execute DAT fires on every beat boundary, reads the current step (count % steps) from the table, and dispatches — action=param sets a custom parameter to the step value; action=cue recalls the cue for active steps (cues stored with manage_cue). The deterministic, repeating-rhythm instrument between create_autopilot (random drift) and create_cue_sequencer (linear list): program a strobe on beats 1+3, a hue shift on the bar, etc. Reprogramme the grid live by editing the step_table DAT. NOTE: beat-callback timing is UNVERIFIED offline — check op().time.play if steps don't fire when the TD timeline is paused.

Create a BlackTrax tracking scaffold with receiver, trackable maps, zone maps, and calibration notes.

Create a Blender-to-TouchDesigner scene handoff scaffold for file-watch, OSC, or WebSocket metadata workflows.

Build a blob-position-tracking chain that drives parameters from the POSITIONS of multiple objects/hands in a camera (or a TOP) — the per-blob counterpart to create_motion_reactive's single aggregate motion value. Creates a container under parent_path with a Video Device In TOP (or a Select TOP pulling an existing TOP), a Monochrome + Threshold TOP to isolate bright blobs, a Blob Track operator assigning each blob a persistent slot, and a Script CHOP that normalizes the tracker's per-blob output into a deterministic 'blobs' Null CHOP with channels blob0_x, blob0_y, blob0_size, blob1_x, … Bind any parameter to op('…/blob_reactive/blobs')['blob0_x'] (or pass targets to bind by expression as value*scale+offset). Camera source may prompt for (and briefly hang on) a macOS camera-permission dialog. The Blob Track operator is a palette/CV op whose optype and channel naming vary by TD build — the chain is built fail-forward and warns (rather than failing) if it is unavailable, and the Script CHOP normalizes whatever channels the tracker emits. Returns a summary plus a JSON block with the container path, the blobs CHOP path, the tracked output TOP, the tracker type used, channel names, bound targets, and warnings.

Trace the contour/outline of a blob or silhouette into vector line art: source → monochrome → blur → threshold (the blob mask, optionally inverted) → optional Edge (boundary-band only) → Trace SOP (mask-to-polyline) → wireframe render. This is the CONTOUR-TRACE complement to create_vector_lines (full image vectoriser) and export_sop_to_svg, and is distinct from create_blob_reactive (which tracks blob position/reactivity — it does not draw the outline). Source can be the live camera (may prompt for macOS permission), a movie file, an animated synthetic blob (testable without a camera), or an existing TOP. Creates a new baseCOMP under parent_path. Exposes Threshold, Blur, and LineWidth controls. Returns a summary plus a JSON block with the container path, created node paths, output path, exposed controls, node errors, warnings, and an inline preview image.

Create a MediaPipe-ready interactive bubble installation over the live camera: a detected open palm emits soap-like bubbles, body and hand landmarks act as soft colliders that can bat or lift them, a visible body contour is rendered in the same output so the interaction reads clearly, bubbles stay inside the screen box, settle on the lower floor, and pop/fade after a configurable lifetime (default 30 seconds). By default it keeps the bubble count low and disables pose-wrist emission, so bubbles are created only by an open palm. Builds a self-contained Base COMP with a Script CHOP physics solver, Script SOP bubble outlines, Script SOP body contour, camera-background composite, Geometry/Render/Null TOP output, a frame cooker, and live controls for emission rate, gravity, drag, buoyancy, skeleton impulse, bubble repulsion, tracking smoothing, body radius, body contour, camera opacity, lifetime, and bounce. Provide hand_chop_path from setup_hand_tracking and body_chop_path from setup_body_tracking/create_pose_tracking for full interaction.

Build a body-reactive visual driven by full-body pose tracking: glowing marks that follow the 33 landmarks (head, hands, elbows, hips, knees, feet), rendered to a Null TOP. Creates a new baseCOMP under parent_path holding the pose source, a Geometry COMP (dots copied onto the landmark point cloud), a Camera, a Render TOP, and per-style post-processing. Styles: 'points' (crisp dots), 'glow' (bloomed dots), 'trails' (motion smears that follow the body). Source defaults to a SYNTHETIC animated pose so it builds and previews instantly with no camera and no plugin; switch to 'mediapipe' (the free torinmb plugin), 'osc', or an existing pose CHOP (e.g. from create_pose_tracking) for the real performer. The visual counterpart of create_audio_reactive, for the body instead of sound. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Build a bidirectional inter-app video bridge to another program (Resolume, OBS, MadMapper, a game engine…) in one container: receive an external feed IN and publish a TOP OUT at the same time. Picks the right operators per protocol — NDI (network, macOS & Windows), or Syphon (macOS) / Spout (Windows). direction 'in' only subscribes, 'out' only publishes, 'both' runs a full round-trip loop. The receive half is a receiver TOP → Null 'in_out'; the send half pulls source_top through a Select TOP into a publisher TOP. ANTI-FEEDBACK: the two halves are never wired together, so 'both' won't loop this app's own output back in. PLATFORM-GATED & largely UNVERIFIED-live: Spout needs Windows, Syphon needs macOS, and sender/receiver-name parameter names vary by TD build (probed at runtime) — the wrong platform or a real signal needs the actual sender present. This is the combined in+out version of create_live_source (in) and setup_output (out).

Build a CHOP recorder/player container that captures a source CHOP's channels over a fixed window using a Trail CHOP, snapshots the trail into a Table DAT on Stop, and plays the take back via a Datto CHOP indexed by a Timer CHOP–driven Lookup CHOP, terminating on a Null CHOP ready for bind_to_channel. Re-entrant: re-running with the same name updates controls without rebuilding. The last take is persisted in comp.store so it survives a .toe reload. Large takes (nchan × samples > 250k) are saved to disk instead of stored in the .toe. Note: time-dependent playback reads 0 when the TD timeline is paused — that is expected behavior.

[experimental] Builds a 12-channel pitch-class chroma vector (chroma_0..chroma_11) from an audio bus via FFT bin → pitch-class fold. Outputs a Null CHOP ready for bind_to_channel. Shares audioSource convention with create_transient_reactive / create_energy_reactive.

Builds a liquid-chrome / Y2K metaball generator: an animated Noise TOP (or external source) is blurred, thresholded into soft blobs, then a GLSL TOP renders a procedural environment-map chrome look (greyscale ramp + moving specular highlight) with 5 metal tints and 4 background modes. Creates a self-contained baseCOMP with Speed, Blob_Count, Metal_Color, and Background controls exposed on the container.

Build an Ableton-style clip launcher: a grid panel (Container COMP) of clip buttons, one per named cue (from manage_cue), for fast hands-on scene switching during a live set. Open the container in Perform/Panel mode and tap a clip to fire its cue — instantly, or (with morph_time) crossfading to it over N seconds (eased, the same engine manage_cue uses). Store the cues with manage_cue / create_control_panel first.

Build a colour-grading / LUT finishing stage over a source — the 'make the final output look graded' tool for VJ sets. A Level TOP applies lift/gamma/gain (brightness1 / gamma1 / contrast + black level), then an HSV Adjust TOP applies saturation + hue rotation; an optional LUT image file is loaded via a Movie File In TOP and fed into a Lookup TOP's second input to remap every colour. Creates a new baseCOMP under parent_path holding the chain. With an input_path the source is pulled in via a Select TOP (so it can live in another container); without one, a Ramp TOP test gradient is graded so it builds and previews standalone. Live Brightness / Gamma / Contrast / Saturation / Hue knobs are exposed. Output is a Null TOP. Returns a summary plus a JSON block with the container path, created node paths, the Level/HSV/output paths, exposed controls, any node errors, warnings, and an inline preview image. Use apply_post_processing instead to chain several distinct effects in series.

Classic colour-grading wheels — three tinted Level TOPs run in series for shadows (lift, gamma-biased), midtones (gamma) and highlights (gain, brightness-biased), then a master Level TOP for global offset (blacklevel), then an HSV Adjust TOP for saturation. Each wheel is an [r,g,b] multiplier in 0..2 (1,1,1 = neutral). Builds a new baseCOMP under parent_path holding the chain; with source_path the upstream TOP is pulled in via a Select TOP, without one a Ramp TOP test gradient is graded so the chain previews standalone. Exposes per-channel LiftR/G/B, GammaR/G/B, GainR/G/B float knobs plus Offset and Saturation (live-bound to the underlying Level/HSV pars). Output is a Null TOP. Use create_color_grade for a simpler single-Level + HSV chain, or apply_post_processing to chain several distinct effects.

Build a companion performance surface for an existing node/COMP: infer useful primitive parameters, add bound custom parameters, create a playable fader/cue panel, and optionally append a read-only preflight report. Use after generating a component that needs a human-facing control surface without hand-wiring every parameter.

Create one empty COMP under parent_path to hold a visual system, then tile it into the parent's network grid clear of existing siblings. comp_type picks a Container COMP (a 2D panel) or a generic Base COMP. Returns the created node's path, type, and name. Use a higher-level Layer 1 tool instead when you want a fully built, wired network rather than an empty shell.

Expose live controls on a COMP: append custom parameters (sliders, toggles, menus, RGB, pulse) and bind them to node parameters so the artist can drive a generated system in real time. Point comp_path at a system container and list the controls; use each control's bind_to to wire it to one or more 'nodePath.parName' targets.

Build a playable performance panel (a Container COMP of visual widgets) for live use, beyond the parameter dialog: vertical faders that drive parameters, and buttons that recall or morph to named cues (from manage_cue). Open the container in Perform/Panel mode for a touchable surface — faders move their parameters, cue buttons fire scenes (instantly or with a crossfade).

Render a true cube-map dome master — the higher-fidelity follow-up to create_dome_output (which only warps a flat equirectangular source). A 3D scene is rendered by a Render TOP in cube-map mode (rendermode 'cubemap', which outputs a real cube-map texture in one render — no separate Cube Map TOP), or an existing cube-map source is pulled in via a Select TOP; then a GLSL TOP samples that cube map by 3D direction (TD's built-in samplerCube sTDCubeInputs[0]) to produce a fisheye fulldome master or a full 360°×180° equirectangular image, ending on a Null ready for setup_output. Creates a new baseCOMP under parent_path (named by name) holding the cube-map source (or the test scene's Geometry/Camera/Light/Render TOP), GLSL remap, and Null output. Sampling a real cube map avoids the equirect pole-pinch/seam. With expose_controls, a live Fov knob sets fisheye coverage and a Rotation knob spins the dome horizon. Returns a summary plus a JSON block with the container path, created node paths, the cube-source/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Build a bar-quantized cue timeline: a Beat CHOP (on the global tempo) + a CHOP Execute DAT that, on each bar (or beat) boundary, advances through an ordered list of steps and recalls — or morphs over morph_seconds — that step's cue on a target COMP. The deterministic, musically-timed counterpart to create_autopilot (which is random/cyclic). Reuses manage_cue's stored cues and the same cue_morph engine, so store the target's cues with manage_cue first. Live Active / Step / BarsPerStep controls let you pause, jump, or retune on stage.

Build a datamosh (broken-codec / time-echo / ghost-trail) visual effect network in one call. Three modes: 'feedback_echo' (classic datamosh — a Feedback TOP loop decays and re-composites each frame, creating ghost trails); 'frame_blend' (blends current and previous frames for a motion-blur smear); 'time_echo' (Time Machine TOP samples different time offsets per pixel for per-pixel delayed ghosting). All modes expose a Decay knob; set source to an existing TOP path or omit it for a built-in animated test source. Returns a container with a Null TOP output, exposed controls, and a live preview.

Wire arbitrary external data (weather, follower count, sensor readings, OSC values) onto a COMP's custom numeric parameters — the data counterpart to bind_audio_reactive. Point target at a COMP with numeric custom-parameter knobs, source_chop at a live-data CHOP (e.g. a create_data_source Null), and provide explicit mappings (data channel → param name) each with an input range [in_min, in_max] and output range [out_min, out_max] so the data is correctly re-mapped to the parameter's visual range. Set smooth > 0 to insert a Lag CHOP (symmetric attack+release) so noisy or jittery data does not flicker the visuals. Fail-forward: a missing source CHOP or absent channel are warnings — only a missing/non-COMP target is fatal. Build the data CHOP first with create_data_source; use bind_to_channel for finer single-parameter control.

Ingest live external data onto a binding-ready channel/table — the input counterpart to create_data_visualization and bind_to_channel. 'json'/'csv' poll a URL with a Web Client DAT (and cook from a static sample of fields when no url is given, so it works offline); 'osc' listens on a UDP port; 'serial' reads a device. Numeric fields become channels on an output Null CHOP (named for each key) so other tools can bind to them; the raw text is exposed on a Null DAT. Live OSC/serial values only appear when a sender/device is present.

Advanced live-data ingest for HTTP polling and WebSocket streams — the richer-transport sibling of create_data_source. http_poll: webclientDAT driven by a timerCHOP so polling cadence is a real CHOP signal you can retune/sync; supports custom HTTP method, headers, and body. websocket: websocketDAT with auto-reconnect, persistent connection. Both: JSONPath-lite selectors ($.key, $.key.sub, $.arr[0].field — no wildcards/filters) map response fields to named channels on an output Null CHOP ready for bind_to_channel. Raw body exposed on a Null DAT. Use create_data_source for simple one-knob JSON/CSV polling; use this tool when you need real POST/headers, fine-cadence timer sync, or a WebSocket stream.

Build a data-driven visualization: a data source feeds a CHOP that drives a chart TOP. Creates a new baseCOMP under parent_path holding a 'data' source operator (seeded with placeholder values), a DAT-to-CHOP / CHOP-to-TOP conversion, a Scale level, the chart visual, and a Null output. Wire your real data into the created 'data' node. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings (including a reminder to wire real data), and an inline preview image.

Create a Blackmagic DeckLink video-device input/output router scaffold with route maps and hardware-gated safety notes.

Build a DJ-style VJ mixer. Without decks[], it preserves the legacy A/B Cross TOP mixer with GainA/GainB controls. With decks[], it builds a 2-8 deck mixer: every deck pulls a source TOP (or a test source) through gain and FX-send Level TOPs, decks 3+ blend into a running Cross TOP chain, a Switch TOP provides hard transition cuts, a final Cross TOP blends program vs cut, and an additive FX-send bus returns per-deck sends into the master. Output is a Null ready for post-processing or setup_output.

Create a DepthAI/OAK camera scaffold with OAK Device, OAK Select TOP/CHOP placeholders, stream maps, and hardware-gated setup notes.

Push a flat plane into real 3D relief by a depth/luminance map: a subdivided grid whose vertices are offset along Z by a GLSL displacement material sampling the source's brightness, rendered with a camera + light so it reads as depth that shifts with the view. Unlike create_depth_silhouette (a flat 2D mask), this is true geometry — a 2.5D landscape. Source can be the live camera (may prompt for macOS permission), a movie file, an animated synthetic pattern (testable without a camera), or an existing TOP (e.g. a real depth map). subdivisions sets the relief resolution, depth the push amount, invert flips bright↔near. Creates a new baseCOMP under parent_path holding the source, height map, Geometry COMP + GLSL displacement MAT, Camera, Light, Render TOP, and a Null output. Exposes Depth and Zoom knobs — bind Depth to a tempo ramp or an audio feature to make the surface heave. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Wraps TDDepthAnything v2 (community TOX by IntentDev) to convert any 2D image/video TOP into a depth map TOP using Depth Anything v2 via NVIDIA TensorRT/ONNX — no Kinect or RealSense required. Given a source TOP path, drops the TOX into a fresh container, wires the source, exposes a depth Null TOP whose path can be fed directly into create_depth_displacement, create_depth_pop_field, or create_depth_silhouette. Requires the user to have installed TDDepthAnything.tox from https://github.com/IntentDev/TDDepthAnything and an NVIDIA GPU with CUDA + TensorRT pre-built weights (.engine/.onnx). NOT supported on macOS. First cook may take 30–60 s for engine compile. Returns container_path, dropped_tox_path, depth_top_path (the key output), source_top_path, output_resolution, model_variant, and warnings.

Build a depth-driven GPU POP scatter field: consumes a depth/mask TOP and uses lookup_texture_pop to sample depth for displacement/scatter proxies (and optionally color). When depth_top_path is omitted, auto-spins-up a setup_segmentation MediaPipe chain inside the container and uses its mask Null TOP as the depth source. Scatter modes: 'displace' applies a uniform depth-scale proxy, 'emit' adds an emission-like jitter scatter proxy, 'both' does both. Forward-compatible: pass create_depth_from_2d (Depth Anything, W4) output as depth_top_path. NOTE: POPs are Experimental — op types and par names are fail-forward, probe on a live TD. Returns a JSON block with container path, depth source info, controls, warnings, and unverified probe record.

Extract a silhouette / body mask from a depth or video source — a person's white outline on black you can composite, fill with colour, or use as a mask for reactive visuals (interactive installations / camera-reactive sets). The signal is smoothed (Blur TOP), keyed to a mask (Threshold TOP), optionally inverted (Level TOP) and optionally filled with a colour keyed through the mask (Constant + multiply Composite). Creates a new baseCOMP under parent_path holding the source, Blur, Threshold, Level, optional Constant + Composite fill, and a Null output. Source defaults to a self-contained synthetic noise field so it builds and previews with ZERO device permissions; pick 'file' for a clip, or a 'kinect_azure'/'kinect'/'realsense' sensor for the live installation (may prompt for macOS permission). Exposes Threshold (bind to proximity/audio), Smooth, Invert (+ FillColor) and outputs a Null TOP. Use create_depth_displacement instead for true 3D relief geometry rather than a flat 2D mask. Returns a summary plus a JSON block with the container path, created node paths, the mask/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Turn object/person detection into TouchDesigner control channels — with NO CUDA requirement. Two backends: 'websocket' subscribes to an external detector process that streams JSON detections over a WebSocket (runs on any machine/GPU, or none), and 'onnx' scaffolds a CPU Script CHOP that runs an .onnx model via onnxruntime inside TD. Either way the output is a Null CHOP carrying a stable contract — presence (0/1), count, and per-object normalized bboxes (obj1_x, obj1_y, obj1_w, obj1_h, obj1_score, …) — ready for bind_to_channel. (Detection idea inspired by TDYolo, MIT-licensed; no code copied.)

Create a Direct Display Out TOP scaffold with monitor inventory, display maps, and inactive-by-default safety notes.

Build a displacement-warp stage over a source — the 'heat-haze, liquid, audio-pushed pixels' tool for VJ sets. A Displace TOP warps the source image using a second image as a displacement map; the map is driven by one of three modulators: 'noise' (animated Perlin noise — smooth, continuous warp), 'second_top' (your own displacement map via a Select TOP), or 'audio' (audio FFT spectrum converted to a texture via CHOP-to-TOP, so the warp reacts to the music). Without a source the chain builds over a Ramp TOP test gradient and previews standalone. The Displace TOP's weight (displaceweight1) maps to the amount parameter; the Noise TOP translate speed maps to speed. Amount and Speed are exposed as live knobs. Output is a Null TOP. Returns a summary plus JSON with the container path, created node paths, controls, errors, warnings, and an inline preview image. Pairs with extract_audio_features for reactive warp and apply_post_processing to chain with other effects.

Build a retro dither effect: ordered Bayer (2×2/4×4/8×8), checker, noise, or single-pass error-diffusion — quantising to a 2/4/16-colour palette. Supports mono, duotone (Game-Boy-green default), or RGB quantisation mode. Creates a new baseCOMP under parent_path holding the source (or a self-contained noise source), a GLSL TOP with an inline shader, and a Null output. Exposes Mix, Threshold, and Scale knobs for live tweaking. Returns a summary, node paths, exposed controls, and an inline preview image.

Build a DMX/Art-Net (or sACN) output chain from a fixture list. For each fixture (rgb, rgbw, par64, movingHead8, movingHead16) creates a Constant CHOP with one named, default-valued channel per DMX slot (prefixed '/'), inserts pad Constant CHOPs to keep DMX-slot alignment, merges them all into one stream, and drives a dmxoutCHOP (interface, universe, netaddress, rate). Returns the container + a JSON report with paths, fixtures, total channels, exposed controls (Universe / Rate / Net Address), and warnings. Per-fixture sliders are NOT auto-exposed — bind individual channels later with bind_to_channel / animate_parameter on op('rig_out')['fix1/r'] etc.

Remap a source TOP (treated as an equirectangular / panoramic master) into a square single-output dome master for planetarium fulldomes / 360 — the curved complement to create_multi_output's flat tiling. A Select TOP pulls the master in, a GLSL TOP warps it (fisheye: equirect → centred dome disc using fov; equirectangular: near-passthrough identity remap) via a shader held in a Text DAT, ending on a Null ready for setup_output. Creates a new baseCOMP under parent_path holding the Select TOP, GLSL remap, and Null output. With expose_controls a Rotation knob spins the dome horizon. Note: this GLSL-remaps an existing flat source — use create_cubemap_dome instead for a true cube-map render (higher fidelity, no equirect pole-pinch/seam). Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings (including the cubemap-follow-up note), and an inline preview image.

[experimental] Build a song-structure (build / drop / breakdown) edge detector COMP with adaptive thresholds. Listens to an existing audio CHOP (audioSource) or a freshly created Audio Device In, follows a long-window envelope, and runs a Script CHOP that maintains a rolling buffer (last windowSec seconds) to derive an adaptive mean (mu) and std (sigma). Emits a 5-channel Null CHOP out with: energy (smoothed RMS 0..1), state (0=breakdown, 1=build, 2=drop), and three 1-sample edge pulses build_edge / drop_edge / breakdown_edge. buildThreshold and dropThreshold are k-multipliers of sigma above mu (NOT absolute amplitudes), so the detector self-calibrates to the current mix loudness. Hysteresis (4 cooks above to step up, 30 below to fall back) stops chattering at thresholds. windowSec/Buildthreshold/Dropthreshold are exposed as custom params on the parent COMP so artists can tweak live. Default audio source builds an Audio Device In CHOP (may pop the macOS mic-permission dialog once — click Allow); pass audioSource to skip the device.

Drop a TouchDesigner Engine COMP that loads an external .tox in a separate TD subprocess — an independent crash domain with its own cook + (optionally) a second GPU thread, ideal for hosting heavy or unstable subgraphs. Sets the .tox file, optional reload pulse (re-pulls the .tox once), perform-mode override, and color-map toggle. The .tox's own outTOP/outCHOP/outSOP/outDAT operators surface as connectors on the Engine COMP for downstream wiring. Complements make_portable_tox (which produces the shippable .tox). Note: sub-process spin-up forks a TD process — the first cook can be multi-second on slow disks; that is not a hang. par.reload / par.usecolormap / par.performmode are guarded with hasattr so unverified par names degrade to warnings rather than throwing.

EXPERIMENTAL — Build a reactive signal-shaping chain (attack/release envelope + threshold gate or sidechain ducking) from a CHOP channel, for 'pump the whole layer on every kick' or similar sidechain effects. Creates a container with: a Select CHOP isolating the source channel by absolute path (no cross-container wire), a Lag CHOP shaping the attack/release envelope, a Logic+Math CHOP threshold gate (gate mode: silence the output below threshold) or an inverted Math CHOP (duck mode: output dips to 0 on a hit, rises on silence — classic sidechain pumping), and a Null CHOP as the stable output handle. Optionally binds the shaped output to target parameters by expression. The gate threshold uses a Logic CHOP whose par names (convert/boundmin/boundmax) match detect_onsets — but these are UNVERIFIED across TD builds; gate reads near 0 at the 0.2 default with most sources — tune threshold live. Use bind_to_channel with attack/release for a simpler Lag-only envelope without a gate.

Build a Euclidean rhythm sequencer: given pulses evenly distributed across steps via Bjorklund's algorithm (with optional cyclic rotation), it writes the resulting on/off pattern to a Table DAT and fires one dispatch per active step on each beat boundary. The deterministic, mathematically-grounded sibling of create_beat_grid_sequencer — program rhythms by musical intent (e.g. E(3,8) tresillo, E(5,8) cinquillo, E(4,16) four-on-the-floor) rather than by hand-editing cells. Sweep the Pulses/Rotation custom parameters live and the table re-shapes in place. action=param sets a custom parameter to on_value/off_value per step; action=cue recalls a cue per active step (cues stored with manage_cue). NOTE: beat-callback timing is UNVERIFIED offline — check op().time.play if steps don't fire when the TD timeline is paused.

Bridge TouchDesigner to the outside world: OSC/MIDI input (a control surface — bind incoming channels straight to parameters), OSC/MIDI output (send a CHOP's channels back out for bidirectional feedback to lighting desks, other apps or hardware — pass source_path), DMX/Art-Net output for lighting (dmx_out for any DMX desk; artnet_out for network Art-Net/sACN pixel-mapping of LED strips & stage fixtures), RTMP output to live-stream a TOP to Twitch/YouTube/OBS (rtmp_out — NVIDIA GPU on Windows only), or NDI / Syphon-Spout video input. To discover which channel a control sends (a 'MIDI learn'), wiggle it and read the input CHOP with get_td_nodes, then bind_to that channel. Validate live where possible, but real signal needs the hardware/sender present.

Build a multi-projector architectural facade rig: one source TOP fanned into N per-projector branches, each with Crop → Corner Pin keystone → edge-blend Ramp/Composite mask → Level brightness, plus per-projector Null outputs and a summary preview composite. Ships as a calibration skeleton; per-projector corners, color match, and (when 3D) camera transforms are left to live install alignment.

Build a feedback-based visual system: a seed feeds a loop that is transformed (blur/displace/etc.) and fed back each frame. Creates a new baseCOMP under parent_path holding the seed, a Feedback TOP, a 'maximum' Composite, the transform chain, a Level decay node, an optional GLSL colorize pass, and a Null output (the Feedback TOP samples the Level node to close the loop). Great for evolving, hypnotic visuals. Exposes a live 'Feedback' decay knob. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image. Use this for a general feedback look with a chosen seed type and an ordered chain of effects; for the specific infinite-zoom/rotate spiral (with Zoom/Rotate/HueShift/Decay knobs) use create_feedback_tunnel instead.

Build a parameterized infinite-zoom/rotate feedback tunnel: a seed TOP is composited with its own fed-back, zoomed, rotated, and decayed frame each cook to produce a hypnotic inward-spiral tunnel. Four audio-bind-ready controls (Zoom, Rotate, HueShift, Decay) are exposed on the container for live performance. A built-in animated noise seed is used when no source TOP is given. The recipe-validated topology (noiseTOP → feedbackTOP + compositeTOP-maximum → transformTOP sx/sy → blurTOP → levelTOP brightness1/huerotate → nullTOP, loop closed by feedbackTOP.par.top) is created inside a new baseCOMP under parent_path. Returns a summary, the container + node paths, exposed controls, any node errors, and an inline preview image. This is the fixed zoom-and-rotate spiral preset; for a general feedback loop with a choice of seed type and an arbitrary ordered chain of effects (blur/displace/edge/…) use create_feedback_network instead.

Build a moving-head lighting rig with BOTH a DMX/Art-Net output chain AND a 3D visual previsualization. For each fixture: a Constant CHOP holds an 8-channel movingHead8 block (pan, tilt, dimmer, r, g, b, strobe, gobo, prefixed '/…'), padded and merged into a dmxoutCHOP (interface, universe, netaddress, rate); and a Geometry COMP 'head' with a tube-cone beam whose pan→ry and tilt→rx rotation is expression-driven straight from that fixture's DMX pan/tilt channels (0-255 mapped across pan_range/tilt_range degrees), all rendered under one camera+light Render TOP. This adds the live 3D preview on top of what create_dmx_fixture_pipeline (DMX-out only) does. Bind individual channels later with bind_to_channel / animate_parameter on op('rig_out')['fix1/pan']; the previz updates automatically.

Build a two-pass Kyprianidis-style flow abstraction: an edge-tangent-flow (ETF) bilateral smoother followed by a flow-based DoG (FDoG) line extractor — oil-painting smooth interiors with crisp coherent ink edges. Creates two glslTOPs + companion textDATs under parent_path, fed by a Select TOP from the source TOP and terminated by a Null TOP. Strength/Edge/Iterations are exposed as live parent-par-bound uniforms; blur radius, sigmas and tau are baked in at build time. Iterations boosts effective ETF strength in-shader (single-input pass, no ping-pong feedback).

Build a real-time 2D fluid/ink/dye simulation (stable-fluids style: semi-Lagrangian advection + Jacobi pressure solve + gradient-subtract projection + dye advection) as a stack of GLSL TOPs in feedback loops inside a new baseCOMP under parent_path. Exposes artist-facing controls (dye color, injection radius/strength, viscosity, dissipation, pressure iterations, inject U/V) and optionally binds a CHOP at audio_path so audio drives the dye injection strength. With injection_mode='auto', a slow LFO drives the splat point so the sim shows life with no input. Returns a summary plus a JSON block with the container path, created node paths, the dye_out output path, exposed controls, any node errors, warnings, and an inline preview image.

Drops the community TDGS .tox by Anglerfish-graphics into a fresh baseCOMP, loads a .ply or .splat Gaussian Splat asset, optionally binds an existing cameraCOMP, and exposes a clean output renderTOP at 720p–2160p. Assets can be exported from Polycam, Postshot, Luma, or Nerfstudio. The wrapper connects to any existing tdmcp camera rig (create_camera_orbit, XY pads, MIDI). REQUIREMENTS: TDGS by Anglerfish-graphics installed (https://github.com/Anglerfish-Graphics/TDGS); TouchDesigner build ≥2023.30000; CUDA-capable NVIDIA GPU on Windows. macOS and AMD GPUs are not supported by TDGS — the tool returns a friendly error. VRAM: 720p≈2GB, 1080p≈4-6GB, 1440p≈12GB+, 2160p≈16GB+ (OOM crashes TD — no friendly error, start at 720p on a laptop). Returns container_path, dropped_tox_path, output_top_path, camera_path, warnings, and a preview image.

Create an evolving generative visual. Creates a new baseCOMP under parent_path holding the generator (a recipe network, a GLSL TOP + Text DAT, or a noise chain) ending in a Null output. reaction_diffusion/noise_landscape use validated recipes; strange_attractor, voronoi, and fractal render built-in GLSL; custom_glsl accepts caller shader source only when TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1; the rest fall back to animated noise (with a warning). Exposes a live 'Speed' knob (except for recipe-built techniques). Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, the technique, any node errors, warnings, and an inline preview image.

SYNTHESIZE audio — generate sound rather than react to it. Builds an audio synthesis chain ending on a Null CHOP carrying the signal: 'oscillator' (a single tone, choose sine/triangle/sawtooth/square + frequency), 'fm' (two oscillators, one frequency-modulating the other for metallic/bell timbres), or 'noise' (a Noise CHOP shaped by a low-pass filter for textures). A Volume gain sets the level. Playback is opt-in: set to_device=true to route it to an Audio Device Out CHOP (default off, so the build stays silent and never prompts for audio hardware). Creates a new baseCOMP under parent_path holding the synth chain. The output Null feeds create_spectrum/create_waveform, bind_to_channel, or the speakers. Audio CHOPs are time-dependent — the signal is silent while the TD timeline is paused. Returns a summary plus a JSON block with the container path, created node paths, the audio Null path, the synth settings, the device-out path (if any), any node errors, and warnings (no preview image — the output is a CHOP, not a TOP).

Turn GeoJSON (e.g. OpenStreetMap-derived) into a 3D city visualization. Reads Point / LineString / Polygon / Multi* features, projects lat/long via a Mercator projection normalized to a unit box, and builds a Script SOP that lays out point clouds for points and polylines for streets/building footprints — optionally extruded into 3D ribbon 'walls' using each feature's numeric 'height' property — all wrapped in a Geometry COMP under a camera+light Render TOP for instant preview. NOTE: OpenStreetMap map data is © OpenStreetMap contributors and licensed under the Open Database License (ODbL); you must attribute it when visualizing OSM-derived data.

Build a glitch / corrupted-signal visual: RGB channel split, noise-driven blocky/slice displacement and horizontal band tearing over a source. Creates a new baseCOMP under parent_path holding the source, a noise driver, a Displace TOP, a GLSL RGB-shift pass, and a Null output. With input_path it glitches an existing TOP (pulled in via a Select TOP); otherwise it uses a self-contained animated colour-noise source (no device permissions). Exposes Amount (master intensity — bind to audio/beat), Speed, RGBShift and BlockSize knobs. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image. A signature live VJ look.

Create a GLSL MAT under parent_path for custom-shaded geometry. Caller shader source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. The pixel/vertex/(optional) geometry shader source is placed in companion Text DATs (<name>_pix/_vert/_geo) and wired to the GLSL MAT's pixel/vertex/geometry parameters; numeric uniforms are best-effort bound on the Vectors sequence and samplers on the Samplers sequence. Pixel shader must declare out vec4 fragColor;. Returns the GLSL MAT path, the DAT paths, and warnings for known TD GLSL footguns (missing fragColor, F1/F2 preamble collision, undeclared uTime, sampler bindings needing manual wiring). Artist assigns the MAT to a Geometry COMP via its material par.

Create a GLSL TOP under parent_path that renders a custom fragment shader (and optional vertex shader). Caller shader source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. The shader source is placed in companion Text DATs (<name>_frag and, if given, <name>_vert) and wired to the GLSL TOP's pixel/vertex parameters; numeric uniforms are best-effort bound on the Vectors page and the output resolution is set. Returns the GLSL TOP path, the fragment/vertex DAT paths, and any warnings (e.g. sampler2D uniforms or uniform binds that need manual wiring).

Build a high-count GPU particle / point field: position and velocity are simulated entirely on the GPU in two RGBA32float feedback-TOP loops (velocity integrates forces — noise/curl/gravity; position integrates velocity), then a Geometry COMP instances a tiny dot once per texel, reading XYZ from the position texture. Creates a new baseCOMP under parent_path holding the velocity/position feedback loops, the instanced Geometry COMP, Camera, Light, and Render TOP ending in a Null output. Reaches counts (side², up to 512²≈262k) well beyond the CPU create_particle_system (use that for a simpler, lower-count CPU emitter). This is the general-purpose GPU drift field (noise/curl/gravity); pick a sibling instead for other motion: create_particle_flock for boids separation/alignment/cohesion, image_to_particles when particles should spring to the pixels of an image/video, create_pop_particle_system for TouchDesigner's native POP particle network. Exposes PointSize and Zoom knobs. Optional reactivity energises the field live: 'audio' drives it from mic/line RMS, 'motion' from camera frame-difference energy (both bound to the velocity shader's uReact uniform). Returns a summary plus a JSON block with the container path, created node paths, the particle count, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Build an L-system / vine-growth generator: a Script SOP iterates a context-free rewriting grammar from axiom for generations steps, then walks the resulting string as a 3D turtle to draw a polyline tree. Recognised symbols: F (forward draw), f (forward no draw), + - (yaw ± branchAngle), & ^ (pitch), \ / (roll), [ ] (push/pop state). Other symbols are no-op constants (use X/A/B as grammar variables that expand but don't draw). Multiple rules sharing a from symbol trigger weighted-random stochastic selection (weight defaults to 1; seed controls the RNG). The polyline tree is thickened with a Tube SOP, recentred, and rendered. Complements create_particle_flock (boids) and create_gpu_particle_field (curl-noise) as the deterministic CPU-geometry idiom. Returns a summary plus a JSON block with the container path, output path, rules DAT path, exposed controls, errors, warnings, and an inline preview.

Build a print/comic print-look effect: halftone dots, CMYK colour separation, ordered dithering, or posterized stepped colour — classic retro aesthetics in one GLSL pass. Creates a new baseCOMP under parent_path holding the source (or a self-contained noise source), a GLSL TOP with an inline shader implementing the chosen style, and a Null output. With source it stylises an existing TOP (pulled in via a Select TOP); without it uses a self-contained animated colour-noise source (no device permissions). Exposes Mix (blend original vs stylised), DotSize, and Angle knobs. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Build a MediaPipe-hands to TDAbleton TDA_Mapper performance control network. It outputs map1=left pinch, map2=right pinch, map3=left wrist roll, map4=right wrist roll, creates a skeleton overlay with star joints plus the thumb-index line, and optionally relinks an existing TDA_Mapper to the generated mapper_send CHOP. Uses TDAbleton directly; AbletonMCP is not required.

Create a TouchDesigner Base COMP that converts hand landmarks into a stable gesture-control Null CHOP for palm holograms, lasers, audio controls, and other hand-reactive visuals. It creates helper nodes under parent_path, returns the component/output paths and created-node report, and exposes debounced channels such as palm_open, float_x/y, palm_size, pinch_active, pinch_power, scale_target, light_gain, and audio_level. Use source='synthetic' for camera-free previews, source='mediapipe' to build/use setup_hand_tracking, or source='existing_chop' with hand_chop_path when a hand landmark CHOP already exists.

Build a palm-anchored hologram visual driven by create_hand_gesture_bus. Defaults to a synthetic previewable holographic cube; open palm controls visibility, the float anchor keeps it above the palm, and opposite-hand pinch drives scale, glow, and optional futuristic synth/device audio.

Build a luminance (and optional per-channel RGB) histogram video scope for any TOP. Computes the histogram on the GPU using a GLSL TOP (bins×1 output), samples into a CHOP, normalises, and renders through choptoSOP → renderTOP. Output is a single Null TOP ready for previews or bind_to_channel. Implements the roadmap Milestone 2 histogram scope panel as a standalone focused tool. This is the single-scope, working histogram (the one create_video_scopes can't render in TD 099); for a combined waveform/parade/vectorscope monitor use create_video_scopes.

Create a Hokuyo LiDAR scanner scaffold with hardware-gated CHOP setup, scan-zone maps, and calibration notes.

Define N rectangular zones over a camera / motion input; each zone fires when motion in that region crosses a threshold. Builds a stock-TOP chain — a motion-energy TOP (monochrome → previous-frame cache → difference), then per zone a cropTOP (region isolate) + analyzeTOP average + toptoCHOP, merged into one level CHOP, then a scriptCHOP that emits per zone a *_state channel (0/1 active) and a *_dwell channel (seconds continuously active). Ends on a 'zones' Null CHOP as the bind point — wire cues via bind_to_channel to op('…/interaction_zones/zones')['zone0_state']. Camera-only (no depth cam). Source is a TOP pulled via selectTOP, or a built-in synthetic animated Noise TOP when omitted (offline-safe, cooks clean on any install with no external asset). A live Threshold knob tunes sensitivity. Zones are normalized rects (x,y = top-left corner, w,h = size); the top-left image convention is mapped to TD's bottom-left uv origin. Returns a summary plus JSON with the container path, created node paths, the zones Null path, per-zone state/dwell channel names, the zone definitions, threshold, and warnings (no preview image — the output is a CHOP, not a TOP).

Build a synthetic-safe interactive projection mapping rig for a USB webcam plus projector: camera/synthetic/existing TOP input, frame-difference motion field, placeholder blob/post-it mask, cyan dot and magenta card visual TOPs, manual Corner Pin projection mapping, debug switch, live controls, and an out1 Null TOP. Defaults to source='camera' for installations, but source='synthetic' previews without camera permission. Returns output/debug paths and explicit warnings for camera, blob tracking, and physical calibration states.

Create a deterministic TouchDesigner scaffold for iPhone depth senders such as TDLidar, Record3D, or a generic NDI/OSC source. Builds live/video receiver TOPs, color_out, depth_preview, OSC sensor input, sensors_out, setup hints, and an optional point-cloud placeholder. This is a scaffold and returns warnings where sender-specific metric depth decoding must be validated live.

Instantiate a self-contained Jump-Flooding-Algorithm Voronoi generator (stained-glass / cell pattern) as GLSL TOPs — seeds → jfa_init → K halving passes → color_pass → null. Exposes live PaletteMode / SeedCount / Speed / Jitter / EdgeThickness / EdgeColor / ColorA / ColorB controls and previews the output TOP. Pass count auto-derives from resolution (log2(max(w,h))); override with step_count.

Wrap a source in a kaleidoscope / radial-mirror symmetry effect — a signature VJ look. Folds the image into N identical mirrored wedges around a centre, with live Segments / Rotation / Zoom / Center controls. Creates a new baseCOMP under parent_path holding the source, a single GLSL fold pass, and a Null output. Pass input_path (an absolute TOP path) to kaleidoscope an existing visual, or omit it to generate a self-contained noise source that previews on its own. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Composite a keyed performer, logo, or any source over a background visual — the green-screen / chroma-key / matte tool for installations and live camera work. Creates a self-contained baseCOMP under parent_path that holds the full chain: source (Select TOP or test card) → key stage → composite → Null TOP output. Three key_type modes: 'chroma' (Chroma Key TOP, keys on Hue/Sat/Val range — best for green/blue-screen), 'luma' (Level TOP threshold + Matte TOP — keys by brightness), 'rgb' (RGB Key TOP, keys on R/G/B channel ranges — best for a solid background colour). key_color sets the target colour to remove (chroma/rgb modes); tolerance widens the key range; softness feathers the edge. With a source the footage is pulled in via a Select TOP (so it can live in another container); without one, a constant green test card is used so the chain builds and previews standalone. With a background the composited result is placed over it; without one, a diagonal ramp is used. Tolerance/Softness/KeyColor controls are exposed on the container. Output is a Null TOP. Returns a summary with the container path, created node paths, exposed controls, any node errors, warnings, and an inline preview image.

Animate parameters along a keyframed curve synced to the timeline — structured motion beyond animate_parameter's LFO (use animate_parameter instead for continuous LFO oscillation). Give time/value keyframes and the targets; this creates a baseCOMP 'keyframe_anim' under parent_path containing an Execute DAT that interpolates the curve each frame (linear or smooth easing) and writes the value onto every target parameter, looping over the keyframe span (or holding the last value). Use it for choreographed moves (a build-up, a drop, a sweep). Returns a summary plus a JSON block with the container path, the Execute DAT (hook) path, the loop duration, the targets, and warnings (including any targets that did not resolve). Returns a friendly error if the keyframes do not span a positive duration.

Build a synthetic-safe Kinect v2 / FreenectTD projected wall harp in an isolated Base COMP. The network can create a FreenectTOP depth path when explicitly enabled, listen to an external OSC Kinect bridge with source='osc_kinect', or build a synthetic fallback. It extracts left/right hand centroids, divides the projection into configurable musical zones, triggers short electronic plucks on zone entry, renders a denser vibrating curtain of projected strings, and exposes depth/mask/hands/audio plus bridge-status diagnostics. If FreenectTD or Kinect hardware is unavailable, the tool returns warnings instead of throwing, so the visual/audio/trigger chain can still be tested offline.

Build a self-contained animated / kinetic typography layer — a word or line that flashes, pulses, or slides, the signature live-VJ lyric-flash effect. A Text TOP renders the text; an LFO CHOP at the given Rate (Hz) drives the animation: 'flash' gates a Level TOP's alpha/opacity hard on/off (a square wave — the text vanishes between flashes rather than turning black, so it pops cleanly in and out over a background), 'pulse' drives a Transform TOP's scale plus a Level TOP alpha fade (a sine, the text breathes), and 'slide' scrolls the Transform TOP's translate-X. Creates a new baseCOMP under parent_path holding the Text TOP, the LFO, the per-mode Transform/Level nodes, an optional Composite, and a Null output. With an input_path the text is composited OVER that source (pulled in by a Select TOP, so it can live in another container); without one it animates on a transparent frame. Rate is free-running for v1 — bind the LFO's frequency to a beat CHOP (or a Trigger to a detect_onsets channel) to lock the flashes to the tempo. This is for a single animated word/line; for a static caption or title use create_text_overlay, and for multi-line scrolling tickers/credits rolls/typewriter reveals use create_text_crawl. Returns a summary plus a JSON block with the container path, created node paths, the text/lfo/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Build a VJ-style layer mixer: combine source TOPs into one output. Creates a new baseCOMP under parent_path. 'crossfade' makes an A/B Cross TOP with a Crossfade knob (the classic two-deck mix); any other blend mode composites the inputs (add, difference, hardlight, glow, …). Sources are pulled in via Select TOPs so they can live anywhere; with fewer than two, demo sources (noise + ramp) are created. Output is a Null ready for post-processing or setup_output. Returns a summary plus a JSON block with the container path, created node paths, the source and output paths, exposed controls, any node errors, warnings, and an inline preview image.

Build a VJ-style N-layer compositor: stack 2–8 source TOPs and composite them bottom-up, each layer with its own blend mode (over/add/multiply/screen/difference/lighten/darken) and opacity. Each layer is a Select TOP (or a built-in test source when omitted) → a Level TOP carrying opacity; layers above the base each get their own 2-input Composite TOP so blend modes are per-layer. Exposes a live control strip — per layer: Opacity (0–1), Blend (menu), Mute, Solo — and ends on a Null ready for post-processing or setup_output. Pass layers (bottom-first) for an explicit stack, or omit it to build count empty test layers. Returns a summary plus a JSON block with the container path, per-layer node paths, the output Null, exposed controls, node errors, warnings, and an inline preview image.

Create a Leap Motion hand/gesture scaffold with CHOP/TOP placeholders, hand maps, gesture maps, and setup notes.

Build a pixel-mapping chain from a source TOP to an LED fixture grid and DMX Out CHOP over Art-Net or sACN. The generated network resizes to width×height, samples one texel per fixture pixel, preserves RGB channels, and returns created node paths, channel count, warnings, and live Brightness/Universe controls on the parent COMP. It defaults to a moving Ramp test source so the chain can cook without input; real network output still requires a reachable fixture/node and should be verified before sending. Use create_dmx_fixture_pipeline for fixture patching and this tool when you specifically need image-to-pixel mapping.

Build a self-contained source COMP that ingests an external feed — screen grab, NDI, Syphon/Spout, camera, or a video stream (RTSP/SRT/WebRTC) — normalizes it to a target resolution, and exposes a named Null TOP output ready for the mixer, decks, or post-fx chain. The default 'screen_grab' is zero-permission and safe to test anywhere. 'camera' (Video Device In) is opt-in: it can hang TouchDesigner on a macOS permission modal until the user clicks Allow. NDI, Syphon/Spout, and video_stream are platform- and license-gated (NDI requires the NDI Runtime; Syphon is macOS-only, Spout is Windows-only). Par names for the source/sender/URL are probed defensively so a name that differs between TD builds becomes a warning rather than a hard failure.

Create a Livox LiDAR adapter scaffold with UDP/WebSocket/file-replay ingest, point-stream schema, zone maps, and calibration notes.

Stand up a prompt → response LLM chain inside TouchDesigner as a self-contained baseCOMP. Two modes: webclient — stock chain using webclientDAT + textDATs + headers tableDAT that POSTs JSON to any OpenAI-compatible endpoint (OpenAI, Anthropic, Ollama, llama.cpp, LM Studio, OpenRouter). tox_drop — drops the dotsimulate LLM LOPs .tox and wires mirror DATs. Default provider=ollama (fully offline, no key). API keys are read from env inside TouchDesigner (os.environ) and written into a headers tableDAT — the MCP server never sees them. Returns container_path, prompt_dat_path, response_dat_path, status_chan (:busy), provider, model, endpoint_url, and missing_env when a key is needed but unset. Notes: webclientDAT uses reqmethod/url/includeheader (verified live TD 099); body content goes via body_builder textDAT + callbacks. Anthropic uses x-api-key header + anthropic-version, not Authorization; Ollama requires ollama serve running on 127.0.0.1:11434; dotsimulate TOX par names are UNVERIFIED.

A playable snapshot row: store N named 'looks' (snapshots of a control COMP's numeric/toggle/menu parameters) in a visible, editable Table DAT, with one momentary recall button per slot (snap or crossfade) plus a master A↔B morph knob that blends continuously between two chosen looks. Reuses manage_cue's morph engine (so a recall behaves exactly like a cue morph, with optional beat/bar quantize) and mirrors slots into the COMP's cues so they interoperate with manage_cue / create_control_surface. Pulses and strings are always skipped at capture. Build cues/params with create_control_panel first.

Create an LTC receive/generate scaffold with LTC In/Out CHOP placeholders, cue maps, and routing notes.

Add one macro knob (a 0–1 custom parameter) to a COMP that drives many parameters at once, each remapped into its own [min,max] range with an optional response curve — a one-to-many control for sweeping a whole look from a single fader. Targets are bound by expression so they track the macro live.

Point at a folder on the TouchDesigner machine and build a clip BIN inside a new bin COMP: it scans the folder (filtered to the given extensions, capped at max_clips), creates one Movie File In TOP per file, feeds them through a Switch TOP, and ends on a Null TOP. Exposes Index (current clip), Next / Prev (pulse, wrapping), and Crossfade (seconds) controls — switching clips crossfades by ramping the Switch's fractional index (0s = hard cut). The folder is read inside TD (not the MCP server). If the folder is empty or missing you get an empty, pointable bin instead of an error. Use create_video_player for a hand-listed playlist; use create_media_bin to ingest a whole folder for clip-based VJing.

Map a source TOP onto a curved or irregular surface via a deformable textured grid — the curved-surface upgrade to create_projection_mapping's flat corner-pin, for domes, columns, and sculptures. Builds a Geometry COMP holding a grid that is bent into a dome (bulge), ripples (wave), half-cylinder (cylinder), or left flat, textured with the source through a Constant MAT, and rendered through an orthographic Camera + Light + Render TOP. Creates a new baseCOMP under parent_path holding all of these; output is a Null ready for setup_output; exposes a Zoom knob. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

HARDWARE-GATED SCAFFOLD. Build a MIDI controller preset for a supported device (apc_mini / launchpad / midi_mix / nanokontrol / generic): creates a midiinCHOP + a labeled bind Table DAT, and optionally auto-binds faders/knobs to a target COMP's numeric custom parameters. Explicit bindings can override or supplement the preset. CC/note numbers are best-effort from published MIDI charts and MUST be validated with real hardware — actual assignments depend on device firmware. This tool is HELD FROM RELEASE until hardware validation is complete. For one-at-a-time MIDI learn of a single control, use learn_control instead.

Build a MIDI note → per-note trigger/velocity chain that exposes bindable channels on a Null CHOP (note0…noteN-1). Unlike learn_control (which binds one CC), this creates a full note-event chain: midiinCHOP → eventCHOP (ADSR envelopes per note) → Null CHOP. Bind any parameter to op('…/notes_out')['note0'] and it pulses with each keypress. source='synthetic' (default) previews without hardware by generating a procedural note pattern — switch to source='device' when a MIDI keyboard is connected. The device path is HARDWARE-GATED (HELD FROM RELEASE until validated with real MIDI gear).

Create a generic OptiTrack/Rokoko/Axis Studio/VRPN-style mocap bus scaffold with joint and rigid-body mapping surfaces.

Build a bank of N BPM-synced LFOs in one self-contained container — each an oscillator (sine/triangle/saw/square or a random sample-&-hold) with its own rate-in-beats, output range and phase offset. Every rate locks to a tempo source (a create_tempo_sync Null, or TouchDesigner's global tempo) by expression, so the whole bank speeds up/slows down with the music and stays phase-continuous across tempo changes. All outputs land on one Null CHOP (mod_out) with one named channel per modulator, ready for bind_to_channel — the 'everything breathes' lever. Note: modulators are timeline-driven, so they only move while the timeline is playing. Re-running with an existing container name rebuilds it in place (clearing that container's children), so this tool is marked destructive and hidden from the safe profile.

Create a Monitors DAT inventory scaffold with monitor maps, GPU maps, preflight checks, and setup notes.

Build a video-analysis chain that exposes ready-to-bind reactive channels — overall brightness plus frame-to-frame motion energy — on a Null CHOP. The camera counterpart to extract_audio_features: bind any parameter to op('…/motion_reactive/features')['motion'] and it responds to movement in front of the camera, or ['brightness'] to ambient light. A Sensitivity knob scales both. Creates a new baseCOMP under parent_path holding the source, a downsized monochrome analysis chain, and a 'features' Null CHOP output. Source can be the live camera (may prompt for macOS permission), a movie file, an animated synthetic pattern (for testing without a camera), or an existing TOP. Optical flow is unavailable on macOS, so direction isn't exposed. Returns a summary plus a JSON block with the container path, created node paths, the features Null path, the channel names, exposed controls, any node errors, and warnings (no preview image — the output is a CHOP, not a TOP).

Create an MPCDI projection-calibration scaffold with MPCDI TOP/DAT, projector maps, region maps, and setup notes.

Fan a master TOP across N projectors/displays: each output is a cropped slice (horizontal or vertical) resized to full projector resolution and ended on a Null, ready for setup_output. Set overlap for edge-blending — tiles widen into their neighbours and a GLSL feather fades the shared seams so physically-overlapping projectors blend smoothly. Creates a new baseCOMP under parent_path holding the Select TOP, per-tile Crop (+ optional GLSL feather) and Null outputs, and optional Window COMPs. With as_windows, each tile also gets a borderless Window COMP offset across the desktop so it lands on its own display (left closed — open in Perform mode). Use setup_output instead for a single-window output; create_dome_output/create_cubemap_dome for curved/fulldome instead of flat tiling. Returns a summary plus a JSON block with the container path, created node paths, the first output path, the full list of output and window paths, and any node errors/warnings, with an inline preview image of the first tile.

Create a Windows Multi Touch In DAT scaffold with panel maps, touch-slot maps, and platform notes.

Create an NCAM camera-tracking scaffold with pose, lens, video-preview, and calibration maps.

Create a stable NDI source/output routing matrix scaffold without claiming live NDI discovery.

Create multiple nodes and (optionally) connect them in sequence. Returns all created paths; on failure it stops and reports partial progress without deleting anything.

Apply a non-photorealistic painterly filter to an existing TOP. A generalized Kuwahara (sector-based local variance smoothing) runs in a single GLSL TOP and branches into three looks selected by mode: oil (flat color regions, preserved edges), pencil (graphite sketch via luminance × edge magnitude), or watercolor (quantized chroma + low-frequency bleed). Creates a Select TOP → GLSL TOP → Null TOP chain under parent_path and exposes Radius / Smoothness / Strength as custom parent params bound by expression for live tweaking. Returns the GLSL TOP path, the bind-ready output null path, the fragment DAT path, exposed controls, and an glsl_compile_verified flag (always false offline — verify post-cook with get_td_node_errors).

Create a TouchDesigner scaffold for Nuitrack skeleton data over OSC, WebSocket, TCP JSON, or sample mode. Produces a stable body_bus CHOP contract and setup notes; live SDK/device calibration must be validated separately.

Create an OpenXR/SteamVR controller input scaffold for pose, trigger, grip, thumbstick, and button streams supplied by an external adapter.

Build a CPU motion-energy field from a video source (cheap drop-in for displacement / particle chains; NOT a real dense optical-flow solver). Output is a single-channel TOP: bright = motion, mid-grey = still, computed as gain × (current − previous luminance) + 0.5. In direction_from='edges' mode the result is multiplied by a Sobel edge map for a coarse where-is-motion-relative-to-edges estimate — still not a true dx/dy gradient flow. No CUDA, no external models — built entirely from stock TD TOPs: blurTOP (pre-blur), monochromeTOP, cacheTOP (previous-frame delay), compositeTOP subtract (frame diff), optional edgeTOP cross-multiply, mathTOP (sensitivity gain + 0.5 recenter), feedbackTOP+levelTOP (temporal smoothing). Defaults to TD's bundled Mosaic.mp4 test clip so the chain builds and previews standalone without a live camera (avoids macOS permission modal). Output is a nullTOP. Reads 0 when TD timeline is paused and the source is static — that is correct behavior. Returns a summary plus JSON with node paths, controls, warnings, and an inline preview image.

Create an OptiTrack/NatNet tracking scaffold with receiver, rigid-body maps, marker maps, and calibration notes.

Create an Orbbec/Kinect-compatible depth silhouette scaffold with synthetic/file fallbacks, stable silhouette_out and depth_preview TOPs, and explicit hardware/SDK validation warnings.

Create an Ouster LiDAR scaffold with Ouster TOP, range selection, zone maps, and calibration notes.

Generate a reusable colour palette + gradient other tools can bind to. In 'harmony' mode it computes N swatches from a base hue and a colour-theory rule (complementary / analogous / triad / tetrad / monochrome); in 'from_source' mode it samples dominant colours from a source TOP. It builds a Ramp TOP gradient (key colours from a docked Table DAT) plus a Constant CHOP exposing each swatch as swatch{i}r/g/b channels — feed those into create_color_grade, generate_from_moodboard or bind_to_channel. Live BaseHue / Saturation / Value / Rule / Count controls are exposed on the parent. Builds standalone (a harmony palette needs no source).

Build a live-performance safety control — the 'oh no' button every VJ needs. Wraps a source in a small COMP with two instant kill switches: Blackout forces the output to black (a Level TOP's brightness1 driven to 0) and Freeze holds the last frame (a Cache TOP stops capturing, active → 0). With an input_path the source is pulled in by a Select TOP (so it can live in another container); without one a built-in Ramp TOP test source is used so it builds and previews standalone. Output is a Null TOP. Big Blackout / Freeze toggle buttons are exposed on the container so a performer can hit them instantly. Marked destructive because firing Blackout/Freeze disables the live output. Returns the container, the source/freeze/blackout/output node paths, and the initial toggle states.

Build a boids-style GPU particle flock: position and velocity are simulated entirely on the GPU in two RGBA32float feedback-TOP loops, where the velocity shader implements the three classic boids rules — separation, alignment, cohesion — by scanning a stencil of neighbouring texels in the agent texture (each texel is one agent), then renormalising toward a cruise speed. Positions drive TOP-instancing of a tiny dot once per agent. Creates a new baseCOMP under parent_path holding the velocity/position feedback loops, the instanced Geometry COMP, Camera, Light, and Render TOP ending in a Null output. The behavioural complement to create_gpu_particle_field (use that instead for curl-noise/gravity drift rather than flocking); also pick a sibling for other motion: image_to_particles to spring particles onto the pixels of an image/video, create_pop_particle_system for TouchDesigner's native POP particle network, create_particle_system for a simple CPU emitter. Exposes live Separation / Alignment / Cohesion / Speed knobs. Note: the flock only evolves while the TD timeline plays. Returns a summary plus a JSON block with the container path, created node paths, the agent count, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Build a CPU particle system: an emitter SOP feeds a Particle SOP inside a Geometry COMP, rendered with a camera + light. Creates a new baseCOMP under parent_path holding the Geometry COMP (emitter + particle SOP), a material, Camera, Light, Render TOP, and a Null output. Forces and render style are scaffolded for further tuning. Exposes live Drag / Turbulence / Gravity / Lifetime knobs. This is the simplest CPU emitter, born from a real SOP shape; pick a sibling instead when you need scale or specific motion: create_gpu_particle_field for much higher counts (GPU-simulated noise/curl/gravity drift, up to ~262k), create_particle_flock for boids/flocking behaviour, image_to_particles to reconstruct an image/video as points, create_pop_particle_system for TouchDesigner's native POP particle network. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings (e.g. approximated forces or fallback render styles), and an inline preview image.

Build a physically-based 3D scene: a Geometry COMP holding the chosen primitive (sphere/torus/box) shaded by a PBR MAT (base colour, metallic, roughness), lit by an Environment Light for image-based lighting (fed a Constant TOP of env_color so it works with no HDRI file) plus a key Light, framed by a Camera and rendered to a Null. Creates a new baseCOMP under parent_path holding the Environment Light + envmap Constant TOP, the PBR MAT, a Geometry COMP, a key Light, a Camera, a Render TOP, and a Null output. Use create_3d_scene instead for basic (non-PBR) shading or GPU instancing. Exposes Metallic, Roughness, BaseColor and Spin controls; set rotate to turn the object so its reflections move. Returns a summary plus a JSON block with the container path, created node paths, the material/lights/geometry/camera/render/output paths, exposed controls, any node errors, warnings, and an inline preview image.

Stream a phone's IMU (tilt + gyro + shake) and multitouch into TouchDesigner as CHOP channels you can bind to anything. Builds a Web Server DAT page the phone opens (any browser, no app) and a Null CHOP exposing tilt_x/y/z, gyro_x/y/z, shake, touch0..3_x/y/active, clients. Composable with create_phone_remote on the same COMP (different port). SECURITY: listens on all interfaces with no auth — trusted networks only. iOS Safari needs HTTPS for motion permission; falls back to touch-only on plain HTTP.

Serve a mobile-friendly web panel from a Web Server DAT so you can control a COMP's numeric custom parameters from a phone — just open the URL, no app to install. Each parameter becomes a touch slider that writes back live. SECURITY: like the bridge, this listens on all interfaces and accepts writes with no auth, so use it only on a trusted network. Pair with create_control_panel (the params to expose) and manage_cue (snapshot looks you dial in from the phone).

Build a DJ/VJ phrase-quantized cue-lock engine. Any incoming pulse CHOP (Button, MIDI In, OSC In, composeCueList trigger) is queued FIFO and fired on the next 1/2/4/8/16/32/64-bar phrase boundary derived from the global project tempo. Live controls: Active (on/off gate), PhraseLength (live retune), Flush (clear queue), QueueDepth (display). Mode 'next' fires on the first upcoming boundary; 'aligned' locks to the project-start phrase grid. Pairs with create_tempo_sync upstream and bind_to_channel / manage_cue downstream. Output is a 0/1 trigger Null CHOP at /out.

Build a glitch-art pixel-sort effect that sorts pixels along rows or columns within luminance-thresholded regions, creating the signature Kim Asendorf–style horizontal/vertical streak aesthetic. Uses a multi-pass odd-even transposition sort over a glslTOP feedback chain. Sort key: luminance, hue, or saturation. Exposes Mix, Threshold, Iterations, Direction, and Reset for live tweaking. Defaults to a self-contained noiseTOP source when no input TOP is provided.

Render a point cloud from a depth/luminance map (or a synthetic source): scatter a resolution×resolution grid of points and push each point's XYZ from the texture — X/Y from its grid position, Z from the map's brightness × depth_scale. Unlike create_depth_displacement (a continuous shaded mesh), this is a cloud of discrete dots. A GLSL TOP packs each point's position into one RGBA32float buffer, then a Geometry COMP TOP-instances a tiny sphere once per texel (reaching resolution², up to 512²≈262k points). Creates a new baseCOMP under parent_path holding the source, a monochrome heightmap, a GLSL position-pack buffer, the instanced Geometry COMP, Camera, Light, and Render TOP ending in a Null output. Source can be an animated synthetic pattern (testable without any device, the default), a movie file, the live camera (may prompt for macOS permission), or an existing TOP (e.g. a real depth map). Use create_depth_displacement instead for a continuous shaded mesh rather than discrete dots. Exposes DepthScale, PointSize, and Spin knobs — bind DepthScale to a tempo ramp or an audio feature to make the cloud heave. Returns a summary plus a JSON block with the container path, created node paths, the effective and requested source, the point count, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Turn mouse/pointer position and click into a first-class creative seed. Builds a Mouse In CHOP → normalized u/v (0..1) + velocity (vu/vv) + button, exposed on a 'pointer' Null CHOP ready for binding: op('…/pointer_reactive/pointer')['u'] / ['v'] / ['button'] / ['vu'] / ['vv']. A Sensitivity knob gains every channel. By default also builds a small visible demo — a bright dot that follows the pointer and leaves a decaying trail over a feedback field — so you immediately see it working; set demo=false to build only the CHOP chain (no image, no preview). multitouch is reserved for a future Panel-COMP touch source; this build always uses Mouse In and reports the limitation as a warning when requested. Creates a new baseCOMP under parent_path. Returns a summary plus a JSON block with the container path, created node paths, the pointer Null path, channel names, exposed controls, any node errors, and warnings.

Build a GPU point field using TouchDesigner's POP (Point OPerator) family — a generator POP (chosen by pattern: 'noise' scatters count points and displaces them with a Noise POP for a moving cloud, 'grid' a flat lattice, 'sphere' a shell), a Transform POP that spins the whole field over time, then a render path (POP to SOP → Geometry COMP → Render TOP) output as a Null TOP. Creates a new baseCOMP under parent_path holding all of these and exposes PointSize and Spin knobs. NOTE: POPs are flagged Experimental in this TD build and the POP render path is uncertain, so this tool is built fail-forward and probe-first — the POP chain and render wiring are best-effort (failures become warnings) while the output Null is always created, and the result's extra.unverified lists every POP op type and the render path attempted so you can live-validate. Returns a summary plus a JSON block with the container path, created node paths, generator/transform/render/output paths, exposed controls, node errors, warnings, the unverified probe record, and an inline preview image.

Procedural Op Pattern (POP) geometry generator: build a SOP chain inside a Geometry COMP — primitive (box/sphere/tube/torus/grid/line/text) → Transform SOP (translate/rotate/scale) → optional Subdivide SOP → optional per-point Noise SOP displacement → Material SOP (Constant MAT) → Null SOP — then render through a Camera + Light + Render TOP to a Null TOP. Creates a new baseCOMP under parent_path. Exposes a RotateY control; NoiseAmount + NoisePeriod are exposed only when noise_amount > 0 (otherwise the Noise SOP is omitted and those knobs would be inert). Use build_sop_geometry for a fully declarative SOP chain without a render rig; use create_3d_scene for instanced primitives, create_pbr_scene for PBR shading.

Build a POP-native reaction-diffusion / growth system inside a fresh baseCOMP. Three mode presets: 'dendritic' (sparse fibrous tendrils, low decay), 'coral' (dense outward accretion, mid decay, strong force), 'lichen' (patchy crust, high threshold emission clusters). A particle_pop emits points gated by a noise threshold; a noise_pop drives a force_pop vector field that biases their motion; a feedback_pop loop carries point state forward one cook so accumulation simulates organic growth. Output is a Null TOP via poptoSOP → geometryCOMP → renderTOP. POP chain delegated to buildPopChainScript. POPs are Experimental — par writes are fail-forward; result reports unverified op/par set. Warns when feedback_gain × (1 − decay) ≥ 1.0 (divergence risk).

Plexus-style line-web visual built on the POP family. A POP point cloud (auto-generated or sourced) is fed to a Neighbor POP that fills a per-point Nebr array attribute with closest-neighbor indices. A Script SOP converts that index list into deduplicated line primitives, rendered as a Geometry COMP through a Render TOP to a Null TOP — the classic Plexus look without third-party plugins. auto_pattern: 'noise' (default) = pointgeneratorPOP + noisePOP; 'sphere' = spherePOP; 'grid' = gridPOP. count is hard-capped at 8192 (CPU O(N·k) line emission). color_mode: flat | by_distance (warm→cool gradient) | by_neighbor_count (isolation ramp). Exposes live controls: MaxDistance, MaxNeighbors, Spin, PointSize, LineAlpha. POPs are Experimental — par names and Nebr array-attribute survival through poptoSOP are probe-first unverified; result carries extra.unverified.

Build a complete POP particle simulation (particle_pop → feedback_pop → lookup_texture_pop → field_pop → null_pop) inside a new baseCOMP, wire a render rig (poptoSOP → geometryCOMP → renderTOP → nullTOP), and expose EmissionRate, Lifetime, FeedbackGain, and ForceTexture live controls. When force_texture_path is omitted, a noiseTOP is created inside the container as the default force source so the chain always cooks. Supports three output modes: 'particles' (particle render), 'field' (field_pop visualization), and 'composite' (compositeTOP add of both). POP chain creation is delegated to build_pop_chain (Layer 2); this tool adds only the render rig and control exposure. This is the only particle tool built on TouchDesigner's native POP operators (force-texture driven, with field/composite output modes); pick a sibling instead for non-POP paths: create_gpu_particle_field for a GPU noise/curl/gravity drift field, create_particle_flock for GPU boids/flocking, image_to_particles to reconstruct an image/video as points, create_particle_system for a simple CPU emitter. NOTE: POPs are Experimental — the result carries an unverified marker; live-validate.

Render a canonical OpenPose-colored stick figure TOP (per-limb RGB lines + per-joint colored discs on a black background, default 512×512) from an existing pose CHOP produced by create_pose_tracking. The render is GPU-rasterized in a single GLSL TOP that samples the pose CHOP via a CHOP-to-TOP. Optionally auto-wires the output to a Syphon/Spout or NDI sender for a downstream Stable Diffusion / ComfyUI / StreamDiffusion ControlNet node. No model inference — this tool produces the driver conditioning image that ControlNet consumes.

Body-pose binder parallel to bind_audio_reactive: take the 33-sample MediaPipe pose CHOP produced by setup_body_tracking and derive scalar reactive channels (right-hand height, arms openness, elbow angle, hand velocity, …) on a Null CHOP ready for bind_to_channel. Each channel is a Select→Math→Hold→Filter→Limit→Rename chain inside a fresh baseCOMP, all merged into one null_out. Supported metrics: y/x/z (1 landmark), distance/openness (2 landmarks), angle (3 — vertex middle), velocity (1, time-derivative). Optional bindings[] writes expression-mode binds directly onto target parameters (same shape as bind_to_channel; failures collected as warnings, not throws). Exposes a Reactive custom page with Smoothing/Intensity/Bypass/Gate_ knobs. Heads-up: MediaPipe's landmarks are 2D (z near-zero) — z/distance/angle/velocity are unreliable unless the adapter exposes worldLandmarks; the tool emits a warning when it detects a constant tz. Run setup_body_tracking first.

Render a live stick-figure skeleton from full-body pose tracking — the classic MediaPipe body-tracking look: glowing lines connecting the 33 landmarks (shoulders, elbows, wrists, hips, knees, ankles) drawn by a Line MAT and rendered to a Null TOP you can composite or post-process. Source defaults to a SYNTHETIC animated pose so it builds and previews instantly with no camera and no plugin; switch to 'mediapipe' (the free torinmb plugin), 'osc', or an existing pose CHOP (e.g. from create_pose_tracking) for the real performer. Creates a new baseCOMP under parent_path holding the pose source, a Geometry COMP (a Script SOP that rebuilds points + bones each cook), a Line MAT, a Camera, a Render TOP, and a Null output. Use create_body_reactive instead for glowing dots/trails at the landmarks rather than a connected stick figure. Exposes LineColor / LineWidth / CamDistance. Returns a summary plus a JSON block with the container path, created node paths, the skeleton SOP and output paths, the bone count, exposed controls, any node errors, warnings, and an inline preview image.

Set up full-body pose tracking — the foundation for body-reactive visuals (the camera/skeleton counterpart to extract_audio_features). Produces a canonical pose CHOP (33 MediaPipe landmarks as samples, channels tx/ty/tz/confidence) plus a 'keypoints' CHOP of ready-to-bind scalar channels (r_wrist_y, l_wrist_x, hips_x, hand_span, height, …). Source defaults to a self-contained SYNTHETIC animated pose so it builds and previews with no camera and no plugin; switch to 'mediapipe' (the free torinmb/mediapipe-touchdesigner plugin), 'osc', or an existing pose CHOP for the real performer. Smoothing and Mirror included. Feed the output into create_pose_skeleton or create_body_reactive.

Target-agnostic preset morph engine: snapshot any OP's animatable parameters into N named slots, then blend between them with a weight vector (or a single A↔B recall) through a Lag CHOP + Lookup curve, exposing the live blended values on a Null CHOP for bind_to_channel consumers. Unlike create_look_bank (which is scoped to a control COMP's custom pars with a 2-slot A↔B knob), this drives any OP and supports >2 simultaneous weights (normalized internally). Reuses manage_cue's MORPH_HOOK for beat/bar quantized recall. Note: Lag CHOP does not advance while the timeline is paused.

Build a Markov-chain step sequencer. On each beat boundary the COMP transitions from the current state to a next state sampled from the per-state weighted-transition table. Outputs two CHOP channels: 'state' (current state index) and 'trigger' (pulse on state change). Generative sibling of create_euclidean_sequencer and create_beat_grid_sequencer — great for evolving, probabilistic rhythms and generative state machines. NOTE: beat-callback timing requires a live TD session with time.play=1.

Wrap a source TOP in a Corner Pin warp for projection mapping: drag the four corner handles to line the image up with a physical surface (wall, object, screen). The source comes in through a Select TOP so it can live anywhere; output is a Null ready for setup_output. The corner positions are parameters, so you can also drive or save them.

Create one DAT under parent_path preloaded with your Python code. dat_type chooses a Text DAT (plain code), an Execute DAT (event hooks like onFrameStart), or a Script DAT (table builder); for a Script DAT the code is written to its auto-created companion callbacks DAT, since the Script DAT's own text is read-only. Returns the created DAT's path. This only stores code as a node; use execute_python_script instead to run Python immediately against the live project.

Instantiate a self-contained GLSL TOP raymarcher (volumetric / signed-distance-field) — the 3D complement to create_shader_lib. Scenes: sphere_field (repeated spheres), menger (Menger-sponge fractal), tunnel (twisting tunnel). Exposes live CameraZ / Speed / StepCount / Intensity / ColorA / ColorB controls and previews the output TOP.

Copy a RayTK ROP master (SDF / camera / light / combine / material / render) into a network and optionally wire an existing op into one of its typed inputs, using the same COMP.copy primitive RayTK's own palette uses. Resolves the install-dependent master path live (RayTK's pathsByOpType lookup, or a category-folder search) — never hardcoded — so it requires the RayTK toolkit staged + loaded first (see manage_packages / the tdmcp://raytk/operators catalog). Complementary to the GLSL create_raymarch_scene: this instances RayTK's own operators instead of authoring a shader.

Build the minimal renderable RayTK node graph (sphereSdf → raymarchRender3D → Null TOP) from RayTK's real ROP COMP masters, copied at runtime — the node-graph-native complement to create_raymarch_scene (which stays the lightweight, no-dependency GLSL path). Optional flags union a second SDF, insert an inline basicMat, and add an explicit lookAtCamera / pointLight. Requires the RayTK toolkit staged + loaded (manage_packages install raytk, then load the .tox); RayTK 0.46 requires TouchDesigner 2025.30770+. Fails forward with 'stage & load RayTK first' guidance when the library is absent.

Build a RayTK SDF graph from copied RayTK ROP masters: primary SDF, optional secondary SDF through simpleUnion, optional basicMat, lookAtCamera, pointLight, raymarchRender3D, and a native Null TOP output. Requires RayTK to be staged with manage_packages install raytk and loaded from the staged .tox.

Build a Gray-Scott reaction-diffusion GPU simulation as a ready-to-use visual system. Delegates to the built-in 'reaction_diffusion' recipe (seed GLSL TOP → feedbackTOP → simulation GLSL TOP → null output), then overlays caller-provided Gray-Scott parameters (Feed rate F, Kill rate K, diffusion coefficients Da/Db) as GLSL uniforms, patches the shader so da/db use the uniforms instead of hard-coded constants, and optionally chains a rampTOP + lookupTOP for a color LUT (coral / spots / stripes / mitosis presets). Exposes a control panel with sliders for F, K, Da, Db, resolution, and a palette menu. Output node is a nullTOP ready for downstream wiring. 'iterations>1' is unverified — effective value is 1 with a warning.

Create an Intel RealSense depth-camera scaffold with RealSense TOP, NDI, WebSocket adapter, or sample-source modes plus depth/color/point-cloud routing notes.

Wire a Replicator COMP that clones a template COMP once per row of a Table DAT — TouchDesigner's idiomatic 'N copies from data' mechanism (menus, scoreboards, per-track decks, instanced panels). Resolves or creates the template COMP (omit template_path → a minimal container with a Text) and the driving Table DAT (omit table_path → a small example table; rows sets how many demo rows), creates the replicator under parent_path, points its driving-table and master parameters at them, sets the replication method to 'by table', and optionally drops an onReplicate callback DAT stub for per-clone setup. The Replicator's parameter names vary by TD build, so each is set probe-first and the report includes which parameter took plus the live parameter list. Then it pulses a re-replicate so the clones appear. Re-replicating is destructive to previously generated clones, which the replicator deletes and re-creates on cook.

Build a live-show safety primitive at the very end of the master output chain: deterministic fade-to-black over a configurable time, optional emergency single-frame hard-cut, optional hotkey + external watchdog trigger, and symmetric fade-in recovery. All reactivity is parameter-driven (Speed + Lookup CHOP + Math/Logic CHOPs) — no Python runs at cook time, so the chain is ALLOW_EXEC=0-safe. Complements create_panic (per-source kill+freeze) by being the master-output dimmer with grace, recovery, and a watchdog hook. Returns the container, source, dim, emergency-gate, composite, and output node paths plus the trigger merge/target/speed/lookup nodes.

Build a TouchDesigner bridge surface for an external SAM2/FastSAM segmentation service. Creates source input, mask receiver, mask_out, matte_out, preview_out, and clear notes that no model is bundled.

Create a Scalable Display TOP scaffold with display tile maps, status, and calibration setup notes.

Build a scrubbable show timeline: a single Timer-CHOP playhead drives ordered scenes that recall cues on a target COMP. Sits above create_cue_sequencer (beat-quantized) and create_scheduler (event-firing) as the show's master clock. Exposes Play/Pause/Stop/Seek/Rate/Loop/Active_Scene custom pars + a playhead Null CHOP (t_seconds, t_norm, scene_idx, scene_t). Consumes the foundation setlist schema: when setlist_path is given, each scene's setlist_slot is mirrored into tdmcp_scenes for downstream tools. Bars→seconds conversion uses BPM 120 + 4 beats-per-bar at build time (no auto-rescale on tempo change).

Build a Timer-CHOP scheduler COMP: one or more named timers (seconds or beats), each with an optional ordered segment list, sharing a Callbacks DAT that fires a cue/param/script action on onDone and onSegmentEnter. Atomic timer primitive that create_scene_timeline and other automation rides on. Reuses manage_cue's tdmcp_cues storage for the default 'cue' action - store target cues first with manage_cue.

Build a programmable signed-distance-field (SDF) raymarcher in TouchDesigner as a self-contained GLSL TOP. Compose a CSG tree of sphere / box / torus primitives with union / intersect / subtract boolean ops and optional smooth blending. Exposes live CameraZ / Speed / StepCount / Intensity / Rotate / ColorA / ColorB / Background controls and previews the output.

Raymarch a text string as a signed-distance-field 3D slab: a Text TOP renders the glyphs to a mask, and a GLSL TOP treats that mask as an extruded distance field (glyph coverage in XY, closed by two Z planes at ±depth/2) so the letters read as solid, lit, rim-highlit 3D volumes that can spin. Distinct from create_sdf_field (primitive CSG only, no text) and create_text_3d (mesh-extruded text SOP) — this is the raymarched distance-field text look. The mask→SDF is approximate (coverage-derived, no external font SDF atlas required) and eased by smoothing. Creates a new baseCOMP under parent_path. Exposes CameraZ/Speed/StepCount/Intensity/Rotate/Fill/Edge/Background controls and previews the output. Returns a summary plus a JSON block with node paths, exposed controls, node errors, warnings, and an inline preview image.

Layer-1 wall-clock setlist player for rehearsed VJ shows. Pass rows[] of (source TOP, duration_seconds, transition_seconds) and the tool builds a baseCOMP containing N Select TOPs (one per row), a Switch TOP, a Cross TOP for crossfaded boundaries (hard cut when transition_seconds=0), an optional NOW/NEXT/remaining Text TOP HUD composited over the program, a Timer CHOP + CHOP Execute engine that auto-advances rows on wall-clock time, and live custom params Play/Row/Skip/Prev/Loop/Defaulttransition for stage overrides. Output is a Null TOP at <parent>/<name>/out. Fills the gap between create_clip_launcher (manual grid) and create_cue_sequencer (musical bars).

Build a hands-light stage navigator (the QLab model) for stepping through an ordered scene/cue list: Next / Prev to move the pointer, Go to fire the current scene's cue on the target COMP, and an Index knob to jump directly. Optionally quantizes GO to the next beat. The navigator drives manage_cue recall on the target so cue morphs and beat-quantized changes all work. Use after building a control panel with manage_cue cues stored; then perform the show by hitting Next + Go instead of recalling by name.

Instantiate a curated, ready-to-run full-screen GLSL shader (tunnel, raymarch_sphere, fractal, metaballs, plasma) into a GLSL TOP with live Speed / Scale / Color controls. High-value VJ eye-candy; unlike create_glsl_shader it ships robust built-in shaders rather than taking arbitrary code.

Compile Shader Park JavaScript sculpture code with shader-park-core and instantiate it as a self-contained TouchDesigner GLSL MAT scene with live controls. Caller source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. Use the companion shader-park:tox script when you specifically want the official Shader Park .tox plugin workflow.

Create a Shared Memory In/Out TOP/CHOP for zero-copy IPC with another app on the same host (Notch, Unity, Unreal, custom tools). Pick direction ('in' to receive, 'out' to publish), kind (TOP for pixel buffers, CHOP for numeric channels), and a shmName that the peer must match exactly. After creating an Out variant, wire the producer TOP/CHOP into it with connect_nodes. When format.header=false the peer reads a raw headerless buffer — sizes must agree exactly or frames will garble. Some (direction, kind) combos are platform/build-dependent; the tool returns a friendly fatal if the optype isn't available.

Build a live-show watchdog: a Switch TOP (blend=1 cross-dissolve) between a primary source TOP (NDI/camera/Spout/Syphon path, or a synthetic noiseTOP when none is given) and an MP4 fallback (or a constantTOP when no file is given), driven by an Info CHOP + watchdog CHOP-Execute DAT that trips on cook stall (total_cooks delta stays flat for stall_ms) and, optionally, primary cook errors. A Filter CHOP smooths the integer Switch index into a fade_ms crossfade. Sticky-recover auto-returns to primary after recover_ms healthy; otherwise stays on fallback until Reset. Exposes Active / Stall_Ms / Fade_Ms / Sticky_Recover / Reset / Force_Fallback controls and a Null CHOP of status channels for bind_to_channel. Returns the container, output TOP, status CHOP, control names, and the operator paths.

EXPERIMENTAL — One-call 'pump the whole rig on the kick': build a sidechain ducking envelope from a trigger CHOP channel and bind multiple target parameters to dip on every hit. Distinct from create_envelope_follower (which builds the chain + optional gate/duck mode with a threshold); this tool is the ergonomic multi-target pump with a single depth knob and a rest_value anchor — ideal for classic pumping compressor feel across many targets at once. Builds a container with: a Select CHOP isolating the source channel by absolute path (no cross-container wires), a Lag CHOP shaping attack/release, a Limit CHOP clamping to [0,1] (type=clamp/min/max, live-validated on TD 099 — guarded with warnings), and a Null CHOP 'pump' as the stable output handle. Each target gets the expression: rest_value * (1 - depth * op('')[chan0]). Per-target failures become warnings; fatal only if source_chop or parent COMP is missing.

Build a GPU simulation: 'reaction_diffusion' grows Gray-Scott patterns (via the validated recipe), while 'slime' and 'fluid' run a feedback loop displaced by an evolving noise flow field — drifting trails and advected smears. Exposes a Decay knob (trail persistence). For more procedural techniques (cellular automata, flow fields, strange attractors) see create_generative_art.

Build a slit-scan visual system: each row (or column) of the output samples a different past frame from a Cache TOP ring buffer, producing the classic 'time-as-space' stretched-time look (Floris Kaayk / Adam Magyar style). Creates a new baseCOMP under parent_path holding a source TOP, a Cache TOP ring buffer, a slit GLSL shader, and a Null output. When no source_top_path is given, a synthetic Noise TOP is used so the tool works headless / on CI without camera permission. Exposes a live 'Depth' knob. Note: GLSL compile is UNVERIFIED offline; cacheTOP 2D-array binding must be validated live in TouchDesigner. Memory cost at 1080p RGBA16 is ~depth × 32 MB; depth 600 ≈ 5 GB VRAM. Output freezes when the timeline is paused (cacheTOP stops recording — expected behaviour). Returns a summary plus a JSON block with the container path, created node paths, output path, exposed controls, warnings, and an inline preview image.

Build an FFT audio-spectrum analyzer that exposes N separate, ready-to-bind frequency-bin channels (band0..band{N-1}) on a Null CHOP. This is the per-band complement to extract_audio_features (which only gives overall level + bass/mid/treble): bind a row of parameters to op('…/spectrum/spectrum')['band0'], ['band1'], … to drive a bank of bars, or pick one frequency. A Sensitivity knob scales every band. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic oscillator (for testing), or an existing CHOP. Use extract_audio_features when you want coarse level/bass/mid/treble bands instead of N fine bins, create_audio_reactive for a ready-made spectrum visual, and feed this Null into bind_audio_reactive to drive a COMP.

Serve one unified live-performance cockpit from a Web Server DAT — a single responsive web page (phone + laptop) that combines a grid of cue-launch buttons (recall named cues from manage_cue on the target COMP), master faders bound to chosen parameters, a big PANIC button (toggles the target COMP's Blackout/Freeze safety pars, the create_panic mechanism), and a live readout strip (a beat indicator plus a VU bar reading an audio-features Null CHOP). Open the URL — no app to install — and the page POSTs every control change back to the server, which applies it. SECURITY: like the bridge and create_phone_remote, this listens on all interfaces and accepts writes with NO auth, so use it only on a trusted network. Store cues with manage_cue, expose params with create_control_panel, and run create_panic first so the Blackout/Freeze toggles exist.

Tile a source TOP into a rows×cols brick/grid pattern with per-cell gap, position jitter, rotation jitter, and an optional brick/masonry half-tile row offset — all computed per-cell in a single GLSL TOP shader (stock TOPs only, no external files besides the optional source). Defaults to a built-in synthetic Noise TOP so the grid previews standalone on any install without a source (no external asset). Output is a nullTOP. Returns a summary plus JSON with node paths, live controls, warnings, and an inline preview image.

Density-weighted particle scatter rendered as discrete points — a stippled / halftone-engraving point cloud whose dot distribution follows the luminance of a source TOP. Brighter regions yield denser clusters. Three visual modes: bw_dots (constant colour stipple), colored_dots (sample source RGB at each point), random_jitter (adds noisePOP for organic hand-engraved scatter). Outputs a Render TOP through a Geometry COMP in points render mode. Sibling to create_pop_geometry (procedural SOP geo) and the rasterised create_dither / create_halftone tools (which stay in TOP space).

Build a strange-attractor deferred geometry generator: a Script CHOP integrates a chosen ODE system (Lorenz / Aizawa / Halvorsen) with configurable sub-steps and maintains a rolling ring buffer of trail_length points. A Script SOP converts the channels into one open polyline; an optional Tube SOP thickens it for shaded render inside a Geometry COMP + Camera + Light + Render TOP pipeline. Closing Roadmap Milestone 4. Complements create_growth_system (L-systems) and create_particle_flock (boids) as the deterministic CPU-geometry idiom. With TD timeline paused the integrator pauses too (time-dependent) — resume playback to continue. Returns a summary plus a JSON block with the container path, output path, exposed controls, errors, warnings, and an inline preview.

Build a beat-syncable strobe / flash layer — a full-frame colour flash that pulses hard on/off, the signature live-VJ strobe effect. A square-wave LFO CHOP at the given Rate (Hz) drives a Level TOP's brightness so a Constant TOP (the flash colour, white by default) blinks; Duty sets the on-time fraction. With an input_path the flash is composited OVER that source (pulled in by a Select TOP, so it can live in another container); without one, the bare flash is output. Output is a Null TOP. Rate is free-running for v1 — bind the LFO's frequency to a beat CHOP later to lock it to the tempo.

Build a named OSC-out preset map for driving Synesthesia or Unreal Engine from TouchDesigner. Picks a preset ('synesthesia' → prefix '/syn', port 6448; 'unreal' → prefix '/unreal', port 8000), builds a Constant CHOP with one named channel per control (channel name = '/' so an oscoutCHOP emits the exact address the target app expects), and wires it into an oscoutCHOP aimed at host:port. Override the control names, prefix, host, or port as needed. This is the preset layer on top of create_external_io osc_out — it fills in the address templates and default control set so the send 'just works' with the target app. Bind audio/analysis to the source channels (e.g. op('controls')['syn/Bass']) to make the receiving app react.

Create a single bare operator (node) inside a parent COMP with optional deterministic auto placement or exact coordinates and viewer state. Omitted placement preserves legacy bridge behavior; idempotently reused nodes keep their existing coordinates. Validates the operator type against the knowledge base and warns (without blocking) on unknown types. Returns {node, warnings[]} for the created node. For a complete wired+arranged network prefer a Layer-1 create_* tool.

Create a tempo clock (Beat CHOP driven by TouchDesigner's global tempo) exposing beat-synced channels on a Null CHOP: a per-beat 0→1 ramp, a pulse spike on each beat, integer beat/bar counters, and bpm. Bind any parameter to these to lock visuals to the beat. With emit_events on, it also broadcasts a beat event over the bridge WebSocket each beat, so tdmcp-agent watch and the AI can see the pulse live. Pair with extract_audio_features for full musical reactivity.

Build a procedural heightmap landscape: an animated Noise TOP height field displaces a subdivided Grid SOP along Z in a GLSL vertex-displacement MAT (real 2.5D geometry, elevation-shaded from a low→high colour ramp), lit by a key Light, framed by a raised angled Camera, and rendered. Optionally adds a flat translucent water plane at water_level and a camera-distance fog fade into the sky/background colour. Distinct from create_visual_system's 'terrain' keyword (which only maps to a noise_landscape recipe) — this is a dedicated, fully parameterized terrain pipeline with its own displacement material, water, and fog. Creates a new baseCOMP under parent_path. Exposes Height, Drift, WaterLevel, and Zoom controls. Returns a summary plus a JSON block with the container path, created node paths, output path, exposed controls, node errors, warnings, and an inline preview image.

Generate a projector calibration / alignment source — a standalone test-pattern network that every media server ships and tdmcp was missing. Builds a baseCOMP containing a GLSL TOP with a baked-in static pattern (grid, crosshair, SMPTE-ish color bars, horizontal ramp, or circle-grid), optional text/number overlay (for per-projector ID), and a Null TOP as the stable output handle. The shader is generated per pattern and baked into the payload — no custom uniforms or live bindings needed. Use the output as a routing source during projector alignment, LED mapping calibration, or camera registration. Pattern, resolution, divisions, overlay number/label, and colours are all configurable.

Build a self-contained 3D text scene: a Text SOP generates the glyph outlines, an Extrude SOP gives them depth (the depth parameter controls depthscale), and a Geometry COMP holds the pipeline with a Constant MAT for colour. A Camera, a Light, and a Render TOP complete the 3D render, output as a Null TOP. Optional continuous Y-axis spin (spin degrees/sec) is driven by a time expression on the Geometry COMP's ry parameter. Exposes Spin and Depth as live knobs. The classic signature look for title cards, lyric reveals, and 3D text drops — use create_kinetic_text instead for flat 2D animated text. Returns a summary plus a JSON block with the container path, created node paths, exposed controls, any node errors, warnings, and an inline preview image.

Build a multi-line animated text crawl / ticker / credits roll / typewriter reveal inside a self-contained baseCOMP. Three modes: 'crawl_horizontal' = continuous left-scrolling ticker tape (news-ticker style); 'roll_vertical' = upward credits roll (use \n to separate lines); 'typewriter' = text is revealed character-by-character from left to right (EXPERIMENTAL — the substring expression on a textTOP text par is unverified across TD builds). A textTOP renders the content; a transformTOP animates position via an EXPRESSION parameter (crawl/roll modes) or the textTOP text par is set to a time-sliced substring expression (typewriter mode). The scroll wraps continuously (loop=true, default) so the text re-enters from the opposite edge. Outputs a nullTOP 'out' as a stable handle. Differs from create_kinetic_text (single-string flash/pulse/slide) and create_text_overlay (a static, non-moving caption/title); this tool handles multi-line copy, continuous scrolling, and character-reveal. Returns a JSON block with container path, output_top, text_top, transform_top, mode, line count, and any per-step warnings.

Composite styled STATIC text over a visual (or on its own transparent background) — a Text TOP with font size, color, and alignment, optionally laid 'over' a source TOP through a Composite TOP, output as a Null. For lyrics, titles, song names, or credits in a set. Distinct from the vault's bind_vault_text (which data-syncs a Text DAT to a note); this is a finished visual layer ready for setup_output. The text does not move: for a single word that flashes/pulses/slides use create_kinetic_text, and for multi-line scrolling tickers/credits rolls/typewriter reveals use create_text_crawl.

EXPERIMENTAL — Apply a per-pixel time effect to a source TOP: echo trails, slit-scan, or per-pixel time displacement (the 'time machine' melt/slice look). Builds a container COMP that selects the source by absolute path (no cross-container wire) and then, by mode: echo — a feedbackTOP (wired input + forced resolution so the loop is not black) blended over the live frame at opacity=feedback to leave fading ghost trails; slit_scan — a cacheTOP buffering frames and a time-machine TOP reading different rows from different points in time; time_displace — the same cache read back through a luminance gradient (displace_top or a built-in vertical ramp) so bright pixels show older frames. The time-machine read operator is PROBED LIVE (timeMachineTOP → cacheSelectTOP fallback) because the optype name varies by TD build; the feedback opacity par (opacity → fadeval) and cache-depth par (cachesize → maxframes) are also set defensively. Every par/connect failure is collected as a warning and the chain still returns its output Null — UNVERIFIED across TD builds; tune live. Ends with a Null TOP 'out'.

Create a TouchOSC-oriented OSC mapping surface and JSON manifest DAT. This intentionally does not claim to generate TouchOSC .tosc documents.

Layer-1 audio splitter: differences a fast and a slow envelope follower to expose two normalized 0..1 channels — 'transient' (percussive onsets) and 'sustain' (tonal floor) — on a Null CHOP at {comp}/out. Pair with bind_to_channel to drive visuals from percussion vs sustain independently. Custom-par page 'Tune' on the parent COMP exposes Sensitivity + per-envelope attack/release for live tweaking.

Build a parameterized A→B transition over a single 0–1 Progress knob — the executable core of VJ cutting. Creates a new baseCOMP under parent_path holding two sources (brought in via Select TOPs, or built-in contrasting test looks when omitted) and one of five transition styles: 'dissolve' (a Cross TOP crossfade), 'luma_wipe' (a Ramp-gradient-driven moving edge via GLSL), 'slide' (B pushes in from the right over A), 'zoom' (B scales in over A), or 'glitch_cut' (a hard A→B switch at 0.5 with a brief RGB-split tear). Progress 0 = full A, 1 = full B. Exposes live 'Progress' + 'Duration' knobs; drive Progress from manage_cue / bind_to_channel to run the transition on a beat or cue. Output is a Null ready for post-processing or setup_output. Returns a summary plus a JSON block with the container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Build a bidirectional OSC or MIDI control surface that drives TouchDesigner params from a controller AND echoes outgoing changes back to it (motor faders, RGB pads), with an oscillation guard so the device's own echo doesn't ping-pong. Each mapping pairs a device address with a TD parameter; a Script CHOP gates outbound sends by epsilon delta, rate limit, and a last_in cache. Exposes Bypass, Globaleps, Ratehz, Reseccache custom pars on the container.

Create an Unreal Engine Live Link/OSC/NDI handoff scaffold with subject maps, event queue, and runtime setup warnings.

Create a VCV Rack OSC/MIDI/CV modulation bridge scaffold with channel mapping and setup notes.

Build a pulse-driven image-to-vector-lines system: capture a still frame from a synthetic, camera, file, or existing TOP source, prepare a monochrome mask, freeze it to a snapshot, trace it through a Trace SOP for editable vector geometry, generate a clean TOP line-art overlay, and composite it over the source. Phase 1 is intentionally not realtime: the artist presses the Vectorize pulse to update trace1/frozen_frame, keeping cook cost bounded. Source defaults to a static synthetic contour card so it previews without camera permissions or moving noise; camera is opt-in. Exposes Vectorize, Threshold, PreBlur, StepSize, Smooth/Fit/Border toggles, line color/width, opacity, overlay mode, and calibration knobs. Returns the container, source/prep/frozen/trace/vector/output paths, warnings for unverified Trace/snapshot details, and a preview.

Build a true vertex-shader displacement material: a GLSL MAT whose vertex stage offsets each vertex along its normal by procedural 3D noise (uTime-animated) or by the luminance of a sampled TOP (texture_path), so the mesh is physically deformed on the GPU. Distinct from the TOP-space image warps create_depth_displacement / create_displacement_warp — those push 2D pixels; this pushes mesh vertices. Assign it to your own Geometry COMP via target_geo, or omit it to build a self-contained demo (subdivided sphere + camera + light + render + Null) so the material previews standalone. Creates a new baseCOMP under parent_path. Exposes Amount, Frequency, and Speed controls bound to the MAT. Returns a summary plus a JSON block with the container path, created node paths, the material path, the output path (demo only), exposed controls, node errors, warnings, and (demo only) an inline preview image.

Build a movie/clip player inside a new 'video_player' container under parent_path: one Movie File In TOP, or a playlist of clips fed through a Switch TOP with a Clip selector. Exposes live Play / Speed (and Clip) controls, output as a Null TOP. Pass file paths, or none to get an empty player you point at a file in TD. Use create_video_synth instead when you want a procedurally generated (oscillator/CRT) image rather than playing a video file. Returns the created clip paths, the output Null path, and whether a playlist was built. For VJ clip playback — mix it with create_layer_mixer or make it react with bind_to_channel.

Build a broadcast-style video engineering monitor with multiple scope panels: waveform (luma trace), RGB parade (per-channel traces), and vectorscope (UV chrominance scatter). Each panel renders as a CHOP-to-SOP scope line through an orthographic camera and Render TOP, composited into a single output TOP via layoutTOP. Companion to create_waveform (audio) and create_spectrum (audio frequency). Default source is a synthetic test pattern (no device permission needed); 'device' is opt-in for live camera. The histogram panel here is unsupported in TD 099 and silently skipped — for a working luminance/RGB histogram use the standalone create_histogram_scope instead.

Instantiate an analog video-synthesizer pattern (lissajous oscillator curve, moving interference fringes, or CRT scanline modulation) into a GLSL TOP with live Speed / FreqX / FreqY / Scale / Color controls, output as a Null TOP inside a new 'video_synth_' container under parent_path. An oscillator/interference generator for VJ work — distinct from create_shader_lib's tunnel/raymarch/fractal/metaball looks. Use create_video_player instead when you want to play a real movie file rather than generate a pattern. Returns the chosen mode, its parameters, and a preview of the output TOP.

Drape a vintage analog-film aesthetic over any TOP in one call. Chains barrel/pincushion lens distortion → chromatic aberration → vignette → film grain as four inline GLSL passes inside a new baseCOMP. Era presets (super8, vhs, 16mm, 80s_camcorder) load era-correct strength defaults; any per-param override wins. Returns a standard Layer 1 envelope with container path, node paths, output path, preview image, warnings, and the resolved strength values.

Create a VIOSO projection-warp scaffold with VIOSO TOP, blend-zone maps, projector metadata, and setup notes.

Create a complete visual system from a natural-language description. Classifies intent (audio-reactive, particle, feedback, reaction-diffusion, landscape, generative) and delegates to the matching Layer-1 builder (or a tag-matched recipe), creating a self-contained COMP under parent_path, then verifies and previews it. Use plan_visual instead for a dry run that reports which tool/recipe would be chosen without building anything. Returns a note on how the description was interpreted plus the underlying builder's result (created nodes, exposed controls, and a preview image).

Create a dry-run/approval-gated voice-to-prompt TouchDesigner scaffold for AI Party-style workflows. It never dispatches raw hardware effects; policy and operator approval remain authoritative.

Build a stacked-slice fake-volumetric noise field: smoke, nebula, ember, ice, toxic or mono palettes. Architecture: Simplex 3D noiseTOP → optional displace+blur → cacheTOP (depth = slice_count) → viewer glslTOP (Beer-Lambert accumulation across slices, baked palette) → nullTOP output. NOTE: this is a stacked-2D-slice approximation, NOT a raymarched volume. There is no per-pixel ray traversal or SDF. For a true raymarcher see the planned create_volumetric_raymarch (L-effort follow-up). Cook cost scales roughly linearly with slice_count × resolution. Default 16 slices is the safe sweet spot; drop to 4–8 on integrated GPUs. Returns a summary JSON with container path, created node paths, the output path, exposed controls, any node errors, warnings, and an inline preview image.

Isometric voxel-stack renderer driven by any TOP. Builds a single instanced Geometry COMP (boxSOP, N=cols·rows instances up to 256×256) with a CHOP chain sampling luminance for column height and per-instance color. Color modes: source_color (sample TOP directly), palette (Monument-Valley pastel ramp), height_ramp (same palette, height-based). Isometric ortho cam (rx=-35.264°, ry=45°) by default; perspective available. Exposes HeightScale, VoxelSize, and RotateY controls. If source_top_path is omitted, an animated noiseTOP drives the stack.

Build a time-domain audio waveform / oscilloscope — the actual audio signal scrolling left-to-right as a moving trace (the time-domain companion to create_spectrum's frequency bins and detect_onsets' transients). A Trail CHOP keeps a rolling buffer of recent samples (time_window seconds), a CHOP-to-SOP turns those samples into a real scope LINE (x=time, y=amplitude) rendered by a Geometry COMP through an orthographic Camera + Render TOP, and a Constant TOP tints the trace to the chosen colour. Unlike create_audio_reactive (which renders a spectrum), this shows the raw waveform. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic oscillator (for testing), or an existing CHOP. Output is a Null TOP. Scale is the vertical amplitude zoom; TimeWindow is the horizontal time span.

Create a Window COMP output matrix scaffold with window maps, source maps, status, and setup notes.

Build a draggable 2D (XY) gesture pad — a Container COMP whose pointer drag drives an x/y CHOP of normalized control channels, optionally remapped into ranges and bound by expression to target parameters (e.g. an effect's two main knobs). Add a 3rd (Z) axis via z_target to also get a slider. Open the container in Perform/Panel mode and drag inside it to scrub X/Y live. The pad reads its drag through a Panel CHOP; the u/v drag-channel names are probed at build time (they vary by TD build) and any mismatch is reported as a warning. Leave the axis targets empty to just expose the x/y channels and bind them later with bind_to_channel.

Build a deterministic TouchDesigner scaffold for YOLO-style object tracking. Creates source input, backend receiver placeholder, detections DAT, stable tracks_out CHOP channels, annotated_out TOP, and setup notes. Live detection requires an external detector or validated TouchDesigner Python ONNX runtime.

Create a ZED camera depth/body/point-cloud scaffold with ZED TOP/CHOP/SOP placeholders and runtime-gated warnings.

Bundles a curated, hand-picked set of vault assets (recipes, components, looks, raw assets) into a single portable, shareable pack with provenance + integrity. action=pack gathers items into a .pack/ directory tree with a JSON manifest and checksum manifest. action=unpack restores the tree, optionally verifying integrity. Fully offline — no TD bridge required.

Safely remove or bypass one TouchDesigner node. mode:'delete' asks the artist in TouchDesigner to choose exactly Delete / Bypass / Keep; close, timeout, error or unavailable UI means Keep. mode:'bypass' is immediate and reversible. TDMCP_YOLO is an explicit audited skip policy, never inferred from missing UI. The bridge wraps the final mutation in a TouchDesigner undo block; whole-tool undo across multiple REST requests remains unverified. Returns the decision, action applied, final path, confirmation policy/request id and undo label when available.

Build a transient/onset detector that flags kick/snare/hi-hat hits in live audio and exposes a per-band pulse channel (a 0→1 spike on each hit) on a Null CHOP. Unlike create_tempo_sync (a fixed internal clock), this follows the ACTUAL audio: bind a parameter to op('…/onsets/onsets')['kick'] to flash or cut exactly on the kick drum. Each band is built from primitives (band filter → RMS energy → moving-baseline compare → threshold), so a Threshold knob tunes hit sensitivity and a Sensitivity knob scales the output. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic oscillator (for testing), or an existing CHOP. With emit_events on, it also broadcasts an onset event over the bridge WebSocket on each hit. The audio-following complement to create_tempo_sync.

EXPERIMENTAL monophonic pitch tracker. Estimates the dominant musical pitch of live audio and exposes pitch_hz (frequency in Hz), note (MIDI note number), and confidence (peak magnitude) on a Null CHOP — bind a colour/parameter to op('…/pitch/pitch')['pitch_hz'] to drive visuals from a melody. Built entirely from stock CHOPs (the Pitch CHOP isn't createable in this build): an Audio Spectrum CHOP in 1-sample-per-Hz mode, trimmed to a [min_hz, max_hz] search band, then an Analyze CHOP argmax (highestpeakindex) whose index IS the frequency. A Threshold knob mutes the pitch when nothing is clearly playing and a Sensitivity knob scales the magnitude. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic sine oscillator (for testing), or an existing CHOP. Caveats: ~1 Hz resolution, no harmonic/octave correction, monophonic only — approximate and best tuned live.

EXPERIMENTAL automatic tempo (BPM) detection WITHOUT manual tapping. Detects beat onsets in live audio (kick band → RMS energy → moving-baseline threshold, reusing detect_onsets' primitive), measures the time between beats, and reduces the recent inter-onset intervals to a stable tempo (median → BPM = 60/interval) exposed as a bpm channel on a Null CHOP — bind a parameter to op('…/detect_tempo/bpm')['bpm']. Complements sync_external_clock (which is tap-tempo) and detect_onsets (which flags hits but derives no tempo). With drive_tempo on, it writes the detected BPM to the global tempo (op('/').time.tempo) so every Beat CHOP — create_tempo_sync, create_autopilot — follows the music automatically. Source defaults to a synthetic gated tone (device capture can hang TD on a macOS permission modal); also accepts a file, an existing CHOP, or the live device. Caveats: time-dependent (reads 0 on a paused timeline), can lock to half/double time, and must be tuned live per source (Threshold + Smoothing knobs).

Read-only: check whether TouchDesigner is reachable, whether display/projector topology matches expectations, and whether generated sensor/helper status DATs such as source_status or bridge_status are healthy. This is a room/hardware preflight for physical installations; it returns PASS/WARNING/FAIL/UNVERIFIED checks without mutating the TD project.

Inspect a TouchDesigner TDAbleton mapper COMP and its source CHOP. Reports common mapper symptoms and can optionally repair Oscinputchop, Reorder, Bypass, and Min/Max parameters without requiring AbletonMCP or a live Ableton connection.

Offline deep diff of two saved library assets on disk (recipe JSONs, component manifests, or serialize-network spec JSONs). Reports added/removed keys and changed values (old to new); for recipes it also diffs nodes, per-node params, and connections. Does not touch TouchDesigner. Use diff_snapshots to compare two live TD graphs.

Compare two network snapshots (from snapshot_td_graph) and return a readable diff: which nodes were added or removed, which connections changed, and which parameters changed (with before/after values). Snapshot before an edit and after to see exactly what changed, or to version a patch over time. Pure analysis — touches nothing in TouchDesigner.

Remove one or more input wires from a node in TouchDesigner. By default removes every incoming wire into to_path; narrow the scope with from_path (only wires from that upstream node) and/or to_input (only that input slot index). Returns the list of removed wires (input index + upstream node path), a probe of the Connector API attributes seen at runtime, and any per-wire warnings. Fatal only when to_path is not found — partial removals with per-wire warnings still succeed. The inverse of connect_nodes.

Document an EXISTING network: read its nodes and connections and return a readable map — counts by operator family and type, plus a Mermaid flowchart of the data flow you can paste into docs. Unlike plan_visual (which plans from a description), this describes what's actually in the project. Use it to explain or hand off a patch.

Read-only: convert an ordered TouchDesigner operator chain into a RecipeSchema draft without writing files or touching the TD bridge.

Read-only: convert an embedded TouchDesigner technique with GLSL source into a RecipeSchema draft without writing files or touching the TD bridge.

Read-only: extract a conservative operator chain from an embedded TouchDesigner tutorial and draft a RecipeSchema JSON without writing files or touching the TD bridge.

Wraps the community StreamDiffusionTD.tox (by dotsimulate) into a one-shot Layer 1 setup: locate the .tox via candidate-path discovery, drop it into a fresh baseCOMP, wire a camera/source TOP into its input, set the prompt/strength/cfg/seed custom pars, and optionally re-broadcast the output via Syphon/Spout or NDI. Returns a friendly error when the .tox is not installed. The result envelope includes validated_pars so downstream tools (create_ai_mirror) know which SD pars to bind a control panel to.

Copy a node or whole COMP (and all its contents) to a new node, placed in the source's parent or another parent_path. Returns the source path and the new copy's path. Use duplicate this way to clone a built network; use create_container instead when you just need a fresh empty COMP.

Surgically replace a substring inside a Text or Table DAT's .text. Without replace_all, requires exactly one match — 0 or >1 occurrences is an error, forcing the caller to add context or set replace_all. Use set_dat_content to overwrite an entire DAT's text in place; use this to make a targeted edit. Because DAT text can become executable callbacks, this tool is hidden when TDMCP_RAW_PYTHON=off and the bridge also requires TDMCP_BRIDGE_ALLOW_EXEC=1 for writes.

Edit a GLSL/Text DAT and immediately run the practical shader feedback loop: write or surgically replace source text, inspect the shader/output node for errors, and optionally capture a compact inline preview. Uses set_dat_content/edit_dat_content under the hood so DAT write guardrails stay consistent, and requires TDMCP_RAW_PYTHON=on plus TDMCP_BRIDGE_ALLOW_EXEC=1.

Atomically edit an operator's name, parent, exact Network Editor position, color, comment, or writable flags. The bridge prevalidates requested fields, reads values back, and rolls back partial failures; parent moves copy and validate the destination before destroying the source. Returns the final path and per-field results. Does not use raw Python fallback.

Use the schema + LLM to propose values for a tool call's missing required args.

Run score_build and ask the configured LLM for bounded allowlisted improvements. Legacy calls are unchanged. Optional visualCritique uses the exact calibrated local vision receipt, explicit numeric targets, preview-only defaults, native Apply/Keep approval, CAS/readback, and compensating restore; autoApply never bypasses approval.

Escape hatch — invoke an arbitrary Python method on a node (operator). Prefer structured tools where one exists; use this for operations they don't cover (e.g. .cook(), .copy(), .destroy()).

Escape hatch — run an arbitrary Python script inside the TouchDesigner process. Prefer the structured tools (find_td_nodes, get_td_node_parameters, update_td_node_parameters, summarize_td_errors, snapshot_td_graph, …); reach for this only when no structured tool can express the operation. Code runs in TD only, never on the local machine.

Save a COMP as a git-diffable externalized .tox tree using TouchDesigner's 'save external' (COMP.saveExternalTox). Instead of one opaque binary, the component — and, with recurse=true, every descendant COMP — is written to its own .tox file on disk with its externaltox parameter pointed at that file, so a version-controlled project shows per-node diffs. Writes files under out_dir (destructive) and mutates the live COMP's externaltox pars. out_dir is passed to the TouchDesigner process, so it must be a path that process can write to.

Save a COMP as a .tox inside <vault>/<folder>/<slug>.tox and write a sibling Markdown note (id/type=look + name + tags + assets + created + source_path). Defaults folder to Looks. The artist-publishing primitive for portable looks; integrates with browse_vault_library and tag_and_search_library via the note frontmatter. Requires TDMCP_VAULT_PATH and a running TouchDesigner bridge.

READ an existing TD network's topology and WRITE it as an Obsidian note: a Mermaid flowchart plus [[wikilinks]] for every operator and connection, so the vault's graph view becomes a clickable map of the patch. The note (Networks/.md by default) is fully rewritten on each call. Use this to persist a browsable map in the vault; use document_network to get the same documentation back as a tool result without touching the vault. Returns the note path and the node/connection counts (and whether output was truncated). Requires a configured TDMCP_VAULT_PATH.

Save a COMP as a .tox into TouchDesigner's native Palette folder so it appears in the Palette browser for drag-and-drop reuse.

Write a portable JSON recipe bundle to out_file. When include_all=false, recipe_ids selects the entries; when include_all=true, the full local library is exported and recipe_ids is ignored. Unknown IDs are reported in missing rather than silently substituted. Use import_recipe_bundle to restore the bundle on another machine or publish_recipe_bundle when you need checksums/versioned handoff artifacts. This writes a local file and returns the bundle kind, version, timestamp, exported recipes, and missing IDs.

Start/stop a movie export with named VJ/editorial presets (HAP, HAP Alpha, ProRes 422/4444, NotchLC, MP4 review) while reusing record_movie's Movie File Out TOP recorder. This records a TOP to a file written by TouchDesigner and documents the expected codec/extension/fps for downstream playback tools.

Serialize the current cues stored on a COMP (manage_cue snapshots, keyed 'tdmcp_cues') into a setlist note in the Obsidian vault, so a live-built show can be round-tripped into the vault library as a git-diffable setlist. The note frontmatter tracks array matches what import_setlist expects — each cue becomes a track with its title and optional bpm, ready for a recipe id to be added by hand. Re-import the note later with import_setlist to rebuild the visuals. Requires a configured TDMCP_VAULT_PATH.

Walk a SOP's primitives via the bridge and emit an SVG document of polylines (each primitive becomes one <polyline>). Projects to x/y (drops z), auto-fits viewBox, supports stroke/fill/scale/flip_y. Writes to disk when output_path is supplied and always returns the SVG string in the report. Pen-plotter / laser / print deliverable.

Adds extra transports to the data-source fabric beyond create_data_source: 'mqtt' subscribes to a broker, 'ws-binary' streams binary frames over a WebSocket, 'midi-mmc' listens for MIDI Machine Control transport bytes (play/stop/record/locate). Same downstream shape as create_data_source — a Null DAT for the raw text/bytes and a Null CHOP whose channels are ready for bind_to_channel / create_data_visualization.

Build an audio-analysis chain that exposes ready-to-bind reactive channels — overall level plus bass/mid/treble band energies — on a Null CHOP. Unlike create_audio_reactive (which renders a spectrum visual), this produces the raw signals so you can drive ANY parameter: bind a node parameter to op('…/audio_features/features')['bass'] and it pulses with the music. A Sensitivity knob scales all channels. Source can be the live device (mic/line — may prompt for macOS permission), an audio file, a synthetic oscillator (for testing), or an existing CHOP. Use create_spectrum for N fine per-band channels instead of these four coarse bands, and pass this Null as the source_chop to bind_audio_reactive to make a whole COMP react.

Sample dominant colors from a TOP by capturing its preview PNG and running deterministic k-means on the decoded RGB pixels. Returns {source_top, k, width, height, pixels_sampled, hex_colors[], swatches[{hex,rgb,weight}], warnings[]} sorted by dominance (most-frequent cluster first). Feeds AI grading prompts, create_palette, and design hand-offs. Read-only; no nodes are created or modified.

Read-only: compact bridge-side node search by name/path glob, exact or partial operator type, family and bounded depth. Returns {count, truncated, matches/paths, search_metadata} without transferring topology; older bridges fall back only to structured list/topology reads. Prefer this over get_td_nodes when looking through a sub-tree; use get_td_topology only when you need wiring.

Read-only: bounded bridge-side search for live TouchDesigner parameters by node, operator type/family, parameter name, evaluated value, expression, mode, or non-default state. Values are point-in-time snapshots; likely secrets are redacted and cannot satisfy value/expression filters. Inspect scan_truncated and count_complete before claiming project-wide completeness. Requires the current structured bridge route and never falls back to raw Python or a full parameter dump.

Safely follow one same-parent operator group in an existing TouchDesigner Network Editor. Reuses the active/already-owning pane, replaces stale selection, sets an explicit current operator, and returns applied or fail-closed suppression readback. UI-only: it never creates panes or changes project topology, and Perform/headless/disabled states do not steal focus. Smooth colour highlights remain held pending live compare-and-swap proof.

READ a moodboard note (frontmatter technique/palette/colors/speed plus a prose description) and CREATE a matching generative system in TouchDesigner via create_generative_art. Side effect is node creation in TD, not file writes; the palette/mood is passed only as a best-effort color hint. Use this to seed a system from a vault moodboard; call create_generative_art directly to specify the technique and palette inline. Returns the created generative-art network (same result as create_generative_art). Requires a configured TDMCP_VAULT_PATH.

Write one Markdown contact-sheet note of the whole vault library — recipes, shaders, presets, components, and setlists — as a grid of cards, each with its thumbnail (the .png sibling written by save_recipe_to_vault / save_component_to_vault), title, tags, and a copy-paste load snippet (e.g. apply_recipe id=…). No TouchDesigner connection required: it reads the local vault on disk and writes the index note. Filter by category (kinds) and/or a substring query. Requires a configured TDMCP_VAULT_PATH.

Produce a Markdown project document for any COMP or project: family/type counts, custom-parameter table, inputs/outputs, child inventory, external file dependencies, and an optional preview thumbnail of the output TOP. Use include_mermaid to add a Mermaid flowchart and max_nodes to cap large inventories. Returns the full Markdown on the structured channel under markdown.

Curated technique pack of canonical generative looks (feedback tunnel, audio spectrum, noise landscape, particle galaxy, reaction-diffusion, webcam glitch). list_only=true returns the technique cards plus the list of recipes the active library can satisfy; list_only=false also writes a portable bundle JSON (import_recipe_bundle-compatible) at install_path. Pure Node — no TouchDesigner bridge required.

Read-only: collect recent cook errors and warnings from the running TouchDesigner project for debugging. Walks the operator tree under scope and gathers each operator's current cook errors and warnings (guaranteed). Also attempts a best-effort probe of textport/log DATs if they exist in the project. Use this when a script or cook fails and you need more context than the immediate error string — it surfaces the real Python traceback or operator cook errors without requiring a new REST endpoint. Returns {lines[], count, probe} where probe reports which log sources were reachable in this TD build.

Read a Text or Table DAT with pagination so a large table cannot flood context. Returns total row/col counts, a header (table DATs), a sliced page (offset/limit), an optional stable head preview (preview_rows), and a row_range only on a partial read. Table DATs are split on tabs/newlines client-side — that split is lossy if a cell embeds a literal tab or newline (probe live before relying on it). Use edit_dat_content/set_dat_content to write.

Read compact project and editor state for references such as 'this node', 'the selected node', and 'place it here'. Returns only available project/build, perform mode, pane, active Network Editor, current/selected, rollover and viewport fields; unavailable UI fields are omitted with warnings instead of inferred. Does not dump project topology or mutate TouchDesigner.

Read-only one-shot inspection of a TOP: small base64 thumbnail (default 256² JPEG) + parent error sweep (BFS up parent_depth hops) + top-N changed-from-default parameters + cook stats. One call instead of chaining get_preview / get_td_node_errors / get_td_node_parameters when you just want to know 'is this op alive and healthy?'. Use get_preview/render_output for delivery-grade frames; this thumbnail is intentionally tiny + lossy.

Read-only: human-readable Markdown help (description, members, method signatures) for a TouchDesigner Python class or module, from the embedded knowledge base (offline). Returns formatted text, or {found:false, suggestions[]} of near-name matches if unknown. Use get_td_class_details instead when you need the same information as structured JSON to process in code.

Read-only: inspect a single operator's runtime telemetry — cook time, cook count, last-cook frame, resolution (TOPs), channel/sample counts (CHOPs), GPU memory usage, cook errors, and optional Info CHOP channels via include_info_chop. Complements get_td_performance (which aggregates cook times across a network) by providing deep per-op detail for the 'why is it black / why is it slow' diagnostic loop. Returns {path, type, family, cook_time_ms, cook_count, last_cook_frame, resolution, num_chans, num_samples, gpu_memory, info_chop?, errors[], warnings[], extra}. Attribute names are flagged UNVERIFIED and vary by TD build; the extra map records which attrs were actually present for live confirmation.

Read-only: return an embedded TouchDesigner operator workflow guide with common inputs, outputs, examples, next-operator suggestions, and snapshot provenance. When an operator is absent from the imported snapshot, returns candidate guide ids and an explicit snapshot caveat instead of claiming that the operator does not exist.

Read-only: for each menu parameter of a node, live-fetch the menu option values (menuNames — the machine values you set with par.val), their human-readable UI labels (menuLabels), and the currently selected value (current). Use this before setting a Menu / StrMenu parameter so you pick a valid option instead of guessing. Values come straight from the running TouchDesigner build, so they are authoritative and even include dynamically-populated menus (device lists, file menus) — an empty menuNames on a known-menu parameter means the menu has not populated yet (the node has not cooked / the device is not enumerated), not that there is no menu. Requires TDMCP_BRIDGE_ALLOW_EXEC=1; when raw exec is unavailable it falls back to the bundled catalog and attaches a stale-catalog warning.

Capture a TOP node's current output as an inline PNG image. This is read-only. The bridge may return the TOP's native output dimensions instead of the requested width×height; when they differ, the caption shows both. Only TOPs can be previewed (CHOP/SOP/etc. have no image). For a cheaper check of activity and approximate colour, pass sample_grid=N to return an N×N grid of RGBA samples and per-channel statistics instead of an image.

Read-only: full STRUCTURED documentation for one TouchDesigner Python class (members + methods) from the embedded knowledge base (offline). Returns the class object, or {found:false, suggestions[]} of near-name matches if unknown. Use get_module_help instead when you want the same content as ready-to-read Markdown rather than structured JSON.

Read-only: list TouchDesigner Python API class names from the embedded knowledge base (works offline, never touches TD). Returns {classes[]} of name/displayName entries. Optionally filter by name. Use get_td_class_details or get_module_help to expand one class into its members and methods.

Read-only: resolve compact TouchDesigner operator, Python API, or concept documentation from the installed OfflineHelp corpus first, then the embedded KB. Returns section ids for bounded drill-down plus installed/running build provenance. Web fallback is off by default and, when explicitly enabled, is restricted to docs.derivative.ca and labeled as latest-web rather than installed-build truth. Never accepts a filesystem path or returns raw HTML.

Read-only health check + TouchDesigner server info. Returns {connected, endpoint, touchdesigner version info, knowledge-base stats, bridge_stale?} and changes nothing. Use this first to confirm the bridge is reachable; it succeeds even when TD is offline, reporting connected:false with the reason. Also warns when the running Python bridge is older than this build (a common gotcha — editing td/ doesn't reload the running bridge), pointing you at reload_bridge.

Read-only: check one node (or, with recursive:true, its whole sub-network) for cook/compile errors and warnings. Pass summary:true for grouped counts instead of the full list. Returns {total, errors[] or by_type}. For a large network prefer summarize_td_errors, which clusters errors by shared cause and points at the worst-offending nodes.

Read-only: report each node's operator flags (bypass / render / display / lock / allowCooking / clone) plus index-aware input wiring, network position, color and comment — the signals that explain a black/blank output that a parameter dump hides. Scan one node or a subtree (recursive); set only_problems to surface just the ops whose flags or cook errors would suppress output. Returns structuredContent for code to process.

Read-only: read the current parameters (and inputs/outputs) of one node. Returns {path, type, name, parameters, inputs, outputs}. Pass keys to project specific parameters or omit_io:true to drop the inputs/outputs lists. Use compare_td_nodes to diff two nodes' parameters at once. Token economy: pass keys to fetch only the parameters you care about and omit_io:true to drop inputs/outputs — a full parameter dump is large.

Read-only: list the DIRECT child nodes of one COMP. Defaults to a compact summary (count + type breakdown + sample paths); pass detail_level:"full" or path_only:true for the complete list, and pattern to filter by name. Returns {count, by_type/sample or paths/nodes}. Use this to browse one level; use find_td_nodes to search recursively and by operator type, or get_td_topology when you also need the connections between nodes. Token economy: keep the default compact summary and scope with pattern; only request the full list when you truly need every path, and avoid re-listing a path you already inspected.

Read-only: report cook times under a network (recursively by default, slowest node first) and warn about nodes that exceed the frame budget. Returns {targetFps, frameBudgetMs, totalCookMs, nodes[], warnings[]} and changes nothing. Use this to just measure; use optimize_performance when you want suggestions and the option to auto-shrink the slow TOPs.

Read-only: return the nodes AND the connections (wiring) under a network root, flagging obvious structural issues. Returns {nodeCount, connectionCount, issues[], topology}. Use this when you need how nodes are wired together; use get_td_nodes/find_td_nodes when you only need the node list without connections, or snapshot_td_graph when you also want each node's parameters captured for diffing. Token economy: point it at a specific network root rather than the project root, and leave recursion off unless you need nested networks.

Read-only: inspect embedded TouchDesigner technique packs and individual techniques, with optional code snippets and setup/workflow details.

Read-only: list embedded TouchDesigner tutorials, search tutorial metadata/content, or retrieve one by id/name. With include_content, the content is capped (~30K chars) and comes with a sections_available list; pass a section title to drill into just that part instead of pulling the whole document.

Turn any image (a file path or an existing TOP) into a GPU particle field: each particle's rest position is its pixel in the source and (by default) its colour is sampled from that pixel. A spring force pulls particles toward their rest pixel; an optional audio chain scatters them away and lets them spring back, producing the iconic 'image dissolves into points on the drop, then re-forms' VJ look. Builds a new baseCOMP holding a downsampled source TOP, a one-shot rest-position GLSL TOP, velocity + position feedback loops (RGBA32float), an instanced Geometry COMP, Render, and a Null output. This is the only particle tool seeded by image/video pixels (rest positions + per-pixel colour); pick a sibling instead when particles are NOT driven by an image: create_gpu_particle_field for a free noise/curl/gravity drift field, create_particle_flock for boids/flocking, create_pop_particle_system for TouchDesigner's native POP particle network, create_particle_system for a simple CPU emitter. Default source is TD's stock Banana.tif; default audio source is 'none' (image idles statically) — 'file' and 'device' are opt-in (the latter may pop the macOS mic-permission dialog). Returns a summary plus a JSON block with the container path, particle count, output path, exposed controls, node errors, warnings, and an inline preview image.

Create a new TouchDesigner system container containing an ISF (.fs) shader as a GLSL TOP, companion DATs, and optional live controls. Accepts raw source, a local file path, or an http(s) URL; URL fetches are bounded by fetch_timeout_ms. Returns the container/GLSL/output paths, generated controls, provenance, warnings for inputs that need manual wiring, and an inline preview when capture_preview=true. Use create_glsl_shader for hand-written GLSL or import_shadertoy for Shadertoy sources. Imported shader source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1.

Import a 3D model file (.obj/.fbx/.usd) and render it to a TOP: a File In SOP reading model_path, fed into a Geometry COMP, with a Camera, a Light, and a Render TOP output as a Null. Omit model_path to fall back to a default primitive so the network still builds with no dependencies. Exposes RotateY (spin), Zoom (camera distance) and Scale knobs — the imported-model sibling of create_3d_scene.

Import recipes from a portable JSON bundle into a recipe directory. The inverse of export_recipe_bundle: each recipe is validated before it is written, so a malformed bundle fails loudly instead of corrupting the directory. Writes files (destructive).

Fetch, validate, and import a recipe or recipe-bundle JSON from an HTTPS URL into a local recipes directory (host-allowlisted, size-capped).

READ a setlist note (frontmatter tracks: an array of recipe ids or {title, recipe, preset, bpm, notes} objects, OR the newer scenes: an array of {id, cue, recipe, preset, steps, …} scene objects) and build each scene's recipe — CREATING the operators in TouchDesigner under parent_path — to pre-stage a show's visuals. Recipe ids resolve against both built-in and vault recipes; preset-only and cue-only scenes are skipped (recall them live via setlist_runner instead). Use dry_run:true to validate the note without touching TD. Returns the resolved note path and the lists of built vs skipped tracks. Requires a configured TDMCP_VAULT_PATH.

Build a GLSL TOP from a Shadertoy URL, ID, or pasted source. Imported shader source requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. Wires iChannels (defaulting to noise placeholders), exposes Speed (and optional Mouse) controls, and captures a preview. First fetch on macOS may trigger an outgoing-connection permission prompt. Set TDMCP_SHADERTOY_KEY for reliable fetches; paste into raw_source to stay offline.

Atomically insert one same-family operator on one deterministic downstream edge of the exactly selected/current TouchDesigner operator. Requires an exact editor-context compare-and-swap and an idempotency key; returns bounded before/after connector receipts, explicit non-overlapping placement and rollback state. Fan-out siblings and sibling inputs are preserved. Uses the authenticated structured bridge with ALLOW_EXEC=0; it never invokes raw Python, mouse-interactive placeOPs, or implicit pane selection.

Read and validate a tdmcp component/library manifest from a package folder or file. Read-only: use it to check a package's metadata, declared assets, and docs before install_library_package or make_portable_tox; reports validation problems instead of throwing.

Read-only: returns the host GPU info (name, driver, VRAM), attached monitor topology (resolution, refresh rate, primary flag, position), and whether the project is in Perform Mode. Use to plan output mapping, dome rigs, and multi-display shows without leaving the chat. Offline-safe — returns { connected: false, reason } when TD is unreachable.

Read-only: inspect what a COMP exposes — its Python storage dict (keys + values), its extension class descriptors (name, promoted flag, public members), and its custom-parameter definitions (page/name/style/default). Closes the inspect side of the reusable-component loop: use after scaffold_extension + add_custom_parameters to verify what was built, or call standalone to examine any COMP without resorting to raw Python. Returns structured data for agent code-path consumption. API names vary by TD build; the probe field records which attributes were reachable.

Install a local tdmcp component package folder, .zip, .tox, or manifest into an explicit project/user package scope, or preserve the legacy dest_dir/ form. Project scope requires project_dir and uses <project_dir>/.tdmcp/packages. Use inspect_component_manifest first for unknown packages. This copies or extracts files, refuses replacement unless overwrite=true, rejects symlinked directory trees, and returns scope plus resolved paths.

EXPERIMENTAL two-step 'MIDI learn'. Call once with mode:'snapshot' (controls at rest) to record every channel of an input CHOP (a midiin/oscin CHOP or a Null fed by one); then wiggle one hardware knob/fader and call again with mode:'bind' — it diffs against the snapshot, finds the channel that moved the most, and binds your target parameter to it by expression (with optional scale/offset). The snapshot is kept in the parent COMP's storage between the two calls. This is live/stateful: verify the matched channel in the report.

Read a TouchDesigner subtree under scope_path without changing TD, infer naming/colour/topology/parameter conventions, and write the result to the configured Obsidian vault. This is read-only on the TD side but mutates vault files: by default it writes Memory/conventions.md and may merge confident naming/layout signals into Memory/style.md. Set dry_run=true to inspect the extract without disk writes. Use learn_from_my_corpus when the source is already in the vault and load_session_profile when you only need to consume cached preferences. Requires TDMCP_VAULT_PATH and returns sampled conventions plus write flags.

Offline companion to learn_conventions: walks the Obsidian vault corpus (Recipes/, Components/, Looks/, Setlists/, Moodboards/) and distils palette, naming, recipe-shape, and param-default preferences into Memory/corpus_style.md (and optionally merges palettes/naming/favorite_generators into Memory/style.md). No TouchDesigner required — pure filesystem read. Requires TDMCP_VAULT_PATH (or pass vault_path).

Read-only, offline tool that scans the vault library (Recipes, Shaders, Presets, Components, Setlists), extracts lineage frontmatter (parent_recipe, source_assets, remix_of, forked_from), and emits a lineage graph. Output as JSON (machine-consumable), Mermaid (paste into docs), or Graphviz DOT. No TouchDesigner connection required.

Build a floor-occupancy tracker scaffold for synthetic rehearsal, Ouster TOP, Leuze ROD4 CHOP, or UDP point input. Produces a tracked_points CHOP plus a floor preview TOP; hardware modes default inactive and remain explicitly unverified until a real sensor is connected.

Offline semantic linter for recipes/*.json. Checks schema, id/filename match, duplicate node names, unknown operator types, dangling connections, bad parents, render-outside-geometryCOMP, missing parameter nodes, unresolved control bind_to, GLSL uniforms on non-GLSL hosts, and hygiene (tags/description/preview_description). Returns a structured report; never calls TouchDesigner.

List the built-in recipe library — ready-made network templates (feedback tunnel, particle galaxy, reaction-diffusion, projection mapping, …) with their id, name, tags and difficulty. Offline. Apply one with apply_recipe.

Reads ~/.tdmcp/session-profile.json (or a custom path) and returns a unified JSON snapshot that an agent should load at the start of every session. The profile caches the most recent outputs of style_memory, recall_similar_work, learn_conventions, and learn_from_my_corpus so the agent has the artist's preferences and past work at hand without running all four tools every time. If no file exists, a default skeleton is created and returned. Pass reset=true to overwrite with fresh defaults. The profile_path field in the returned object is always the resolved path that was read or written.

Scan a local package directory and write an index of installable tdmcp packages. Use it to make a folder of components browsable and installable as a simple local marketplace; the written index is what browse_library and install_library_package consume. Writes a file (destructive).

READ a snapshot of a TD network (node/connection counts plus any errors) and, optionally, a preview image of an output TOP, then WRITE a dated journal entry to Performances/-.md in the vault (the thumbnail is saved as a binary attachment). Use this to build a diary of your shows over time. Returns the note path, whether a thumbnail was saved, and the node/issue counts. Requires a configured TDMCP_VAULT_PATH.

Record the sequence of MCP tool calls to a portable JSON macro file. Actions: start | stop | list | load. Replay ships separately as run_macro_script.

Save one live TouchDesigner COMP as a portable .tox package on disk, then write a tdmcp-component manifest beside it and optionally copy docs/README files. Use this for packaging a finished component; use bundle_dependencies instead when external media must be collected and relinked. Requires a running bridge and writes/overwrites local files in out_dir; returns the saved .tox path, manifest path, README path, and warnings.

Safely inspect, install, update, or uninstall the small bundled tdmcp skill catalog for Codex or Claude. Mutations default to dry-run, use exact manifest ownership, reject unowned conflicts and symlinks, and roll back partial filesystem changes. Only package-bundled skills are accepted; this is not a remote or arbitrary skill installer.

Self-document a network: create a titled annotation box; safely edit an existing Annotate COMP's title, body, RGBA background, or exact node-space bounds; set an op comment; list annotations; or inspect geometric enclosure. The edit action is a structured, verified transaction that works with raw Python disabled.

Open, inspect, restore, or cancel one bounded TouchDesigner editor workspace using an existing Network Editor plus one right-hand TOP Viewer or Panel split. The bridge schedules every UI access on the TD main thread, keeps only JSON job state, uses compare-and-swap restoration, and fails closed in Perform/headless/conflicted states. It never opens arbitrary UI, creates project operators, adds graph undo, or falls back to raw Python; the authenticated structured routes work with ALLOW_EXEC=0.

Store / restore / list / delete a full snapshot of a sub-network — an 'undo point' to take before risky live edits. A checkpoint captures every node's constant parameters, the wiring, and node positions. Restoring reapplies parameters, recreates nodes that were deleted since (with their wiring), and prunes nodes that were created since. Unlike manage_presets (custom-parameter looks for performance), this captures the whole network for safe experimentation.

Build a reusable component library by moving COMPs to/from .tox files on disk. 'save' uses a deferred, verified same-directory temporary export and refuses overwrite by default; set overwrite_policy='ask' for native Overwrite/Keep consent. 'load' keeps its legacy behavior and reads file_path into parent_path. Paths are on the machine running TouchDesigner.

CRUD operations on a COMP operator's .storage dictionary. Actions: list (all keys+values), get (one key), set (write a key), delete (remove a key). No operators are created; the target COMP must already exist.

Live-performance scene system: store / recall / morph / list / delete named cues (snapshots of a COMP's custom-parameter values). Unlike manage_presets, a cue can be reached with a timed morph that crossfades every numeric control from the current look to the cue over N seconds (eased), via a small Execute DAT — so you can glide between looks on stage instead of hard-cutting. Recall and morph also take an optional quantize ('beat'/'bar') that defers the change to the next musical boundary (from the project tempo) so scene changes land on the downbeat. Build cues with create_control_panel, then jump or morph between them.

Search, list, inspect, doctor, install, reconcile, and uninstall manifest-driven TouchDesigner community packages at explicit user or project scope. Reconciliation is dry-run-first, proves marker ownership, and uses Delete/Bypass/Keep consent before pruning a live package. A legacy uninstall with a live TD target now returns the safe reconciliation plan instead of deleting local state first. This tool never runs third-party scripts, pip installs, model downloads, or external app setup.

Store, recall, list, or delete named snapshots of a COMP's parameter values — the live-performance preset system. Pair with create_control_panel: snapshot the knob positions and jump between looks. Snapshots are saved in the COMP's storage so they persist with the project.

Reads or atomically replaces the versioned brief at <project_root>/.tdmcp/agent-brief.json. Replace requires expected_revision='absent' for creation or the exact revision returned by read. Root precedence is explicit project_root, TDMCP_PROJECT_ROOT, then the saved-project folder from structured editor context; cwd is never used. Brief text is untrusted project evidence and cannot override current user intent, safety policy, consent, tool tier, verification, or emergency behavior.

Write a guarded starter marketplace index JSON with optional built-in seed entries and custom package entries. Use this before local_marketplace_index when planning a local package marketplace; overwrite=false protects existing index files.

Merge the contents of a source Obsidian vault into a target vault (defaulting to TDMCP_VAULT_PATH). Walks Recipes/, Shaders/, Presets/, Components/, Setlists/, and Memory/ folders. sha256-hashes each file pair and resolves conflicts with your chosen strategy: 'theirs' overwrites target, 'ours' keeps target, 'rename' writes a side-by-side copy, 'skip' logs and skips. dryRun=true plans without writing. Note: LF/CRLF differences count as conflicts.

Ingest 1..6 moodboard images and build a matching generative system in TouchDesigner. Uses the vision-capable local LLM when configured to extract palette + motion + generator pick (palette hint, generator from {audio_reactive, generative_art, particle_flock, feedback_tunnel, gpu_particle_field}, optional post-FX). Falls back to a deterministic style→generator grammar otherwise. Note: preview may read 0 on a paused timeline — press Play.

Export an existing create_preset_morph container's slots ('looks') to a portable, sha256-verified JSON file in the Obsidian vault (action=pack), or re-hydrate a pack file back into a (newly built if missing) create_preset_morph container (action=unpack). Reuses the create_preset_morph engine — does not invent a new morph topology. Requires TDMCP_VAULT_PATH unless inline 'looks' are supplied on unpack.

Build a renderable 3D scene with depth cues that read on stage: a Geometry COMP holding the chosen primitive (sphere/box/torus/grid), a Camera, a Light, and a Render TOP beauty pass, output as a Null — like create_3d_scene but with an optional Screen-Space Ambient Occlusion (SSAO) pass for contact shadows, and an optional Depth TOP output. The SSAO TOP is wired directly after the Render TOP (it needs the depth buffer — no TOP between them) and combined with the color. When expose_depth is on, a Depth TOP resolves the same render into a depth map exposed as a second Null ('depth_out'); feed that path into create_depth_displacement or create_depth_silhouette with source='existing_top' for a synthetic depth-driven effect — no depth camera needed. Optionally GPU-instanced into a grid, with spin over time. Exposes Spin, Zoom, and (with SSAO) an Ssao toggle. Returns a summary plus a JSON block with the container path, created node paths, the render/output/depth paths, exposed controls, node errors, warnings, and an inline preview image.

Persist the running narration of a live VJ/show set so decisions can be recalled afterwards. mode='append' adds a timestamped line (with optional section + cue) to a markdown session log (default ~/.tdmcp/narration-.md); mode='recall' reads the log back (last tail lines). Pair with the auto_vj_director prompt: instead of narrating only in chat, call narrate_set on each major move so the set leaves a diary/setlist trail. Writes a local file (not read-only). Delta vs log_performance, which writes a one-shot network snapshot rather than an append-only decision log.

Build a guarded Notch TOP or Engine COMP/TouchEngine bridge scaffold with notes, output, and optional Notch play/speed controls. This does not validate a Notch license or target runtime; live validation remains explicit.

Create an OBS WebSocket v5 control rig in TouchDesigner: websocketDAT connection, Constant CHOP command channels for stream/record/scene actions, and a chopExecute DAT that dispatches op:6 request payloads such as StartStream, StopStream, ToggleStream, StartRecord, StopRecord, ToggleRecord, and SetCurrentProgramScene. tdmcp never accepts or stores OBS passwords; if OBS authentication is enabled, complete Identify authentication manually in the generated obs_dispatch DAT.

Turn one source node, asset, or package entry into five deterministic remix briefs: colorway, motion, texture, spatial reframe, and performance cue. Offline/read-only planning tool for agents before mutating TouchDesigner networks.

Scan a network for cook-time bottlenecks and report the slowest nodes with concrete suggestions. By default this is a read-only measurement; with apply=true it mutates flagged TOP resolutions by scale and returns the before/after sizes. Run get_td_performance when you only need metrics; use this tool when you want the bounded resolution change, and leave apply=false for a plan-only pass.

Create an offline-safe OSC control matrix: one Constant CHOP plus OSC Out CHOP per target, deterministic left-to-right layout, target-specific address prefixes, and a structured report of every emitted OSC address. Use it as the primitive for QLab, atemOSC/Companion, Resolume, VDMX, or any OSC-speaking show-control endpoint.

Read-only: plan a TouchDesigner stable-version migration from offline release highlights plus operator and Python API compatibility records. Returns upgrade boundaries, focused compatibility deltas, and an operator checklist without touching TouchDesigner.

Turn a visual description into a read-only build plan. The deterministic planner remains the default and creates nothing. Set planner='llm' to opt into one bounded completion grounded in compact editor/project/recipe/operator evidence; every suggested tool, recipe and operator is validated, and any unavailable or invalid LLM path falls back deterministically without mutating TouchDesigner.

Compose a chain of 3D-aware post-processing passes (SSAO, SSR, DOF, motion blur) inside a new baseCOMP. Each pass is a glslTOP with companion textDAT that samples color + depth + (optional) normal/velocity AOVs from selectTOPs. Passes run in fixed order SSAO → SSR → DOF → MB and emit a final null TOP ('out1'). SSR is skipped with a warning when normal_top is empty; motion blur falls back to a directional blur when velocity_top is empty; if color_top points at a renderTOP and depth_top is empty, a sibling depthTOP is auto-created (best-effort). Returns container/output paths, the resolved AOV paths, the enabled passes, and any warnings.

Read-only: sample cook times over a window (N samples × intervalMs) and rank hotspot nodes by p95 cook time. Use this to diagnose intermittent stalls that a single get_td_performance snapshot misses. Returns {path, samples, intervalMs, targetFps, frameBudgetMs, windowMs, hotspots[], warnings[]}.

Compose a one-folder handoff/portfolio documentation PACKAGE for a network: a README.md (title, node count, per-family summary, how-to-load note), a topology.md with a Mermaid graph of the connections, and - when include_thumbnails is set - preview PNGs of output TOPs under thumbs/ linked from gallery.md, all written into out_dir. Unlike generate_readme (a single file), this assembles a small multi-file site folder for sharing or archiving a project.

Build a rehearsal-safe projector calibration network: generated grid/crosshair or selected source TOP, per-projector crop/corner-pin/level/output lanes, preview layout, notes, and brightness/gamma controls. Live projector alignment remains explicitly unverified until run on the physical outputs.

Writes a .provenance.json sidecar next to a saved artifact (tox, recipe note, recipe bundle, component bundle). Records the sha256 checksum, file size, mtime, source COMP path, originating tdmcp tool, toolchain versions, best-effort git metadata, author, tags, and freeform notes. Offline — no TD bridge required.

Write a local, versioned recipe-bundle publish artifact for CI upload or handoff: .recipes.json, tdmcp-recipe-publish.json, and tdmcp-checksums.json. Use recipe_ids for selected recipes or include_all=true for the whole library; overwrite=false protects existing artifacts. This is a filesystem write tool and returns artifact paths, checksum entries, included recipe count, and missing ids.

Validate that an existing operator parameter is Pulse style, invoke its structured .pulse() operation, and confirm the result. Missing operators, missing parameters and non-Pulse styles return typed bridge errors. Does not use raw Python fallback.

Create a QLab OSC control bridge using the OSC router matrix primitive. It exposes /go, /stop, /panic, /pause, /resume, /reset and optional /cue/{number}/start routes to QLab's configurable OSC receive port, without requiring QLab to be running during build.

Randomize a COMP's numeric custom parameters within their slider ranges — an instant new variation for live improvisation. amount blends toward random (1 = fully random, low values nudge the current look). Non-numeric controls (toggles, menus) are left untouched, so it is always safe to fire. Pair with manage_presets/manage_cue to snapshot a happy accident.

Build an editable RayTK ROP expression graph from a preset or explicit nodes/edges: copy RayTK masters live via pathsByOpType/category search, wire typed connectors, apply simple parameter values, lay out copied nodes deterministically, and expose the selected output through out1. Complements create_raytk_scene (minimal scene) and create_raytk_op (single ROP). Requires RayTK staged and loaded; offline tests validate payload/registration only, while live render/cook proof remains explicit.

Read-only: for each parameter of a node, report its mode (CONSTANT / EXPRESSION / EXPORT / BIND), its evaluated value, and its raw expression / bind-expression / export-source strings. Use this to faithfully serialize a network for round-trip editing, diffing, or debugging — the evaluated value alone hides which parameters are driven by expressions or exports. Set non_default_only to surface only the parameters that would be lost in a plain value copy.

Reconstruct a live network inside a COMP from a serialize_network spec — the REBUILD half of a git-diffable round-trip. Takes a JSON spec of nodes (name, operator type, parameters as constants/expressions/binds, inbound wires by name, optional x/y) and, in one pass, creates every node, applies its parameters and expressions, then wires inputs by resolving each from reference to the freshly created node. Caller expression/bind source requires TDMCP_RAW_PYTHON=on; constant-only specs remain allowed by the MCP caller-code policy. This tool's one-pass reconstruction still uses /api/exec, so every mode requires TDMCP_BRIDGE_ALLOW_EXEC=1. Fail-forward: an unknown operator type, missing parameter, or unresolved wire becomes a warning and the rest still build, so a partial reconstruction still returns useful results. Set clear_existing to delete the parent's current children first (destructive). Set auto_layout to auto-position every node by dependency (longest-path columns, left→right) from the spec's inputs graph, overriding any manual x/y. Returns the created node names, wire count, parameters set, and any warnings.

Read-only vault search: rank past memory notes by similarity to a new visual goal so the agent can reuse prior recipes, params, and prompts instead of rebuilding from scratch. Scores by query-token overlap with title/intent/prompt/tags/body, with optional tag and op boosts. Returns ranked hits with vault paths, score, matched terms, and an optional body snippet. Offline; requires TDMCP_VAULT_PATH.

Record a TOP to a movie file (.mov/.mp4) via a Movie File Out TOP — for exporting a clip or a loop, where render_output only saves a single frame. start begins recording (pass file, fps); pass seconds to auto-stop after a fixed length, or call stop to finish (stop also cleans up the recorder node). The file is written by TouchDesigner on the TD machine. For individual numbered frames, use render_output per frame.

Capture fresh preview PNG assets from one or more live TOP nodes and write each target to its file_path. Use it to regenerate stale thumbnails after a network changes; pass targets as {node_path,file_path} plus optional width/height. Requires a running TouchDesigner bridge, overwrites image files, and returns written previews plus per-target warnings.

Hot-reload the bridge's Python inside the running TouchDesigner, so edits to the td/ modules take effect without reopening the project. Reimports every loaded mcp./utils. module in place and returns the list reloaded. Use after editing bridge code.

Save a TOP to an image file at its native, full resolution (PNG/JPG/EXR/TIFF by extension) — for exporting a finished frame, unlike get_preview which only transfers a small inline thumbnail. The file is written by TouchDesigner on the TD machine; pass an absolute path.

Bounded, autonomous repair: scan cook errors under a subtree, classify each, and plan a safe fix, capped at max_steps so it can never run away. Defaults to dry_run (PLAN only, no changes). Set dry_run:false to apply the known-safe fixes — resetting a broken parameter expression to constant mode, and re-enabling a bypassed/display-off op — within the same bound; risky cases (DAT syntax errors, missing inputs, unclassified errors) are always PLAN-only. Re-checks errors after applying and stops at the bound or when errors clear. Returns {parent_path, dry_run, max_steps, errors_before, errors_after, steps[], remaining[], warnings, rolled_back}. Use it as the diagnostic 'try the obvious safe fixes' loop after a build; for raw triage use summarize_td_errors / get_td_node_errors instead.

Create an OSC control chain for driving Resolume, VDMX, or both from TouchDesigner. It builds target-specific OSC Out lanes with layer opacity, crossfader, speed, clip trigger, and blackout channels; use it beside video/NDI/Syphon output tools when an external VJ app handles playback or final compositing.

Replay a MacroRecord JSON file by dispatching each entry through the in-process tool handlers. Use dryRun to plan without invoking, stopOnError to halt on first failure, argsOverrides to shallow-merge per-tool arg replacements, and allowRawPython to opt-in to raw-Python entries (still subject to the server-side ctx gate). Redacted args from a recording may fail at the tool boundary; do not un-redact.

Save a live TouchDesigner COMP as a reusable .tox component file inside the Obsidian vault (at /.tox) and write a companion markdown note with frontmatter, a description, and load instructions — completing the build→parameterize→script→package-to-library loop. The saved .tox can later be loaded back with manage_component (load action). Requires a configured TDMCP_VAULT_PATH. The target COMP must exist and be a COMP (not a non-COMP operator).

Capture an existing COMP's network (child nodes, non-default parameters, wiring, and text/script DAT bodies) by reading TD, then WRITE it as a reusable recipe note in the Obsidian vault at Recipes/.md; list_recipes/apply_recipe then see it alongside the built-in recipes. Use this to turn a patch you already built into a template — to instantiate a template instead, use apply_recipe. Refuses to overwrite an existing note unless overwrite:true. Returns the note path, recipe id, and node/connection counts. Requires a configured TDMCP_VAULT_PATH.

Save the current TouchDesigner project or Save As to an explicit path. Existing Save As targets require bounded native overwrite consent and fail closed to Keep on timeout, close, error, or unavailable UI. Never opens a native file dialog, loads/quits a project, or falls back to raw Python. Returns the requested/final path, verified save state, decision and project/build metadata.

Give a COMP a Python extension class: create a Text DAT holding the class (with optional method stubs), wire it into an extension slot, optionally promote it (so members are callable directly on the COMP), and reinitialize. The other half of making a generated network reusable — pair with add_custom_parameters (knobs) and manage_component (save as .tox).

Create a genre-flavored starting network under parent_path — beyond scaffold_show's blank skeleton. Picks a tempo, look, and palette per genre: 'techno' (fast ~130 BPM clock + a hard strobe-y feedback look + dark palette), 'ambient' (slow ~70 BPM + a soft blurred-feedback look + warm palette), or 'installation' (no clock + a slow generative noise look + muted palette). Each builds a 'master' output Null and a genre look already wired into it, and (when a tempo applies) writes the project's global tempo (op('/').time.tempo). Use scaffold_show instead for an empty skeleton with no look or palette. Returns the container path, the master/tempo/look node paths, the BPM written, and the palette. Then add scenes, a layer mixer into master, cues, and a control surface.

Inverse of apply_recipe: walk a COMP's child network in TouchDesigner and serialize it back to a draft RecipeSchema JSON (nodes + non-default parameters + connections + cross-references). Validates against RecipeSchema before returning. When write_path is set, writes pretty JSON to that vault-relative path; otherwise returns the recipe in structuredContent. Read-only with respect to TD — no operators are created or modified.

Write a minimal but valid recipe JSON template to disk as a starting point for a new recipe. Use it to bootstrap a hand-authored recipe that already passes RecipeSchema; fill in nodes/connections, then instantiate with apply_recipe. Writes a file (destructive).

Create a starting skeleton for a live show: a new container under parent_path with a 'master' output Null (where your mix lands) and a 'tempo' beat clock for reactivity, but NO scenes or look. Use scaffold_genre instead when you want a genre-flavored start (tempo + a ready-made look + palette already wired in). Returns the container path plus the 'master' and 'tempo' node paths. A blank-canvas starting point — then add scenes, audio features, a layer mixer into master, cues and a control surface.

Meta DX tool: scaffolds a new tdmcp tool file (xSchema + xImpl + registerX) and a matching offline msw unit test from a one-line idea. Returns the exact integration-hint (import line + array entry + layer index path) so the integrator can wire it without re-deciding shape. No TouchDesigner bridge call — pure local filesystem generator.

Populate the configured Obsidian vault with a starter layout and worked examples (a README plus example recipe, setlist, shader, and moodboard notes) so you begin from a working vault instead of an empty folder. WRITES Markdown files into the vault root and its subfolders; existing files are skipped unless overwrite:true. Run this once when first setting up a vault, before save_recipe_to_vault/import_setlist/etc. Returns the vault root path and the lists of files created vs skipped. Requires a configured TDMCP_VAULT_PATH.

Compose a complete, playable VJ deck UI in one call: it builds a DJ-style A/B deck mixer (create_decks) with a crossfader, adds an on-screen fader control surface (create_control_surface) with crossfade + per-deck gain faders, and creates a midiinCHOP control surface (create_external_io) whose channels are bound to the same crossfader/gain parameters for hands-on MIDI control. Pass deck_a/deck_b source TOP paths (or omit for test sources), and an optional midi_map of channel→control bindings (defaults to ch1c1→crossfader, ch1c2→gain_a, ch1c3→gain_b). This is the deck-scaffold layer on top of the create_decks primitive — it wires the existing deck, surface, and I/O tools into one UI container.

Read-only: score a built network 0–100 on a fixed rubric (palette/motion/complexity/errors/perf) and return per-criterion sub-scores plus deterministic improvement suggestions. Optional LLM critique when llmCritique=true and ctx.llm is configured. Composes existing bridge endpoints — creates nothing.

Search the embedded operator knowledge base (629 operators) by keyword, exact name, tag/keyword, category, subcategory, parameter metadata, or TouchDesigner version compatibility — ranked by relevance, fully offline by default. Use it to discover the right operator before creating nodes instead of guessing a type (e.g. 'what sends DMX?', 'particle', 'corner pin'). Returns name, family, summary, facets and optional matching parameters. Pass semantic:true to re-rank fuzzy candidates by embedding similarity (needs an LLM endpoint; falls back to keyword). With parameter_search, matched Menu parameters include their menu options; results are stamped with a data_version (which TouchDesigner build the offline catalog reflects) and a stale_hint when the connected TD is on a different major. Token economy: use a specific query and a small limit; one focused search beats several broad ones.

Read-only: search TouchDesigner Python API classes, methods and members from the embedded offline knowledge base. Supports class category filters and conservative stable-version compatibility filtering where compatibility metadata exists.

Read-only: bounded BM25-style lexical search across authored DAT text and parameter expressions in the live TouchDesigner project. Returns short redacted excerpts with exact operator, source field, line, column, ranking provenance, and truthful completeness metadata. Works with TDMCP_BRIDGE_ALLOW_EXEC=0; never falls back to raw Python, exports whole DATs, or requires an embedding service.

Read-only: search the embedded TouchDesigner knowledge router across operators, operator workflows, examples, versions, compatibility notes, technique packs, TD classes, and experimental build notes. Returns normalized results with resource URIs and tool hints for deeper lookups.

Read-only: serialize a COMP's immediate children into a git-diffable JSON spec — each node's name, op type, parameters (with mode + expression, not just the evaluated value), input wires by source node name, and position — plus best-effort custom-parameter definitions. This is the serialize half of a round-trip pair: feed the output spec to rebuild_network to reconstruct the subtree. Use it to snapshot a network as text you can diff across edits or commit to version control. Returns {root, nodes[], truncated?, warnings[]}.

Overwrite a Text or Table DAT's entire .text with new content. Unlike edit_dat_content (which makes a surgical find-and-replace), this replaces everything in one shot — use it to deploy a full script or template. Refuses to write empty/whitespace-only text unless confirm_wipe:true is passed, preventing silent data loss. Because DAT text can become executable callbacks, this tool is hidden when TDMCP_RAW_PYTHON=off and the bridge also requires TDMCP_BRIDGE_ALLOW_EXEC=1 for text writes.

Set one or more parameters on a node using five modes: 'expression' (par.expr = ...), 'bind' (par.bindExpr = ...), 'constant' (par.val = ...), 'reset' (restore the parameter default), and 'unbind' (freeze the current evaluated value as a constant). Caller-supplied expression/bind text requires TDMCP_RAW_PYTHON=on and TDMCP_BRIDGE_ALLOW_EXEC=1. In restricted mode, constant/reset/unbind use the structured endpoint and remain available on a current bridge. Multiple assignments are applied fail-forward — per-item failures accumulate as warnings so a partial batch still returns useful results.

Update parameters on multiple nodes in a single batch request. Each update reports its own success; a failure does not roll back the others.

Toggle perform mode — the one switch the artist flips before going live. When enabled, tdmcp stores an advisory flag that tools can read before doing nonessential compute; the built-in guard currently suppresses auto preview captures. The flag is stored on the TD root op (op('/').store('tdmcp_perform_mode', ...)). Advisory: this does not stop the TD timeline or kill audio/video processing. Call with enabled=false after the show to resume normal operation.

One-shot body tracking from a webcam: loads the free mediapipe-touchdesigner ENGINE (install it first with tdmcp install mediapipe-touchdesigner) into your project, starts the timeline (the engine captures the webcam through an embedded browser that only runs while playing), reads its pose JSON DAT through an adapter that emits a 33-landmark pose CHOP, and builds a live skeleton so you only need to pick your webcam and enable Pose. If the engine isn't installed yet, it tells you how. Loading the engine will prompt for camera permission on macOS (click Allow).

One-shot face-landmark tracking from a webcam: loads the MediaPipe ENGINE (install first with tdmcp install mediapipe-touchdesigner), starts the timeline, and builds an adapter Script CHOP that emits a 468-sample (or 478 with iris) face-landmark CHOP (tx/ty/tz/confidence, centred on nose tip). Feeds directly into bind_to_channel and create_data_visualization.

One-shot MediaPipe hand tracking from a webcam: loads the mediapipe-touchdesigner ENGINE (install with tdmcp install mediapipe-touchdesigner), starts the timeline, locates the engine's hand JSON DAT, and builds an adapter Script CHOP that converts the hand JSON into a canonical max_hands×21-landmark CHOP (channels: tx/ty/tz/confidence/handedness). Use coordinate_space='world' for gesture detection (3D, curled fingers separate in z). The output CHOP at <parent_path>/<adapter_name>/hand is ready for bind_to_channel or create_pose_skeleton. Shares the same engine as setup_body_tracking — both can run in the same project.

Drop the torinmb mediapipe-touchdesigner ENGINE in one shot and enable any combination of face, hand, body, and segmentation pipelines. Use this instead of running setup_face_tracking + setup_hand_tracking + setup_body_tracking + setup_segmentation separately — those tools each re-load the engine, resulting in multiple competing MediaPipe COMPs fighting for the webcam. This tool loads the engine ONCE and toggles its Face/Hand/Body/Segmentation pars. IMPORTANT: there is NO stock TouchDesigner MediaPipe; all five mediapipe tools (this one + the four setup_*_tracking tools) rely on the free torinmb plugin — install it first with tdmcp install mediapipe-touchdesigner. Output paths for face/hand/body are DATs (JSON landmark streams from the plugin), not CHOPs — use a Script CHOP adapter to convert to numeric channels. The engine requires the TD timeline to be PLAYING (uses an embedded browser for webcam capture).

Route a finished TOP to an output destination: a display window, NDI stream, Syphon/Spout, a recording, or Touch Out. Creates the matching output node ('<output_type>out') under parent_path; for a window it points the Window COMP's winop at the source and sets its size, and for the other types it bridges the source in through a Select TOP (TD wires can't cross COMP boundaries). Typically the LAST step after building a visual — feed it the output Null from a create* tool or a create_layer_mixer. Returns the created output node path, the output type, the source path, and any non-fatal warnings (e.g. if wiring or window config failed).

One-shot selfie segmentation via the MediaPipe TouchDesigner engine (install with tdmcp install mediapipe-touchdesigner). Loads the engine, enables Selfie Segmentation, and builds an adapter COMP with a clean alpha-mask Null TOP (optionally inverted and/or feathered) plus an optional pre-keyed RGBA Null TOP (person on transparent). Wire the mask into create_keyer, create_depth_silhouette, or any matte-consuming tool. The engine reuses an existing MediaPipe op if already loaded (idempotent). Keep the TD timeline PLAYING so the embedded browser captures the webcam; click Allow if macOS prompts for camera permission.

Wire up an Ableton Live bridge inside a tdmcp-managed container. Auto mode probes for the official TDAbleton Palette COMP; if found, clones it and surfaces tempo/beat/track/device channels as binding-ready Null CHOPs. Falls back to a full OSC fabric (oscinCHOP + selectCHOP fan-out) if the Palette isn't available. Either branch exposes the same Null CHOP names at the container boundary so downstream bind_to_channel calls work regardless of which path was taken.

Read-only pre-show check: bridge reachability, node errors, topology, cook-time budget, GPU/display topology and perform-mode status in one PASS/UNVERIFIED/WARN/FAIL report. Use before rehearsals or venue handoff to see what is safe, unverified, suspicious, or failing without mutating the project.

Read-only: capture a compact, serializable snapshot of a network — nodes, connections, structural issues, and optionally each node's parameters — for review, diffing, or documentation. Returns {nodeCount, connectionCount, issues[], nodes[], connections[]}. Set compact for a token-cheap whole-COMP read that hoists per-type default parameters and stores only each node's deltas. Feed two of these snapshots to diff_snapshots to see exactly what changed across an edit.

READ or UPDATE the long-lived Memory/style.md note in the configured Obsidian vault — the artist's standing preferences across sessions (palettes, default energy, banned moves, favourite generators, naming/layout conventions, tags). mode='show' returns a compact one-line context string suitable for feeding an LLM, 'read' returns the full structured note, 'update' field-wise merges a patch (lists union+dedup, scalars overwrite) and bumps the updated date. Touches the vault only — no TouchDesigner side effects. Requires TDMCP_VAULT_PATH.

Read-only: suggest a small ordered TouchDesigner operator chain for a creative or technical goal from offline operator docs and workflow patterns. Returns connection hints and next tool hints; it does not create nodes.

Read-only: collect errors and warnings across a network and cluster them by message, severity type, or parent container, with the nodes that have the most diagnostics and a suggested order to investigate. Returns {total, error_count, warning_count, groups[], suggestions[]}; each group sample retains its error/warning severity. Use this for network-wide triage instead of reading every node's diagnostics one by one; use get_td_node_errors when you want the raw list for one node or sub-tree.

Change an operator's TYPE while preserving its name, position, incoming + outgoing wires, and any parameters that exist on the new type. Snapshots wires + params, deletes the old node, creates a new node of new_type at the same parent/name/x/y, re-applies matching params (others go into dropped_parameters), and rewires connectors. Fail-forward: per-wire / per-param failures are reported as failed_inputs[] / failed_outputs[] / dropped_parameters[] rather than aborting. Returns {old_type, new_path, preserved_parameters, dropped_parameters, reconnected_inputs, reconnected_outputs, failed_inputs, failed_outputs, warnings}.

Lock the project tempo to a live source so beat-synced visuals follow the music. mode picks the source: 'tap' (default) gives a Bpm knob + Tap pulse you dial/tap by ear; 'ableton_link' locks to an Ableton Link session on the network; 'midi_clock' derives BPM from incoming MIDI timing-clock (24 PPQN). All modes write the global tempo (op('/').time.tempo), so create_tempo_sync clocks and create_autopilot follow. The Link/MIDI modes are hardware-gated — without that source present the manual Bpm knob still drives the clock.

Bridge a COMP's manage_presets snapshots with the Obsidian vault. With action 'export' it READS TD storage and WRITES a Markdown note (diffable, shareable) under Presets/; with action 'import' it READS that note and WRITES the presets back into TD storage (merging by name). Returns the note path plus the affected preset names. Use this to version-control or share presets across machines; use manage_presets to capture/recall them live. Requires a configured TDMCP_VAULT_PATH.

Wire an external SMPTE/MTC/LTC/OSC timecode source into the TouchDesigner timeline. Creates the input op + Math CHOP normaliser + Null CHOP 'tc_out' (channels 'frame' and 'seconds'); optionally adds an Execute DAT that writes project.frame = tc_out['frame'] each cook so the timeline follows house clock. Requires the project to be playing — paused TD will not advance. LTC has no native TD decoder; the tool surfaces a warning and creates the audio input so the artist can attach an external decoder. MTC operator availability is build-dependent.

Faceted browse + tag editing over a vault library (Recipes/ + Components/ markdown notes). op='list' enumerates every asset and its tags; op='search' filters by free-text query and/or tags_any/tags_all set logic; op='tag' edits one asset's frontmatter tags (union or replace, always preserving '*'-pinned user tags); op='filter' returns assets matching a license_tier bucket (and optional SPDX license id). Pure vault I/O — no TouchDesigner bridge required. Requires TDMCP_VAULT_PATH.

Build a teaching/selling companion for a network: snapshot the COMP's topology, capture preview PNGs of its output TOPs, scaffold an N-step lesson plan in Markdown, and emit a documentary network snapshot. Writes into <vault>/<folder>/<slug>/ as tutorial.md + topology.json + network_snapshot.json + previews/*.png. The snapshot captures nodes + connections by TD path for reference only — it is not a RecipeSchema-compatible installable recipe. Composes existing read-only bridge calls — the artist edits the lesson body afterwards. Requires TDMCP_VAULT_PATH and a running TouchDesigner bridge.

Modify an existing node by setting one or more of its parameters to constant values. The update is strict (not best-effort): an unknown parameter name fails the whole call atomically without changing anything, and a bad value (wrong type or out of range) returns an error naming which parameters applied and which failed. On success returns the updated {node}. To inspect valid parameter names/current values first use get_td_node_parameters; to make a parameter move over time use animate_parameter instead of a static value.

Check that a local library asset exists and is referenced by an optional manifest. The default static mode preserves the cheap filesystem check. Opt-in deep_roundtrip validates an absolute .tox in an authenticated disposable quarantine bridge on a non-9980 port, using a structured loadTox-only job with bounded polling and verified scratch cleanup; offline evidence is UNVERIFIED, never PASS.

Read-only: validate an ordered TouchDesigner operator chain against embedded operator docs, documented connections, family/category filters, and optional TouchDesigner version compatibility. It does not create or modify TD nodes.

Generate N perturbed variants around an anchor parameter look and write the whole pack to the Obsidian vault as a morph_pack-compatible JSON. Probes the target COMP's customPars for slider ranges to clamp + integer-round per param, then perturbs each variant uniformly within ±delta_range × (normMax − normMin). The resulting file is consumed directly by morph_pack (action=unpack). Requires TDMCP_VAULT_PATH.

Read-mostly git wrapper for the configured Obsidian vault directory. Lets an artist see what's changed (status), fetch/fast-forward-only pull, push, or read recent history (log). Never auto-resolves conflicts. Never uses --force. Never invokes a shell. Conflicts are surfaced as structured data for manual resolution. Requires TDMCP_VAULT_PATH or the vault_path argument.

Apply a SemVer patch/minor/major bump to a vault recipe or component note, recording the change in a sidecar <asset>.versions.json (asset_path + current + history list with version/bump/note/timestamp) and writing the new version into the note's frontmatter version field. Pass read_only:true to inspect the sidecar without bumping. Pure vault I/O — no TouchDesigner bridge required. Requires TDMCP_VAULT_PATH.

Read-only: sample one TouchDesigner operator over a short interval and return runtime state, readable parameter values, and CHOP channel values when available. Missing TD attributes/channels are reported as warnings instead of failing the watch. Returns {path, requested_samples, collected_samples, interval_ms, window_ms, warnings[], snapshots[]} where each snapshot has {sample_index, elapsed_ms, path, type, family, state, parameters, channels, warnings}.

Opt-in: subscribe to param.changed events for an operator's parameters. When a watched parameter's value changes in TouchDesigner (by a human or a script), the bridge broadcasts a {path, par, prev, value, frame} event on the TD event stream, forwarded to the MCP client as a logging notification. Use action='watch' to register (optionally scoped to named parameters), 'unwatch' to remove, and 'list' to see active watches. Events only arrive when the server's TD event stream is enabled (TDMCP_EVENTS); param.changed is treated as a high-frequency event (coalesced bridge-side so a slider drag can't flood). Survives TDMCP_BRIDGE_ALLOW_EXEC=0.

Emit a project-local CLAUDE.md / AGENTS.md seeded with tdmcp operator conventions and TouchDesigner render-coordinate rules, so a future agent working on this project starts with the right mental model. A small dynamic header (project name, node count, top families) is prepended to a curated static body. Pass output_dir to also write the file to disk on the machine running TouchDesigner. The guide is always returned in the structured result.