Installation

ComfyUI Manager / Comfy Registry

Search for Radiance in ComfyUI Manager, or install it from the Comfy Registry. Nothing else needs doing:

• Dependencies install from requirements.txt (OpenColorIO, OpenEXR, OpenImageIO, OpenCV and the rest; all ship as wheels for Python 3.9 to 3.13). On Python 3.14, which has no OpenEXR wheel yet, OpenEXR is skipped and EXR goes through OpenImageIO.
• OCIO configures itself at startup: your $OCIO if you have one, otherwise OpenColorIO's built-in ACES studio config. No files to download.
• The RUDRA SDR → HDR model downloads the first time a graph needs it (about 5 MB, see Models).
• The Multipass Estimate models (MoGe-2 and Marigold IID, about 4.9 GB) download the first time that node runs, unless its download_missing_models switch is off (see Multipass Estimate).

Checked on a clean ComfyUI 0.32 with Python 3.13: the registry package installs, all 156 nodes load, OCIO is configured, and the first SDR → HDR run fetches the model and applies it.

Requirements

Install into the same Python environment as ComfyUI. Radiance relies on ComfyUI's existing PyTorch. Dependencies are pure Python (no CUDA toolkit or compiler required). Use the requirements file that matches your platform, shown below.

Windows

cd ComfyUI\custom_nodes
git clone https://github.com/fxtd-studios/radiance.git
cd radiance
pip install -r requirements_windows.txt

Ubuntu / Linux

Install the system libraries OpenCV needs (OpenEXR and OCIO ship as self-contained wheels):

sudo apt update
sudo apt install -y git python3-venv build-essential libgl1 libglib2.0-0 ffmpeg

On Ubuntu 22.04 the package is libgl1-mesa-glx; on 24.04+ it's libgl1.

Then, inside ComfyUI's environment:

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

WSL (Ubuntu on Windows)

WSL2 is Ubuntu with GPU passthrough, so follow the Ubuntu steps above (including requirements_linux.txt), plus:

• Install the NVIDIA driver on the Windows host only, never a Linux NVIDIA driver inside WSL. Verify with nvidia-smi inside WSL.
• No CUDA Toolkit needed: PyTorch's bundled CUDA runtime handles the GPU.
• Keep ComfyUI on the Linux filesystem (~/ComfyUI), not /mnt/c/..., for speed; open the UI from Windows at http://localhost:8188.

macOS (Apple Silicon)

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

Verify

Start ComfyUI and look for Radiance: successfully loaded 156 nodes (v3.5.0) in the log. A lower count means a node module failed to import, usually a missing optional dependency; the Environment Guard table printed at startup shows which.

For a full machine-level check (every node executed on your GPU, VRAM peaks, and the RUDRA SDR → HDR pixel model benchmarked and scored), run the acceptance tool. It ships with a git install, not with the registry package:

cd ComfyUI
python custom_nodes\radiance\tools\gpu_acceptance.py

It writes gpu_acceptance_report.md next to the script, and names any nodes missing on your install.

Updating

• ComfyUI Manager / Registry: use Update on Radiance in the Manager, then restart ComfyUI.
• Git install: git pull in ComfyUI/custom_nodes/radiance, run the same pip install -r ... line as above, then restart ComfyUI.

The startup log prints the installed version: Radiance: successfully loaded 156 nodes (v3.5.0).

Upgrading from 2.x or 3.4

3.5.0 is a large release; the full list is in the changelog. What affects an existing graph:

• Check widget values once on HDR VAE Decode, SDR → HDR Universal, SDR → HDR Recover and NDI Sender. Inputs were removed from them, and ComfyUI stores widget values by position.
• HDR is measured one way everywhere: linear 1.0 = reference white, 203 nits by default (ITU-R BT.2408). Universal and Recover output that used 1.0 = 100 nits is now 2.03x smaller in value and identical in nits.
• Learned SDR → HDR is one pixel model that downloads itself; the older latent decoders (rudra_turbo_decoder_*, rudra_full_decoder_*) are no longer read and can be deleted from models/radiance.
• Multipass Relight reads ao the way renderers write it: 1 = open. It used to read the pass as an occlusion amount, which inverted real AO loaded through Read AOVs. A hand-made occlusion mask needs inverting once.
• Thirteen bug fixes change some outputs: Video HDR Decode (white on peak_nits, a real SDR preview), Video Batch Decode (no second latent_scale), HDR Color Pipeline (every primaries pair, corrected D60 matrices), Multipass Relight's point light with a depth pass, Digital Cinema Read (a video's first frame), EXR MultiPart (every frame). The changelog's upgrade note lists them.

Models (RUDRA SDR → HDR)

Learned SDR → HDR recovery uses the RUDRA pixel model: a compact network that takes decoded 8-bit SDR pixels and returns scene-linear HDR, recovering clipped highlights and crushed shadows. It works on any image or frame batch and needs no VAE, so it applies equally to generated frames and to footage. The weights are published on Hugging Face, fxtdstudios/RUDRA.

The RUDRA weights are licensed for non-commercial use only, unlike Radiance's code (GPL-3.0) and RUDRA's code (Apache 2.0). One training source (HdM-HDR-2014 / HdM-HFR-2017) is free for academic use only, and FXTD Studios cannot waive that term. Research, evaluation, teaching and personal projects are fine; commercial production, client deliverables and paid services need a commercial licence from FXTD Studios. The full terms are in the weights' licence. Expand mode uses no weights and has no such restriction.

