Deadline Render Farm Integration

Thinkbox Deadline is the industry-standard distributed render farm management system used in VFX, animation, and game production studios. Vibrante-Node integrates with Deadline through both its REST API (Deadline Web Service) and command-line tools (deadlinecommand), providing nodes for job submission, status polling, output verification, and job management — all composable into larger automation graphs that chain DCC operations directly into farm submission.

The typical usage pattern is to build and prepare a scene using Maya Headless or Blender Headless nodes, then hand off to Deadline nodes for distributed rendering, optionally followed by Prism Pipeline nodes that publish the completed renders to the version database.

---

How It Works

Architecture Diagram

Vibrante-Node Graph                         Deadline
───────────────────                         ─────────
maya_action_* chain           deadline_submit_job ──► REST API
                                                   or deadlinecommand
blender_action_* chain        deadline_get_status ──► Job status poll
                              deadline_wait_complete─► poll until done
      │
      └─ builds job payload (plugin, scene, output, frames)

Submission Methods

Vibrante-Node supports two Deadline submission mechanisms, selectable via the submission_method parameter on deadline_submit_job:

Method	Environment Variable	Notes
REST API (recommended)	DEADLINE_WEBSERVICE_URL	No Deadline client required on the submitting machine. Requires Deadline Web Service to be running on the farm.
deadlinecommand	DEADLINE_COMMAND_PATH	Uses the Deadline client command-line tool. Requires Deadline client installed on the submitting machine.

Async Polling — deadline_wait_complete

The deadline_wait_complete node uses asyncio.sleep() between status polls. Because Vibrante-Node runs its execution engine on an asyncio event loop shared with Qt via qasync, this polling is fully non-blocking — the UI remains responsive, the log panel continues updating, and the Stop button works immediately. The node calls is_stopped() before each poll iteration so pressing Stop in the toolbar cleanly cancels the wait.

---

Configuration

Configure the following environment variables in Edit → Preferences… → Environment Variables:

Variable	Example	Description
DEADLINE_WEBSERVICE_URL	http://deadline-server:8082	URL of the Deadline Web Service REST API endpoint. Required for REST API submission.
DEADLINE_COMMAND_PATH	C:/Deadline10/bin/deadlinecommand.exe	Full path to the deadlinecommand executable. Required for CLI submission.
DEADLINE_POLL_INTERVAL	15	Seconds between status polls in deadline_wait_complete. Default: 15.
DEADLINE_DEFAULT_POOL	render_farm	Default pool used by deadline_submit_job when no pool is specified.
DEADLINE_DEFAULT_PRIORITY	50	Default job priority (0–100). Default: 50.

---

Node Library

All Deadline nodes are in the Pipeline category.

Node ID	Inputs	Outputs	Description
deadline_submit_job	job_name, plugin, scene_file, output_dir, start_frame, end_frame, chunk_size, priority, pool, group, machine_limit, renderer, camera	job_id, submission_result	Submit a new render job to Deadline. Outputs the assigned job_id for use by status nodes.
deadline_get_status	job_id	status, progress, failed_tasks	Query the current status of a job (Active, Suspended, Completed, Failed, etc.).
deadline_wait_complete	job_id, timeout_minutes	status, success	Poll until the job reaches a terminal state (Completed or Failed). Non-blocking async poll. Respects Stop button.
deadline_cancel_job	job_id	success	Cancel a queued or running job.
deadline_get_output_paths	job_id	paths, frame_count	Retrieve the list of output file paths after job completion.
deadline_get_job_info	job_id	job_info (dict)	Get full job metadata including plugin, priority, pool, timing, and task breakdown.
deadline_list_jobs	pool, group, status, limit	jobs (list)	List jobs filtered by pool, group, or status. Useful for building monitoring graphs.
deadline_set_job_priority	job_id, priority	success	Update the priority of a queued job without resubmitting.

---

Job Payload Reference

When submitting a job via deadline_submit_job, the node constructs the following payload structure internally from its input parameters. This reference is useful when building custom submission nodes or scripting submissions:

{
    "type": "submit",
    "job_name":   "Shot_010_Beauty_Render",
    "plugin":     "MayaBatch",       # MayaBatch, Blender, Arnold, VRay, Mantra, etc.
    "scene_file": "/projects/shot_010.ma",
    "output_dir": "/renders/shot_010/beauty/",
    "renderer":   "arnold",
    "camera":     "renderCam",
    "start_frame": 1001,
    "end_frame":   1100,
    "chunk_size":  10,               # frames per task
    "priority":    50,               # 0 (lowest) – 100 (highest)
    "pool":        "render_farm",
    "group":       "maya_renders",
    "machine_limit": 0               # 0 = unlimited machines
}

Supported Deadline Plugins

Plugin Name	DCC Application	Renderer
MayaBatch	Autodesk Maya	Arnold, V-Ray, Renderman, Software
Blender	Blender	Cycles, EEVEE
Houdini	SideFX Houdini	Karma, Mantra, Redshift
Arnold	Arnold Standalone (kick)	Arnold
VRaySpawner	V-Ray Standalone	V-Ray
CommandLine	Any executable	Any
Python	Python script	Any

---

Complete Workflow Example

The following example builds a Maya scene via headless processing, submits it to Deadline, and waits for completion. Paste this into the Scripting Console.

scene.clear()

