ComfyUI

ComfyUI#

2026-11-09

19 min read

This plugin integrates Prism into ComfyUI.

ComfyUI is a node-based interface for building and running generative AI workflows. It is commonly used to combine models, prompts, image inputs, video tools, upscalers, control networks, and custom processing nodes into reusable graphs.

The Prism-ComfyUI integration connects these node graphs to a structured VFX and animation pipeline. Save workflows as Prism scene versions, import project media, write generated images and videos to versioned project locations, and automate local or Comfy Cloud execution.

You can also run workflows as App Mode dialogs directly from the standalone Prism Project Browser, without opening the ComfyUI node graph.

Compatibility#

The integration supports Windows, Linux, and macOS. Prism's desktop interface requires a graphical desktop session. On Linux, additional system Qt/XCB libraries may be needed, such as libxcb-cursor0 on Ubuntu.

Use an up-to-date ComfyUI installation. Media loading relies on ComfyUI's VideoFromFile API, and video saving uses its video API. Available codecs, containers, and loader nodes depend on your ComfyUI installation.

The Prism sidebar and node buttons in ComfyUI's browser interface communicate with the Prism desktop process through ws://localhost:8765. Use these tools with ComfyUI and Prism on the same machine and keep that port available.

App Mode and Execution Graph Automation instead submit workflows directly to the configured ComfyUI server or Comfy Cloud. Local execution requires the workflow's models and custom nodes on the server; cloud execution requires a Comfy API key and a cloud-compatible workflow.

Setup#

Install the integration through the ComfyUI Registry or install the ComfyUI plugin via the Prism Hub or during the Onboarding setup.

Install From ComfyUI#

Inside ComfyUI open the "Extensions" window from the menu and search for the custom-node package "Prism Pipeline":

Install the package and select "Apply Changes" to restart ComfyUI and to load Prism:

Once restarted the "Prism Menu" is available from the sidebar:

Click "Project Browser" and a configuration window will appear to setup Prism:

Select "Download Prism" to download and install Prism:

Hint

Select "Find existing Prism" if Prism is already installed on the system.

Once setup, open the "Project Browser" and select or create a Prism project.

The setup supports Windows, Linux, and macOS and installs the downloaded Prism application in a user-writable folder:

Windows: ~/Documents/Prism2/versions/<version>.
Linux: ~/Prism2/versions/<version>.
macOS: ~/Library/Preferences/Prism2/versions/<version>.

On all platforms, setting PRISM_USER_PREFS makes the setup use <PRISM_USER_PREFS>/versions/<version> instead.

The integration stores its configuration in comfy.json in Prism's user preferences directory.

Install From Prism Hub#

Install the ComfyUI plugin from the Prism Hub.

After installing the plugin, add the Prism integration to ComfyUI using the pop-up shown after installation.

Alternatively, the Prism integration can be added in the Prism Settings:

Prism User Settings > DCC apps > ComfyUI > Add

Select the ComfyUI root folder containing custom_nodes, even if it is outside the default search location.

On Windows, the default ComfyUI installation is in this location:

%USERPROFILE%\ComfyUI-Installs\*\ComfyUI

The integration installs a custom node package into the selected ComfyUI folder:

custom_nodes/prism_pipeline

Updating and Removing the Integration#

If installed through ComfyUI's custom-node manager, use that manager to update or remove the package. For a Hub installation, re-add the integration to the same ComfyUI folder to update it, or use Remove under Prism User Settings > DCC apps > ComfyUI to remove it. Restart ComfyUI afterward.

Accessing Prism in ComfyUI#

After the integration has been installed and ComfyUI has been restarted, Prism is available inside the ComfyUI interface.

The Prism sidebar tab provides these actions:

Save Version: Save a new workflow version in the Prism project.
Save with Comment: Save a new workflow version with a comment and thumbnail.
Project Browser: Browse project scenes, media, and products.
Settings: Open Prism Settings.
Status: View the connection state and Prism process information.

