Skip to content

rendering

rendering

MCP tool definitions for Houdini rendering operations.

Provides tools for viewport capture, render node management, render execution, and render progress monitoring.

Functions:

Name Description
create_render_node

Create a new render (ROP) node in /out.
get_render_progress

Progress of a render or write started with start_render.
get_render_settings

Get render settings from a ROP node.
list_render_nodes

List all render (ROP/Driver) nodes in the scene.
render_node_network

Capture a screenshot of a node's network editor view.
render_quad_view

Capture all four viewport panes to separate images.
render_sheet

Render frames start..end with the OpenGL ROP and tile them into one image.
render_viewport

Capture the current 3D viewport to an image file.
set_render_settings

Set render parameters on a ROP node.
start_render

Execute any node that renders or writes files.

Functions:

create_render_node async 

create_render_node(
    ctx: Context,
    renderer: str,
    name: str | None = None,
    camera: str | None = None,
    output_path: str | None = None,
) -> dict

Create a new render (ROP) node in /out.

Parameters:

Name Type Description Default
renderer
str

Renderer type ('karma', 'opengl', 'mantra', 'rop_geometry', 'rop_alembic', 'usdrender', 'fetch', 'merge', 'rop_fbx', 'rop_gltf').

 required
name
str | None

Node name.

 None
camera
str | None

Camera node path.

 None
output_path
str | None

Output file path.

 None

get_render_progress async 

get_render_progress(ctx: Context, node_path: str) -> dict

Progress of a render or write started with start_render.

Accepts every node start_render accepts (a LOP usdrender_rop or Karma LOP, a SOP ROP, a File Cache), not only /out ROPs. Reports the node's errors with license_error singled out, the output files on disk, and for a background render the process state and the tail of its log. done is true when there is nothing left to wait for.

Parameters:

Name Type Description Default
node_path
str

The node given to start_render.

 required

get_render_settings async 

get_render_settings(ctx: Context, node_path: str) -> dict

Get render settings from a ROP node.

Parameters:

Name Type Description Default
node_path
str

ROP node path.

 required

list_render_nodes async 

list_render_nodes(ctx: Context) -> dict

List all render (ROP/Driver) nodes in the scene.

render_node_network async 

render_node_network(
    ctx: Context, node_path: str, output_path: str | None = None
) -> dict

Capture a screenshot of a node's network editor view.

Parameters:

Name Type Description Default
node_path
str

Node path to focus on.

 required
output_path
str | None

Image file path. Default: a new PNG in the temp dir.

 None

render_quad_view async 

render_quad_view(
    ctx: Context,
    output_path: str | None = None,
    resolution: list[int] | None = None,
) -> dict

Capture all four viewport panes to separate images.

Parameters:

Name Type Description Default
output_path
str | None

Base image path; viewport names are appended. Default: a new PNG in the temp dir.

 None
resolution
list[int] | None

[width, height] in pixels.

 None

render_sheet async 

render_sheet(
    ctx: Context,
    start: int,
    end: int,
    step: int = 1,
    camera: str | None = None,
    resolution: list[int] | None = None,
    columns: int | None = None,
    output_path: str | None = None,
) -> dict

Render frames start..end with the OpenGL ROP and tile them into one image.

One image shows motion a single frame cannot: a sim's spread, a camera move. Needs no viewport, so it works in a headless session too. A snapshot of the scene as it is now (unsaved edits included, the session untouched) renders in a separate hython, since a second OpenGL render in one hython crashes on Houdini 22; that hython takes a license seat while it runs. Frames are labelled. Objects (/obj) only, not a LOP stage.

Parameters:

Name Type Description Default
start
int

First frame.

 required
end
int

Last frame.

 required
step
int

Frame step; at most 64 frames in all.

 1
camera
str | None

Camera object path. Default: the scene's only camera.

 None
resolution
list[int] | None

[width, height] of each tile. Default [320, 240].

 None
columns
int | None

Tiles per row. Default: about square.

 None
output_path
str | None

Sheet image path. Default: a new PNG in the temp dir.

 None

render_viewport async 

render_viewport(
    ctx: Context,
    output_path: str | None = None,
    resolution: list[int] | None = None,
    camera: str | None = None,
    settle_seconds: float = 0,
) -> dict

Capture the current 3D viewport to an image file.

Parameters:

Name Type Description Default
output_path
str | None

Image file path. Default: a new PNG in the temp dir.

 None
resolution
list[int] | None

[width, height] in pixels.

 None
camera
str | None

Camera node path.

 None
settle_seconds
float

Wait this long before capturing, without blocking Houdini, so a Karma viewport can converge after a change. Use this instead of a shell sleep between calls. Capped at 120.

 0

set_render_settings async 

set_render_settings(
    ctx: Context, node_path: str, settings: dict[str, Any] | None = None
) -> dict

Set render parameters on a ROP node.

Parameters:

Name Type Description Default
node_path
str

ROP node path.

 required
settings
dict[str, Any] | None

Parameter name-value pairs.

 None

start_render async 

start_render(
    ctx: Context,
    node_path: str,
    frame_range: list[float] | None = None,
    background: bool = False,
    overrides: dict[str, Any] | None = None,
) -> dict

Execute any node that renders or writes files.

Foreground by default: Houdini shows its own progress dialog and the user can cancel. The call holds until the render finishes, however long that is; a client that hands a long call to a background task notifies you with the verdict. Do nothing else in Houdini meanwhile and never poll the disk.

Not just /out ROPs: a LOP usdrender_rop (which is how Solaris renders), a SOP ROP Geometry, or a File Cache's Save to Disk all work, because what matters is whether the node can be executed rather than its category.

The result reports the output path it wrote to and whether anything is actually on disk there, so a render that succeeds and writes nowhere is visible instead of silent.

Parameters:

Name Type Description Default
node_path
str

Any node with a render() or an 'execute' button.

 required
frame_range
list[float] | None

[start, end] or [start, end, increment].

 None
background
bool

Render in a separate hython on the saved hip and return at once with status "launched"; get_render_progress reports the process, its log tail and the files. The user sees no progress in Houdini, so use it only when asked to keep working while a render runs.

 False
overrides
dict[str, Any] | None

{parm_name: value} for this render only, e.g. a draft {"resolutionx": 640, "resolutiony": 360}; a parm tuple takes a list. Put back afterwards, expressions and keyframes included, even if the render fails (overrides_applied, overrides_restored). Foreground only. A Karma LOP's "Wait for Render to Complete" is switched on for the call when it is off (foreground_forced).

 None