DiffHDR Is Free and Apache 2.0: Netflix’s Eyeline Labs Open-Sources LDR-to-HDR Video Re-Exposure

Netflix’s research arm just open-sourced the piece of the HDR pipeline nobody had a free answer for. On September 21, 2026, Eyeline Labs — the research group behind Eyeline Studios, working with Texas A&M and Netflix — released the weights for DiffHDR, an ECCV 2026 model that converts ordinary 8-bit LDR video into real HDR radiance you can re-expose in post. Two LoRA files, 58.5 MB each, Apache 2.0, no strings.

If you have ever blown out a window in a handheld shot and watched the recovery slider do nothing, this is the fix that actually invents the missing information instead of stretching what survived. The catch is real and worth saying up front: the LoRA is tiny, but the base model it plugs into is a 75 GB download. Everything below is about whether that trade is worth your afternoon.

At a Glance

• What it is: DiffHDR, a LoRA that turns clipped 8-bit video into linear HDR EXR frames by treating LDR-to-HDR as generative radiance inpainting rather than a tone curve.
• What’s free: Everything. Code on GitHub under Apache 2.0, weights on Hugging Face under Apache 2.0, and the Wan2.1-VACE-14B base model is Apache 2.0 too.
• What it costs: $0 in licensing. Commercial work is explicitly allowed by all three licenses.
• The one catch: 75 GB of base model, a 14B diffusion transformer, and no hosted demo. This is a workstation tool, not a browser tab.
• Bonus: A second LoRA, DiffHDR_Pano.safetensors, turns a single LDR 360 panorama into an HDR EXR environment map — free HDRIs for your 3D lighting.

Why LDR-to-HDR Has Been a Dead End Until Now

Almost every video you own is 8-bit. When the sensor clipped, the highlight didn’t get compressed, it got deleted — every pixel in that window became 255, 255, 255. Classic inverse tone-mapping takes those flat white regions and expands the range around them, which brightens the frame without putting any detail back. You get a wider histogram and the same blown window.

DiffHDR reframes the problem. Instead of expanding what’s left, it masks the over- and underexposed regions and treats them as holes to be filled — generative inpainting, but in radiance space instead of pixel space. It runs in a Log-Gamma color space so the diffusion model is reasoning about luminance the way a camera does, and because the base model is a video diffusion transformer, the invented highlight detail stays consistent frame to frame instead of shimmering. That temporal stability is the whole reason this is built on a video model and not an image one.

Training data was the other wall. Paired LDR/HDR video basically doesn’t exist at scale, so the team built a pipeline that synthesizes HDR video sequences from static HDRI maps — virtual camera moves through a high-dynamic-range environment, giving them matched pairs for free. It’s the same trick that made Marigold V2’s depth and albedo training tractable, applied to luminance.

What You Actually Get: Four Inference Scripts

The repo ships four entry points, and which one you want depends on your footage:

• infer_video.py — up to 33 frames, takes an MP4 or a folder of images. This is the one you’ll run first.
• infer_long_video.py — anything longer, using a sliding window (default 33 frames, stride 16) with linear temporal blending in the overlaps.
• infer_image.py — single stills.
• infer_hdri.py — the panorama LoRA, outputs a 1024×2048 HDR EXR.

Two conditioning modes make this more than a one-button filter. Pass a text prompt prefixed with over-exposed: and you describe what should be behind the blown-out window — the paper’s own example fills a skylight with an ocean horizon. Pass --reference_image_path instead and DiffHDR matches the tone and style of a reference frame. For a colourist, that second mode is the useful one: it gives you a way to keep recovered highlights consistent across a whole sequence of shots.

How It Compares to the Free Alternatives

The honest read on that table: DaVinci Resolve’s free tier will do a competent HDR grade on footage that still has detail in it, and it costs you nothing and no GPU hours. DiffHDR is for the shots Resolve can’t save — where the information is genuinely gone and you need a model to invent something plausible.

Try It Free: The Exact Setup

There is no hosted demo and no Hugging Face Space, so the free path is local. Here is the whole thing:

1. Clone github.com/Eyeline-Labs/DiffHDR, then conda create -n diffhdr python=3.10 -y and activate it.
2. Install PyTorch 2.6.0 for CUDA 11.8: pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu118, then pip install -e . and pip install -r requirements.txt.
3. Pull the base model: hf download Wan-AI/Wan2.1-VACE-14B --local-dir models/Wan-AI/Wan2.1-VACE-14B. That single repo has all seven DiT shards, the T5 encoder, the VAE and the umt5-xxl tokenizer. Roughly 75 GB — start it before you make coffee.
4. Pull the LoRAs: hf download Eyeline-Labs/DiffHDR --local-dir models. 58.5 MB each, both files.
5. Run it: python infer_video.py --lora_path models/DiffHDR.safetensors --input_path demo/room_window.mp4 --output_dir results/video_mp4 --prompt "" --num_inference_steps 10 --add_mask --use_under_exposure_mask --crop_and_resize --srgb_to_lg