Click Status below Settings to view the connection state, the running process ID, and the Prism root and plugin root paths when they are valid. The popup refreshes automatically.

Restart Prism restarts the Prism context process and reconnects. Stop Prism stops it and pauses automatic relaunch in the current ComfyUI session. Opening another Prism action can start it again. Process controls are available only for the process launched by this ComfyUI backend, not an external Prism session.

The Prism node category contains Prism Load Media for reading project media and Prism Save Media for writing generated images and videos. Their inputs and outputs are documented below.

Prism runs in a separate desktop process and communicates with ComfyUI through a local WebSocket connection. The ComfyUI extension reconnects automatically and can start the Prism ComfyUI context process when needed.

Workflow Integration#

In Prism, ComfyUI workflows are handled as scenefiles with the .json extension.

Saving a ComfyUI scenefile from Prism sends a save command to the running ComfyUI instance, waits for the workflow to be written in ComfyUI's user workflow folder, and then copies the workflow into the selected Prism scenefile version.

Use Save with Comment to add a description and thumbnail.
Prism can capture a workflow preview for the scene version.
The plugin also provides an empty ComfyUI workflow as a scene preset in the Project Browser.

Opening a ComfyUI scenefile copies the selected Prism workflow version into ComfyUI's workflow folder and sends a command to load it in ComfyUI.

Running Workflows in App Mode#

App Mode turns a saved ComfyUI workflow into a dialog with editable inputs, a result viewer, and generation history. It runs from the standalone Prism Project Browser without opening the workflow in ComfyUI's browser interface.

Requirements#

Install and enable the ComfyUI plugin in Prism. For local execution, start the ComfyUI server and make sure the workflow's models and custom nodes are installed there. App Mode submits directly to the server; it does not start that server automatically.

Configure the local server with comfyui > localServerAddress (default 127.0.0.1:8188). Cloud execution requires a Comfy API key and a workflow supported by Comfy Cloud. See Settings for configuration.

Preparing a Workflow#

See the official ComfyUI App Mode documentation for configuring App Mode inputs and outputs in ComfyUI.

Build and test the workflow in ComfyUI.
Use ComfyUI's App Mode to expose the inputs that artists should edit and the outputs they should receive.
Save the workflow as a normal ComfyUI workflow JSON file, preserving its App Mode configuration, and store it as a Prism scenefile version.

Prism builds the input form from the saved App Mode inputs. Exposed loader file inputs provide reference-file controls. A workflow without exposed inputs can still run, but its dialog has no editable input form.

Input changes apply to the submitted run; they do not rewrite the saved Prism workflow version. To change the graph or which inputs are exposed, edit and save the workflow in ComfyUI.

Running From the Project Browser#

Open the standalone Prism Project Browser and select the project containing the workflow.
Find the saved .json workflow version in the scenefiles view.
Right-click the file and choose Run ComfyUI Workflow.... This opens the App Mode dialog instead of loading the node graph.
Adjust the exposed inputs and click Run to submit to the configured local ComfyUI server.
Wait for completion. Downloadable outputs appear in the viewer and generation history.

To run remotely, right-click Run and choose Run on ComfyUI Cloud. The dialog reports submission progress and displays an error popup if execution fails.

Note

App Mode does not rely on the Prism integration being loaded in ComfyUI. Native ComfyUI nodes like Save Image can be used to define outputs, which will be captured and made available in Prism.

Reference Inputs#

For exposed loader file inputs, use the browse button or enter a path. Image and video files can also be dragged onto the reference area. Click the reference thumbnail for Browse..., Paste from Clipboard, Capture Screen, or Clear.

../../_images/comfyui_app_mode_inputs.png

Pasted images and screen captures are saved as reference PNG files in the workflow's local history folder. Video reference inputs include playback controls. The path field's context menu also provides Open in explorer and Paste image from clipboard.

