Real Workflows. Real Production.

Batch-publish multiple assets to Prism Pipeline in a single execution: iterate over an asset name list, validate each entry, create versioned Prism products, and return published vs failed counts.

Create a Houdini geo container, clear defaults, wire a Box SOP into a PolyExtrude SOP, set all parameters, and cook the network — entirely over the live JSON-RPC bridge.

Send a prompt to a Gemini LLM endpoint with configurable system instruction, temperature, and max tokens. Returns generated text, token count, and a success flag.

Async HTTP GET or POST with configurable URL, method, headers (JSON string), and body. Returns parsed response data, status code, raw text, and a success flag.

Execute a parameterized SQL query against a SQLite database. Returns rows as a list of dicts, row count, and column names. Handles connection lifecycle automatically.

Send email via SMTP with TLS. Configurable host, port, credentials, sender, recipient, subject, and body. Returns sent status and error message if delivery fails.

Scan a folder for files matching a glob pattern (optionally recursive). Returns a list of matched file paths and the total file count for downstream batch processing.

Watch a folder for new files matching a pattern over a configurable time window. Returns a list of newly appeared files — useful as a trigger step in automated pipelines.

Resize an image to target dimensions using Pillow. Supports aspect-ratio preservation and multiple resample filters (LANCZOS, BILINEAR, etc.). Outputs the saved path and final dimensions.

Apply a regex substitution to a text input with optional case-insensitive matching. Returns the transformed result string and the number of substitutions made.

Minimal node JSON schema: adds two numbers and outputs the result. The simplest complete node definition — ideal as a template for building your first custom node.

Node schema demonstrating async execution: awaits N seconds then passes data through. Shows how to define an async node that does not block the event loop.

Parse a raw JSON string into a Python dict or list. Demonstrates error handling in node execute() — uses log_error when the input is not valid JSON.

Demonstrates the dropdown widget type: a node input with a predefined options list rendered as a select menu in the UI. No exec flow — pure data-out node.

Compare two values and output both a greater-than boolean and an equal boolean. Shows how to define multiple boolean outputs for conditional branching downstream.

Demonstrates on_plug_sync lifecycle hooks: when a wire is connected, the node sets an "auto_prefix" parameter automatically. Shows the plug/unplug event system.

Walk a directory tree for image files (.png, .jpg, .exr, etc.) with optional recursion. Returns sorted path list and count. Demonstrates bool widget and list output.

Split an input string by a delimiter and output the resulting list. A one-input, one-output node demonstrating the simplest list-producing schema pattern.

A data-only node (use_exec=False) that squares an input number. Demonstrates set_output(), log_info(), and icon_path — the minimal data-flow node pattern.

Demonstrates on_plug_sync and on_unplug_sync lifecycle hooks. Logs a message each time a wire is connected or disconnected, showing the plug/unplug event system.

A use_exec=False node with a dropdown widget: options list is defined in add_input(). Demonstrates how to build UI select menus in Python BaseNode subclasses.

Uses on_plug_sync to inspect the connected list and populate a dropdown with its items via set_parameter(). Shows how wiring a port can drive dynamic UI updates.

When a wire is connected to trigger, on_plug_sync() sets the auto_prefix parameter, which downstream nodes immediately see. The canonical reactive propagation pattern.

Demonstrates state management via lifecycle hooks: on_plug_sync() "unlocks" the node, on_unplug_sync() re-locks it. Models a safety interlock pattern.

Filter a list by substring pattern matching. Demonstrates list iteration inside execute(), log_info() for counts, and returning both filtered results and the count.

Compares a value against a threshold and outputs both a boolean (above/below) and the numerical difference. Shows how to return multiple typed outputs from execute().

Reads an environment variable by name via os.environ.get(). Returns the value and a boolean indicating whether it was set. Simple example of system integration.

Merge two dict inputs with Python dict.update(). The second dict's keys override the first on collision. Demonstrates dict type ports and dict output.

Scripting Console script that calls scene.clear(), adds four message nodes with scene.add_node_by_name(), and wires them in sequence with scene.connect_nodes(). The hello-world script.

Iterates scene.nodes, checks node_definition.node_id, and calls node.set_parameter() to bulk-update a prefix on all matching nodes. Useful for path remapping across large graphs.

Uses scene.find_node_by_name() to locate a target node, calls set_parameter() to inject a value, then calls app.execute_pipeline() to run the full graph programmatically.

Uses the git global to check repository status and commit all .vnw files. Demonstrates the git.status() and git.commit() scripting console APIs for workflow version control.

Generates an N×N grid of message nodes programmatically with scene.add_node_by_name() in a nested loop, then calls app.execute_pipeline() to benchmark async execution at scale.

Iterates scene.nodes, counts node types, inspects scene.connections, and queries registry.list_nodes() to print a full summary of the current graph state.

Iterates all nodes in the scene, filters those whose node_id contains "math", and resets their "a" parameter to 0. Demonstrates selective parameter manipulation by node type.

Iterates all nodes, inspects node_definition.parameter_types for bool entries, and sets each to True. Demonstrates how to read parameter type metadata from node definitions.

Reads scene.__class__.__name__, counts scene.nodes by type, tallies scene.connections, and prints a structured session report using registry introspection.

Creates an add_integers node, sets parameters "a" and "b" via set_parameter(), adds a console_print node, and wires the result port to it with scene.connect_nodes().

Clears the current scene, adds a single message_node, and sets its msg parameter to a welcome string. The canonical "clean slate" script pattern.

Full Maya-to-Prism asset publish: open a Maya scene via headless subprocess, export Alembic cache, create a Prism product version, submit a Deadline render job, and log the job ID.

Read a CSV shot list, open each Maya scene headlessly, set the correct frame range from shot metadata, export per-shot Alembic caches, and collect all output paths.

Load shot data from Prism, configure render settings per shot, submit Mantra/Arnold jobs to Deadline with correct frame ranges, and collect all job IDs for monitoring.

Build a complete Houdini FX network procedurally via the live bridge: create geo containers, wire solver SOPs, set simulation parameters, cook, and save the .hip for review.

Open a Blender scene headlessly, export the same asset in FBX, GLTF, OBJ, and USD formats in one automated run, and report all output paths on completion.

Query a Prism project for all shots and assets, get the latest published version of each, compare against minimum version requirements, and generate a pipeline health report.

Canonical ForEach usage: pass a list into ForEach, process each item through a sub-chain, collect results with Collect node, and output the aggregated list.

Route execution through one of two branches based on a boolean condition. The canonical conditional pattern in Vibrante-Node exec-flow graphs.

Run a loop until a condition is met or a max iteration count is reached. Demonstrates WhileLoop with BreakLoop and continue/stop exec pins.

Use SetVariable and GetVariable to share state between branches in an If/Else workflow — a realistic pattern for pipeline decision logic that needs cross-branch data.

Wire multiple exec-flow nodes in strict sequence using exec pins to guarantee ordered execution — the foundation of any linear pipeline step.

Full tutorial workflow: open Maya headlessly via action list, export geometry, push the result through Prism version creation, and verify the published path exists.

Poll an external API or file until a success condition is met, with configurable max retries and delay — a production-ready retry pattern for resilient pipelines.

Route a single data input to one of two outputs based on a boolean switch. Cleaner than If/Else for data-only routing decisions without exec-flow overhead.

Iteratively concatenate strings in a loop, building up a result string across multiple iterations. Demonstrates while loop + variable accumulation pattern.

Demonstrates using the built-in Python Script node inside a workflow: write arbitrary Python inline, access inputs dict, and return results to downstream nodes.