RUDRA

Radiometric Dynamic-Range Conditioning for HDR-Aware Diffusion Models FXTD Studios · github.com/fxtdstudios/RUDRA

Two independent families live in this repository.

They share a name and a radiometric convention and nothing else. Pick the one that matches your problem.

---

sdr2hdr/ — single-image inverse tone mapping

A compact U-Net that predicts a residual on an analytic inverse-ACES tone map, not the image itself. Six channels in (SDR RGB plus the analytic baseline), five out (a log-domain residual and two masks). The curve does the mapping; the network supplies only what a curve cannot know.

Start with sdr2hdr_image_v8.safetensors -- and read what it scores first. RUDRA's own masters use the analytic inverse by default; v8 is the optional learned model, offered with its measured numbers, not in place of the inverse.

Input is 8-bit normalised sRGB RGB. Output is scene-linear RGB normalised to 10,000 nits, with diffuse white at 203 (ITU-R BT.2408).

Loading

Each file carries its own architecture config in its safetensors metadata, so nothing else is needed to build the right network:

import json, torch
from safetensors import safe_open
from safetensors.torch import load_file
from rudra.sdr2hdr import SDR2HDRNet          # pip install -e . from the GitHub repo

path = "sdr2hdr/sdr2hdr_image_v8.safetensors"
with safe_open(path, framework="pt") as f:
    config = json.loads(f.metadata()["config"])
model = SDR2HDRNet.from_config(config)
model.load_state_dict(load_file(path), strict=True)
model.eval()

SHA256SUMS and index.json sit beside the weights. The config also carries corpus_ev, which sets the analytic baseline the residual rides on: v8 is 0.0, every earlier file is the legacy -1. from_config reads it; do not drop it.

v8 on real SDR

Paired against the analytic inverse, 95% bootstrap CIs. real is 287 held-out Netflix Meridian frames, SDR from the Dolby Vision trim pass against its HDR10 grade (live action; never seen in training or selection). aces, oog and mix are rendered benches: the inverse's own curve, other curves, and a mix with codec damage.

• The first model whose CVVDP interval is above the inverse on real SDR, and level with it on PU21. Against shadow_v1 on the same 287 frames: +4.14 dB [+4.10, +4.17], 287/287, +0.026 JOD.
• It does not pass its own gate. Inside clipped highlights it is no better than the inverse (-0.36 stops at 0 EV, ties at +1 and +2 EV), and it lifts black below about 2 nits. On aces, where the inverse is exact, it loses 11 dB. That is why it is optional.

What it scores

429 held-out frames at native 1280×720, PU21-PSNR and ColorVideoVDP JOD, against the analytic inverse-ACES baseline the model sits on top of. hard is the deployment condition (unknown tone curve, 4:2:0 chroma, banding, JPEG); clean is well-graded input the baseline already handles.

The three gate seeds are the only configurations that come out positive on all four measures.

Limitations, stated plainly

• No published method has been scored on our split. Every number above is against our own analytic baseline. Read them as internal progress, not as a comparison, until that gap is closed.
• The backbone alone regresses on clean input. image_v5 loses 3.0 dB of PU21-PSNR on well-graded frames, and the failure concentrates in low-dynamic-range scenes: the 60 worst average −10.76 dB at a median ground-truth peak of 238 nits, the 60 best +3.41 dB at 19,590 nits. The gate is what fixes it.
• The metrics disagree, and it matters. That same 3.0 dB loss is −0.046 JOD in CVVDP, far below a just-noticeable difference. Do not quote the PU21 row without the JOD beside it.
• The achievable gain is bounded by the input, not the model. A linear readout of the features explains 3% of the variance in the per-frame scale an oracle would use, and 79% of that variance sits within a condition rather than between. Capacity (4×), corpus (6×) and objective were each varied and none moved it.
• Three seeds is a spread, not a distribution.
• The temporal refiner is unevaluated. Its held-out set is 4 validation and 5 test clips of one scene each, too small to report.

Training data is documented in the GitHub README: Poly Haven HDRIs (CC0), HdM-HDR-2014 and HdM-HFR-2017 (academic licence), Netflix Chimera (CC BY 4.0), plus proprietary FXTD footage that is not redistributed. sdr2hdr_image_v8 adds real SDR/HDR10 frame pairs from Netflix Open Content (CC BY 4.0): Nocturne, Sparks and Sol Levante for training, Cosmos Laundromat for checkpoint selection, Meridian held out for test.

---

Decoders — diffusion latents to scene-linear HDR

Diffusion models are trained on tone-mapped images, so their VAEs decode to a world where nothing is brighter than white. These replace that decoder and return scene-linear radiance instead.

Two sizes per backbone: full reconstructs more faithfully, turbo is roughly a tenth the size and fast enough to sit in a live graph.

huggingface-cli download fxtdstudios/RUDRA \
    --include "rudra_*_decoder_*.safetensors" \
    --local-dir "ComfyUI/models/radiance"

Then enable rudra_decoder in the Radiance HDR VAE Decode node and pick a decoder_size.

Measured reconstruction quality, for the size we recommend per backbone. The table covers the recommended decoder per backbone, not every file above:

---

Licence and citation

Non-commercial. The weights here are licensed for research, teaching, evaluation, benchmarking and personal use only (checkpoints/LICENSE), because one of their training sources (HdM-HDR-2014 / HdM-HFR-2017) is free for academic use only. The code that runs them is licensed under the PolyForm Noncommercial License 1.0.0. Commercial licensing: FXTD Studios.

If the SDR→HDR work is useful in yours:

@misc{rudra2026,
  title  = {What an 8-Bit Frame Can and Cannot Say About the Scene Behind It:
            bounds for inverse tone mapping, and a gate that reaches one of them},
  author = {{FXTD Studios}},
  year   = {2026},
  note   = {https://github.com/fxtdstudios/RUDRA}
}