Three details that save you time. First, Flash Attention is optional — every inference path falls back to PyTorch SDPA, so skip the twenty-minute CUDA compile on your first run. Second, the paper used 50 inference steps, but the authors say 10 gives comparable quality on many clips, and that is what their own demo commands use. Start at 10. Third, the model outputs linear HDR EXR frames, not an MP4 — you will need a viewer that reads EXR (DaVinci Resolve, Nuke, or oiiotool) to see what you got.

On hardware: neither repo publishes a VRAM figure for DiffHDR specifically, so don’t trust anyone who quotes one. The binding constraint is Wan2.1-VACE-14B, a 40-layer, 5120-dimension DiT. Alibaba’s own guidance for running any 14B Wan2.1 model on a single GPU is to pass --offload_model True, which tells you plainly that a single consumer card is tight. If you have a 24 GB card, expect to offload and wait. If you have 48 GB or more, you’re fine.

The Honest Trade-Offs

The 75 GB base model is the story. A 58.5 MB LoRA sounds like a weekend experiment until you read the next line of the README. And there is no 1.3B escape hatch: Wan2.1-VACE ships in 1.3B and 14B sizes, but the DiffHDR LoRA was trained on the 14B only. A smaller variant would be the single most useful thing the team could release next.

Every benchmark number is the authors’ own. The paper reports wins over SingleHDR and LEDiff on MUSIQ, CLIPIQA, PU21-PIQE, FovVideoVDP and HDR-VDP-3. Those are real metrics with real tooling — the eval scripts are in the repo under eval/cal_sample.py, which is more than most releases give you. But nobody outside the team has run them yet, and there is no Artificial Analysis-style third-party leaderboard for LDR-to-HDR. Treat the comparison image above as a vendor figure.

It’s inventing, not recovering. Where the sensor clipped, there is no ground truth. DiffHDR synthesizes plausible radiance. For narrative and commercial work that is exactly what you want. For documentary, forensic, or anything where the frame is evidence, it is a problem, and you should disclose it.

The 33-frame window. Anything longer goes through infer_long_video.py with overlapping windows and linear blending. Blending helps, but it is not the same as a model that saw the whole shot. Expect drift on long takes with changing light.

Five Things to Do Differently

• Test on the panorama LoRA first. infer_hdri.py on a single LDR 360 image is one frame instead of 33 — the fastest way to confirm your install works before committing to a video run.
• Use --use_under_exposure_mask on night footage. It’s off by default in the text-conditioned example but present in the basic video command. Crushed blacks benefit as much as blown highlights.
• Write prompts as scene descriptions, not instructions. The over-exposed: prefix expects you to describe what’s physically behind the clipping — “a wide blue sea stretching to the horizon” — not “recover the highlights.”
• Lock a reference frame per sequence. Run one shot, pick the best output frame, then feed it as --reference_image_path for every other shot in the scene. That’s your continuity insurance.
• Keep the base model outside your project folder. Set MODEL_BASE to a shared path. You do not want three copies of 75 GB.

Frequently Asked Questions

Is DiffHDR free?

Yes. The code and both LoRA checkpoints are Apache 2.0 on GitHub and Hugging Face. The Wan2.1-VACE-14B base model is Apache 2.0 as well. There is no paid tier, no API, and no gated form.

Can I use DiffHDR commercially?

Yes. Apache 2.0 permits commercial use across all three components, and Alibaba’s Wan2.1 license states the team claims no rights over your generated content. This is a genuinely unusual position — compare it to Qwen-Image-2.1, which ships open weights but requires a separate commercial license.

What are DiffHDR’s system requirements?

Python 3.10, PyTorch 2.6.0, a CUDA GPU, and about 76 GB of free disk. No VRAM figure is published for DiffHDR itself; the constraint is the 14B Wan2.1 base, which Alibaba recommends running with --offload_model True on a single GPU. Flash Attention is optional.

Does DiffHDR work in ComfyUI?

Not yet. There is no ComfyUI node as of September 22, 2026 — the repo is command-line only, built on a trimmed fork of DiffSynth-Studio. Because Wan2.1-VACE already has strong ComfyUI support, a community wrapper is likely; if one appears, the same SageAttention speedups that apply to other Wan workflows should apply here too.

How is this different from just grading in Resolve?

A grade redistributes the information that survived the capture. DiffHDR generates information that didn’t. If your highlights are recoverable, grade them — it’s faster and free. If they’re clipped to pure white, a grade cannot help and this can.

Worth Your Afternoon?

If you own a 24 GB+ card and shoot anything with hard light, yes — download the panorama LoRA path first and see whether the HDRI output alone justifies the disk space. Free HDR environment maps from your own photos is a real workflow win even if you never touch the video side. If you’re on a laptop or a Mac, this one isn’t for you yet, and the honest advice is to wait for either a 1.3B LoRA or a ComfyUI wrapper with aggressive offloading.

We’ve been putting free video models through their paces on the channel — the MiniMax H3 age-morphing prompt test is a good look at how much these video diffusion backbones can actually be steered, and there’s more on the Creative AI Show channel. Also worth reading alongside this: our breakdown of why the Wan family keeps showing up as the base model everyone builds on.

Accurate as of September 22, 2026 — licensing, file sizes and leaderboard positions move fast. Weights released September 21, 2026.