Export to Resolve

Sooner or later the AI output has to become an element in somebody else's timeline. Export to Resolve is the node that writes your frame to disk in a format Resolve actually likes - and, if you ask it to, pokes Resolve's scripting API to drop the file straight into the open project's Media Pool.

What it does

Two halves. The first half always runs: it writes the frame (or every frame of a batch, numbered) into a folder you nominate, in one of three formats chosen by bit_depth.

• 16bit → 16-bit TIFF. The default, and the right answer for most grading handoffs.
• 8bit → PNG. For review and for anything that's going to get mangled by a chat app anyway.
• EXR → 16-bit half-float EXR. The real one, when your values go above 1.0.

resolve_folder is the destination and gets created if it doesn't exist; filename is the stem, no extension. frame_start (default 1001, because this is a VFX node and VFX starts at 1001) numbers a batch so the sequence reads correctly in Resolve.

The second half is import_to_media_pool, and it's off by default. Turn it on and Radiance launches a separate worker process to talk to Resolve through its scripting API. That's deliberate, not over-engineering: the Resolve Python module is a native library that can take the host process down with it, so running it out-of-process means a scripting crash costs you an empty media pool, not your ComfyUI session. Worth knowing, because it also means the import is fire-and-forget - the worker gets 30 seconds, and if it times out you get a status string and your exported files are still on disk.

input_space is the important one

This is where people hand Resolve the wrong thing. The tooltip spells it out:

• TIFF and PNG are written as sRGB display images. Scene-linear input gets encoded with the sRGB curve and clipped at 1.0. Anything above white is gone.
• EXR is written scene-linear. sRGB input gets linearised on the way out.
• As is (no conversion) writes the numbers untouched.

So if you're carrying a float HDR image through the graph and you set bit_depth to 16-bit TIFF, you've just thrown away your highlights at the last step. Choose EXR for anything scene-linear, and set input_space to match what you actually have rather than what's convenient.

Outputs are status (a human-readable line, including what the Resolve import did or didn't manage) and render_path (the folder). It's an output node, so it runs as a terminal on the graph.

Install

Ships in Radiance. Manager → Radiance → install, restart, refresh. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/fxtd-studios/radiance.git
cd radiance
python -m pip install -r requirements.txt

Windows portable: pip with python_embeded\python.exe. EXR writing works without Python's OpenEXR module - Radiance falls back to OpenImageIO, then OpenCV - so a missing EXR wheel won't stop you.

Where people get burned

The media pool import needs three things you probably haven't set: Resolve Studio (the free version's scripting is restricted), Resolve's Preferences → System → General → External scripting using: Local, and the Resolve scripting environment variables (RESOLVE_SCRIPT_API and friends) visible to ComfyUI's process. Without them the export still succeeds and the status line says the import didn't run, which is the correct, non-destructive outcome.

Also: each run imports again. It doesn't check whether the file is already in the pool, so a seven-run iteration session leaves you seven copies of the sequence. Disable the import while you're iterating and turn it on for the pass you're delivering.

And a philosophical note, because it's the reason this pack exists at all: Resolve is a colour-managed application. Give it a gamma-encoded TIFF labelled as linear and every downstream node misbehaves in ways that get blamed on the model. Match input_space to reality and this node is boring, which is the goal.