# Build the Maya scene
open_node = scene.add_node_by_name("maya_action_open_scene", (0, 0))
open_node.set_parameter("scene_path", "C:/projects/shot_010.ma")

headless_node = scene.add_node_by_name("maya_headless", (300, 0))

# Submit prepared scene to Deadline
submit_node = scene.add_node_by_name("deadline_submit_job", (600, 0))
submit_node.set_parameter("job_name",   "Shot_010_Beauty")
submit_node.set_parameter("plugin",     "MayaBatch")
submit_node.set_parameter("scene_file", "C:/projects/shot_010_prepped.ma")
submit_node.set_parameter("start_frame", 1001)
submit_node.set_parameter("end_frame",   1100)
submit_node.set_parameter("chunk_size",  5)
submit_node.set_parameter("priority",    60)
submit_node.set_parameter("pool",        "render_farm")

# Wait for the job to complete
wait_node = scene.add_node_by_name("deadline_wait_complete", (900, 0))
wait_node.set_parameter("timeout_minutes", 120)

# Get output paths after completion
output_node = scene.add_node_by_name("deadline_get_output_paths", (1200, 0))

# Exec chain
scene.connect_nodes(open_node,   "exec_out",  headless_node, "exec_in")
scene.connect_nodes(headless_node,"exec_out", submit_node,   "exec_in")
scene.connect_nodes(submit_node, "exec_out",  wait_node,     "exec_in")
scene.connect_nodes(wait_node,   "exec_out",  output_node,   "exec_in")

# Data chain
scene.connect_nodes(submit_node, "job_id", wait_node,   "job_id")
scene.connect_nodes(submit_node, "job_id", output_node, "job_id")

app.execute_pipeline()

---

Integration with Prism Pipeline

A common production pattern chains Deadline completion directly into Prism version publishing. After deadline_wait_complete confirms the render succeeded, deadline_get_output_paths retrieves the rendered file list, and prism_publish_version registers them in the Prism database:

# After Deadline job completes, publish renders to Prism
wait_node    = scene.add_node_by_name("deadline_wait_complete",   (0,   0))
output_node  = scene.add_node_by_name("deadline_get_output_paths",(300, 0))
publish_node = scene.add_node_by_name("prism_publish_version",    (600, 0))

publish_node.set_parameter("entity",  "shot_010")
publish_node.set_parameter("task",    "lighting")
publish_node.set_parameter("comment", "Auto-published after Deadline render")

# Exec chain
scene.connect_nodes(wait_node,   "exec_out", output_node,  "exec_in")
scene.connect_nodes(output_node, "exec_out", publish_node, "exec_in")

# Data chain
scene.connect_nodes(wait_node,   "job_id", output_node,  "job_id")
scene.connect_nodes(output_node, "paths",  publish_node, "file_paths")

This pattern creates a fully automated end-to-end pipeline: open scene → DCC headless operations → Deadline submission → farm render → automatic Prism publish. Every step is visible, reproducible, and modifiable without touching a single line of code.

---

Production Use Cases

Full Pipeline Automation

Combine all five integration pillars in a single graph: query shots from Prism → build Maya scenes headlessly → submit each shot to Deadline → wait for completion → publish renders back to Prism. This complete automation covers the entire rendering pipeline from task list to deliverable.

Multi-Shot Batch Dispatch

Use a loop or list-processing graph to iterate over all shots in a sequence, submitting each as a separate Deadline job with distinct output paths, frame ranges, and camera settings. The jobs run in parallel on the farm while Vibrante-Node monitors their individual statuses.

Farm-Aware Rendering

Use deadline_list_jobs to query current farm load before submission. If the farm is at capacity (many active jobs in the target pool), adjust the priority or pool of the new submission dynamically using a data pin from the list query results.

Output Verification

After deadline_wait_complete reports success, use deadline_get_output_paths to retrieve the expected output file list, then wire into a general-purpose filesystem node that checks each file exists on disk. If any frames are missing, submit a rerender job covering only the missing frame range.

Re-Render Workflows

Query a completed job using deadline_get_job_info to identify failed tasks, extract their frame numbers, and submit a targeted re-render job covering only those frames. This avoids re-rendering frames that completed successfully, saving significant farm time on large sequences.

---

Troubleshooting

Connection refused / REST API unreachable

Verify that the Deadline Web Service is running on your farm controller machine and that DEADLINE_WEBSERVICE_URL is set correctly. Test the endpoint directly in a browser: navigating to http://deadline-server:8082/api/jobs should return a JSON job list. If the service is not running, start it from the Deadline Monitor (Tools → Configure Web Service).

deadlinecommand not found

Set DEADLINE_COMMAND_PATH to the full path of the deadlinecommand executable (including the .exe extension on Windows). Do not rely on it being on the system PATH — Deadline does not add itself to PATH by default on all platforms.

Job submitted but never starts on farm

Check the pool and group names in your submission. If the pool specified in deadline_submit_job does not match any pool configured on the farm workers, Deadline will queue the job indefinitely with no available workers. Use deadline_list_jobs or the Deadline Monitor to verify the pool names.

deadline_wait_complete never finishes

Check the timeout_minutes parameter — it defaults to no timeout if not set. If the render is genuinely stalled (all tasks in Error state with no pending or active tasks), the node respects this and exits with status = "Failed" and success = False. Wire downstream error handling to the exec_out of deadline_wait_complete and check the success output port value.