Local execution uploads absolute file overrides for LoadImage.image and LoadVideo.file to the configured server. Other custom loader inputs must use paths or references their node implementation can access. Cloud execution uploads existing absolute local file overrides before submission; make sure those files are readable on the Prism machine.

Outputs and History#

The viewer displays generated images and provides playback controls for video and image sequences. Supported 3D model files use USD Quick View when the USD plugin is available. If a model cannot be previewed, the downloaded file can still be opened or dragged into another application.

Local submission downloads image, video, audio, and 3D outputs reported by ComfyUI. Cloud submission downloads image, video, and audio outputs. When App Mode outputs are configured, downloads are restricted to those output nodes; otherwise, reported output nodes are considered. Input files reported by local nodes are not downloaded as generated outputs.

With the Prism USD plugin available, downloaded local .glb results are converted to .usd before being presented to Prism. Successful conversion replaces the downloaded GLB copy with the USD file; if conversion is unavailable or fails, the GLB is retained. This does not delete the original output on the ComfyUI server.

Use the history button to show Generation History, and its refresh button to reload previous results. The dialog combines locally retained files with available job outputs for that workflow from the configured local ComfyUI server. Cloud runs also retain their downloaded results locally; the history refresh does not query cloud job history.

App Mode stores downloaded results beneath Prism's user preferences directory:

ComfyUI/WorkflowHistory/<workflow-id>

These are local history files, not automatically published Prism media versions. Use a workflow configured to write Prism media when versioned project outputs are required. History is associated with the workflow ID saved in the JSON.

Select a history item to preview it, double-click to open it externally, or drag it into another application. Model outputs also provide a dedicated drag button beneath the viewer. Right-click a history item for Open, Open in explorer, Copy Path, Capture Preview, Browse Preview..., and Paste Preview. Generated 3D model previews are captured automatically when Quick View is available.

Clear Session Outputs clears the displayed list only. It does not delete the downloaded files or server history, so refreshing history can show them again.

Importing Media and Assets#

Import media from the Project Browser's Media tab and supported 3D products from its Products tab by rightclicking the product version or media version thumbnail and selecting Import.

Files are uploaded to the active ComfyUI server's input storage before Prism creates the corresponding loader node.

Image Sequences#

When importing an image sequence, choose how to load it:

First Frame: Upload and load only the first frame.
Image Sequence: Upload all frames and create a Prism Load Media node pointing to the sequence.
Convert to Video: Convert the sequence to an MP4 using Prism's media conversion tools, then upload it and create a video loader.
Cancel: Leave the workflow unchanged.

Loader Selection#

For single files, Prism selects a loader based on the file extension:

File type	Loader
Standard images	`LoadImage`.
Videos, such as MP4, MOV, and WebM	`LoadVideo`. This node must be available in ComfyUI.
EXR images	First available node: `◎ RadianceDigitalCinemaRead`, `LoadEXR`, `LoadExr`, or `LoadImage`. The Radiance loader uses its `source_path` input.
GLTF, GLB, FBX, and OBJ products	First available node: `Load3D`, `Load3d`, or `LoadModel`. Files are uploaded to the `3d` input subfolder.

The required loader and any dependencies must be installed in ComfyUI.

Prism Load Media Node#

Add Prism Load Media from the Prism node category to read a single image, an image sequence, or a video from a file path or an existing Prism media version.

Selecting Project Media#

Click Select Version... on the node to open Prism's media browser.
Navigate to the asset or shot, media identifier, version, and, where applicable, AOV or source.
Click Select Version or double-click the version to apply the selection.

The selection fills the node's filepath and context fields. A populated filepath takes precedence over all context fields. Clear it to resolve the media again from context, for example when using latest to follow new versions.

Inputs and Outputs#