It downloads automatically. The first time SDR → HDR Universal or SDR → HDR Recover needs the model and none is installed, Radiance fetches RUDRA's shipped model, sdr2hdr_shadow_v1 (about 5 MB), into your ComfyUI models folder:

ComfyUI/models/radiance/sdr2hdr_shadow_v1.safetensors

The download is pinned to a fixed Hugging Face commit and checked by size and SHA-256 before it is used; a file that does not match is discarded. It happens once, and the console shows [Radiance] Installed ... when it is done. Leave the node's pixel_checkpoint field empty to use it.

To install it by hand instead (offline or air-gapped machines), download sdr2hdr_shadow_v1.safetensors and put it at the path above, creating the radiance folder if needed. To turn automatic downloads off, set any of these in the ComfyUI launch environment:

Radiance registers models/radiance with ComfyUI, so a radiance: entry in extra_model_paths.yaml works too, and RADIANCE_SDR2HDR_PIXEL can point at a file anywhere. Every RUDRA image checkpoint loads, as Hugging Face publishes it (.safetensors, flat in the folder or under the sdr2hdr/ subfolder hf download creates) or as the training scripts write it (.pt); each file carries its own architecture, so the shadow-gated and ungated models both build correctly. When several are present sdr2hdr_shadow_v1 wins, then the other shadow seeds, then sdr2hdr_image_v5, then older .pt files. sdr2hdr_temporal_v1 is not an image model and is refused with a message saying so.

If the model can't be found or downloaded, Universal falls back to deterministic expansion and says so in its report output; Recover raises rather than silently expanding.

What the model recovers, and what it doesn't. In clipped highlights the network supplies brightness; the colour stays the source's. A clipped channel carries no information about its own value, and the released checkpoints were trained on renders that almost never clipped, so their per-channel guesses in blown areas are not reliable colour: letting them through drew false-colour rings round a clipped sun and cast white areas red. The learned lift fades in as the source goes to white (two or more channels near clip), is never darker than the deterministic expansion, and no channel of it exceeds peak_nits, so an HDR10 encode cannot clip it per channel. The model runs on the whole frame when it fits in memory; pixel_tile_size only applies when it does not, because the network normalises over its input and tiles shift the result.

Models every other node downloads

Every node that needs a model downloads it the first time it runs. Each file is pinned (a fixed Hugging Face commit or the original release file) and its SHA-256 is checked before it is installed; a file that does not match is deleted. Downloads go to a .part file and resume after an interruption, and ComfyUI's progress bar shows them.

Gated repositories. FLUX.2-dev, FLUX.2-klein 9B and LTX-2.5 require accepting their licence on Hugging Face. Accept it on the model page, set HF_TOKEN to a read token (or run huggingface-cli login) and restart ComfyUI; the download then runs automatically. Without the token the node stops with a message giving both steps.

Installed by hand. HAT-L (Upscale Tier 2) is published only on Google Drive, so there is no pinned download: get it from the HAT page and save it as models/upscale_models/HAT_L_x4.pth / HAT_L_x2.pth. Until then Tier 2 uses SwinIR-L at 4x and Real-ESRGAN at 2x. SeedVR2 needs the ComfyUI-SeedVR2_VideoUpscaler node pack, which fetches its own weights.

The latent-space RUDRA decoders that earlier releases loaded inside HDR VAE Decode (rudra_turbo_decoder_* / rudra_full_decoder_*) were retired in 3.5.0; see the changelog. The files can be deleted from models/radiance.

Models (Multipass Estimate)

Multipass Estimate turns a plate into render-style passes using trained models only; every pass is a prediction of that quantity or is computed from one. It downloads its weights the first time it runs, pinned to fixed Hugging Face commits:

MoGe-2 runs through ComfyUI's native MoGe support, so it needs a ComfyUI that has the MoGe nodes; a model from Load MoGe Model can also be connected. The Marigold licence allows commercial use with the use restrictions in its licence. To install by hand, download the files into the folders above. Set the node's download_missing_models off, or RADIANCE_ALLOW_DOWNLOADS=0, to stop the download.

What the passes are, and what they are not:

• Geometry is metric but estimated. Depth and position are in metres in camera space (OpenGL axes, the camera looks down -z), with the field of view recovered from the image unless you give it. Scale is the model's estimate, usually within about 10 to 20 percent indoors. Sky and other pixels without a surface are 0 in depth and position and 0 in geometry_mask.
• AO and curvature are computed, not guessed. AO is the GTAO integral (cosine-weighted, radius in metres) over the estimated geometry, 1 = open. Curvature is mean curvature in 1/metre, convex positive.
• Materials and lighting are learned decompositions. Diffuse and specular lighting are scaled to the plate by a least-squares fit per frame, and the node's info output reports how closely they add back up to the beauty (about 10 percent RMS on an indoor photo). Every colour pass is scene-linear.
• Motion vectors are measured with DIS optical flow: backward, in pixels, +y up.
• Video is per frame. The models see one frame at a time; a fixed seed limits flicker but does not remove it.
• Speed and memory. On a CPU a 640 px frame takes about two minutes for materials and three for geometry plus lighting, and the node needs about 8 GB of free RAM (one model is held at a time). GPU timing is still to be measured on the RTX 4080.

Example workflows

Seven workflows ship in the package's workflows folder. The first five appear in ComfyUI's Templates browser under Radiance; any of them can also be dragged onto the canvas. Each one was run on a clean install before release. Pick your own file in the Read node; outputs go to ComfyUI/output/radiance_examples/.