Input	Description
`filepath`	Direct file path or image-sequence pattern. Takes precedence over the context inputs. Environment variables and `~` are expanded; relative image paths can resolve inside ComfyUI's input directory. Empty by default.
`asset`	Asset path for asset-based media. Empty by default.
`episode`	Optional episode context for shot-based media. Empty by default.
`sequence`	Sequence name for shot-based media. Empty by default.
`shot`	Shot name when no asset is specified. Empty by default.
`identifier`	Media identifier to resolve when `filepath` is empty. Empty by default.
`version`	Version name or number. Defaults to `latest`; an empty value also selects the latest available version.
`aov`	AOV for a 3D render identifier. Empty by default.
`source`	Preferred source filename or filename pattern within the version. Empty by default.

Context lookup uses the global Prism project location and checks 2D renders, playblasts, then 3D renders. Context lookup and Select Version... require an active Prism connection; a direct filepath can be used without one.

Output	Type	Description
`images`	`IMAGE`	Decoded image frames as a batch, including frames from videos.
`mask`	`MASK`	Inverted alpha when available; otherwise a zero-valued mask.
`video`	`VIDEO`	Video object for video files. Non-video inputs do not produce a video object.
`resolved_filepath`	`STRING`	The file path or sequence pattern used by the loader.

Image-sequence patterns accept wildcards, hash padding such as render.####.png, and printf padding such as render.%04d.png. A numbered image filename can also discover neighboring frames automatically. Frames are loaded as an image batch; frames with dimensions different from the first decoded frame are skipped.

Prism Save Media Node#

The integration adds a custom ComfyUI node named Prism Save Media in the Prism category.

This node saves generated images and videos directly into the Prism project. It requests the correct Prism media path from the connected Prism instance, writes the output file to that path, and also writes a copy to ComfyUI's normal output folder so the result appears in the ComfyUI UI.

Input	Description
`asset`	Asset path for asset-based outputs. Empty by default.
`episode`	Optional episode context for shot-based outputs. Empty by default.
`sequence`	Sequence name for shot-based outputs. Empty by default.
`shot`	Shot name for shot-based outputs. Empty by default.
`identifier`	Media identifier for the output. Defaults to `comfy`.
`version`	Version to write. Empty by default; leave empty or use `next` for automatic versioning.
`images`	Optional `IMAGE` input. Saved as a PNG or PNG sequence.
`video`	Optional `VIDEO` input.
`video_format`	Optional video container selection. Defaults to `auto`.
`video_codec`	Optional video codec selection. Defaults to `auto`.

At least one media input (images or video) is required.

If multiple image frames are provided, the node writes an image sequence by appending padded frame numbers:

<base>_00001.png, <base>_00002.png, ...

If both images and video are connected, the video output uses an identifier suffix _video to avoid naming collisions with image outputs.

For asset outputs, set asset. For shot outputs, set sequence and shot, plus episode when applicable. The Select Entity... button on the node can fill these fields from the Prism entity selector.

Project output is saved as 2D media in the project's global location and appears in the Project Browser's Media tab.

Note

Keep Prism connected to the intended project when saving. If Prism is unavailable or cannot return a project output path, the node falls back to a relative output path. That fallback is not a versioned Prism publish. Check Status and the ComfyUI console if output is missing from the project.

ComfyUI embeds the workflow in the generated image's metadata when metadata writing is enabled. This works with both ComfyUI's native Save Image node and the Prism Save Media node for PNG images, allowing you to reopen a generated image in ComfyUI to recover its workflow. See the official ComfyUI workflow metadata documentation for details.

After a successful save, the confirmation dialog offers Open in Project Browser, Open in Explorer, or Close.

Execution Graph Automation#

With the Execution Graph plugin installed and loaded, ComfyUI registers two nodes for automated workflow submission.

../../_images/comfyui_execution_graph.png

Submit Workflow (Local)#

Submits a workflow to a local ComfyUI server.

Available settings:

Server Address: Local ComfyUI host and port. The node defaults to 127.0.0.1:8188.
Workflow Path: Path to the ComfyUI workflow JSON file.
Inputs: Optional input overrides for nodes in the workflow.
Wait For Completion: Wait until the workflow has finished before continuing.
Output Dir: Destination folder or file path for downloaded results. Set a writable path so the node can return GeneratedFiles.

The local Execution Graph node uses its Server Address setting. App Mode and calls without an explicit server address use comfyui > localServerAddress instead.

Local submission connects to ComfyUI's websocket before queuing the workflow so fast jobs cannot miss completion events.

If Output Dir points to a file path (for example C:\tmp\result.png), Prism treats it as a file target and appends index suffixes for additional outputs.

Submit Workflow (Cloud)#

Submits a workflow to Comfy Cloud.

Available settings:

Path: Path to the ComfyUI workflow JSON file.
Inputs: Optional input overrides for nodes in the workflow.
Wait For Completion: Wait until the cloud job has finished before continuing.
Output Dir: Destination folder or file path for downloaded results. Set a writable path so the node can return GeneratedFiles.

Cloud submission requires a configured Comfy Cloud API key.

Both Execution Graph nodes return GeneratedFiles, a list of downloaded result paths.

For cloud submissions, absolute local file paths in input overrides are uploaded automatically before submission and replaced with cloud input references.

Workflow Formats and Input Overrides#

Local and cloud submissions accept API-format workflows or normal saved ComfyUI workflows. Saved workflows are converted to API format before submission. App Mode input forms require the normal saved workflow with its exposed-input metadata, rather than only the API prompt.

Supply Inputs as a mapping from node IDs to input names and values, for example:

{
        "6": {"text": "A misty forest at sunrise"},
        "3": {"seed": 12345}
}

Replace these example IDs with IDs from your workflow. Overrides affect the submitted prompt, not the workflow file on disk.

Set Output Dir to a writable folder or output filename to download generated files. Both Execution Graph nodes expect downloadable results for their GeneratedFiles output and report failure when none are returned. They are not fire-and-forget queue nodes. App Mode output selections also restrict which node outputs are downloaded during Execution Graph submission.

Wait For Completion is enabled by default. A configured Output Dir also makes submission wait for completion, even if that checkbox is disabled.

A configured Comfy API key is also passed to locally submitted workflows for ComfyUI API nodes that need it. Models, custom nodes, and remote API access required by the workflow must still be available on the execution server.

Settings#

These values are stored in the comfyui section of Prism's user configuration.

They are not exposed in the Prism Settings dialog, but can be set in the Prism.json configuration file in the user prefs folder or by using the Prism Python API.

Configuration key	Description
`comfyui > localServerAddress`	Host and port used by App Mode, workflow history, and local submission when no explicit address is supplied. Defaults to `127.0.0.1:8188`. Use `host:port` without a URL scheme. The local Execution Graph node has its own Server Address setting.
`comfyui > cloudApiKey`	Comfy API key for cloud submission and local workflows containing ComfyUI API nodes. `PRISM_COMFYUI_API_KEY` takes precedence when set.
`comfyui > cloudBaseUrl`	Comfy Cloud API base URL. Defaults to `https://cloud.comfy.org`.

Environment Variables#

Set installation and discovery variables before starting ComfyUI or Prism.

Variable	Description
`PRISM_COMFYUI_PATH`	Optional ComfyUI root folder override for workflow and input path resolution. Otherwise, Prism uses the folder reported by the running custom node.
`PRISM_COMFYUI_PLUGIN_ROOT`	Optional desktop ComfyUI plugin folder override for custom installation layouts.
`PRISM_COMFYUI_API_KEY`	Comfy API key for cloud submission and local workflows containing ComfyUI API nodes. Overrides `comfyui > cloudApiKey`. Set it in the submitting Prism process's environment.
`PRISM_COMFYUI_CONFIG_PATH`	Optional full path to `comfy.json`. Overrides the default configuration file location, but not the application installation folder. Use the same value for Prism and ComfyUI.
`PRISM_SHOW_DEFAULT_SCENEFILE_PRESETS`	Show the plugin's default scene presets. Defaults to `1`; set to `0` to hide them.