> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ltx.io/open-source-model/vfx-post-production/working-with-exr-hdr/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ltx.io/_mcp/server.

# Working with EXR & HDR

> Bring production EXR/HDR material through LTX-2.5's Native HDR path in ComfyUI and native Python, and return color-managed EXR and HLG output ready for compositing, grading, and finishing.

**Native HDR** brings production EXR material into LTX and returns color-managed HDR output. The goal is to keep color and dynamic range available after generation or editing, so the result can continue through compositing, grading, and finishing instead of being reduced to a display-ready preview.

Use the workflow instructions on this page when your source is an existing scene-linear or ACEScct OpenEXR still or frame sequence. The viewing and color-management sections also apply to EXR output from other documented HDR paths.

If your source is standard-dynamic-range video and you want LTX to synthesize an HDR result, use [SDR to HDR](/open-source-model/vfx-post-production/sdr-to-hdr). That is a reconstruction workflow with its own models, workflows, and version boundaries.

## Native HDR

Native HDR is the HDR-to-HDR path: use it when your source is already EXR/HDR and you want to keep the workflow color-managed through generation and export.

Native EXR is available through the LTX-2.5 Python pipelines. The current LTX-2.5 ComfyUI release workflows add native-HDR image-to-video and inpainting.

### Supported color spaces

Declare the color space that matches the pixels in your EXR source.

| Source                      | Python `--hdr` value | ComfyUI `color_space` value | Meaning                                       |
| --------------------------- | -------------------- | --------------------------- | --------------------------------------------- |
| Scene-linear ACEScg         | `ACESCG`             | `acescg`                    | Scene-linear ACEScg using AP1 primaries       |
| Scene-linear sRGB / Rec.709 | `SRGB_LINEAR`        | `srgb_linear`               | Scene-linear RGB using Rec.709/sRGB primaries |
| ACEScct                     | `ACESCCT`            | `acescct`                   | ACEScct-encoded values                        |

The ComfyUI loader converts supported sources into an ACEScct working representation for the video VAE. Match the EXR output setting to the color space required by your downstream workflow.

### What you get

| Stage                  | Behavior                                                                                             |
| ---------------------- | ---------------------------------------------------------------------------------------------------- |
| Condition load         | A single EXR still or naturally sorted folder of EXR frames is loaded in its declared color space.   |
| Working representation | Supported EXR input is converted to ACEScct for the LTX video path.                                  |
| Generation             | The selected LTX-2.5 generation or IC-LoRA editing workflow runs on the HDR source.                  |
| VAE                    | Video VAE encode and decode run in float32 for the native HDR path.                                  |
| EXR output             | RGB EXR frame sequence, optionally float16 or float32, with output color-space tags where supported. |
| Delivery output        | BT.2020/HLG 10-bit HEVC video. Audio is included only when the selected path supplies a track.       |
| Preview                | A viewable preview is available separately from the EXR sequence and HLG master.                     |

> **Warning**
>
> The ComfyUI loader retains only the first three EXR channels, and the writer creates a new R/G/B EXR. Alpha, additional channels, and source header metadata are not round-tripped.

### HDR video files are not accepted as native HDR input

Native HDR input uses an **EXR still** or a **folder of EXR frames**. HLG, PQ, HDR10, `.mp4`, and `.mov` files are not accepted as color-managed HDR conditioning by the native EXR path.

If your source is an HDR video file, convert it to an OpenEXR frame sequence in one of the supported color spaces:

```text
my_clip_exr/
  frame_00000.exr
  frame_00001.exr
  ...
```

Do not place display-encoded HLG or PQ values into an EXR file and label them as scene-linear.

### Inputs

| Use case                         | Surface | Expected input                                                                                                                               |
| -------------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| HDR image-to-video               | ComfyUI | One EXR still, declared color space, frame rate, duration, and optional prompt                                                               |
| HDR inpainting                   | ComfyUI | EXR frame sequence plus an SDR black-and-white mask video; white is generated and black is retained                                          |
| HDR image-to-video               | Python  | Single `.exr` supplied through `--image`, with matching `--hdr` value                                                                        |
| HDR IC-LoRA / video conditioning | Python  | Directory of `*.exr` frames supplied through `--video-conditioning`, with matching `--hdr` value                                             |
| HDR retake                       | Python  | Directory of `*.exr` frames supplied through `--video-path`; frame rate is required because an EXR sequence has no container timing metadata |

The ComfyUI EXR loader can trim a sequence to its longest valid `8k+1` frame prefix. Confirm the resulting frame count before generation.

### Outputs

| Artifact   | Behavior                                                                                                |
| ---------- | ------------------------------------------------------------------------------------------------------- |
| EXR frames | Written to the configured output directory and color space. ComfyUI supports float16 or float32 output. |
| HLG master | BT.2020, HLG (`arib-std-b67`), 10-bit HEVC. ComfyUI can mux an optional audio track as AAC.             |
| Preview    | Separate preview output for ordinary display; do not treat it as the HDR master.                        |

## Use Native HDR in ComfyUI

### Prerequisites

* A current ComfyUI installation with the required `ComfyUI-LTXVideo` nodes.
* OpenImageIO support for reading and writing EXR files.
* The LTX-2.5 distilled transformer, matching text encoder, video and audio VAEs, and latent spatial upscaler used by the selected workflow.
* The LTX-2.3 In/Outpainting IC-LoRA for the inpainting workflow.

> **Note**
>
> The LTX-2.5 inpainting graph explicitly uses the LTX-2.3 In/Outpainting IC-LoRA as a workflow-specific exception. Do not infer that other LTX-2.3 adapters are compatible with LTX-2.5.

### Image-to-video

1. Load `example_workflows/2.5/HDR_workflows/LTX-2.5_I2V_HDR_Two_Stage_Distilled.json`.
2. In **Load EXR still**, select an EXR plate and set `color_space` to match its pixels.
3. Set frame rate and duration for the generated clip.
4. Enter a prompt if the shot requires one.
5. Keep the workflow's native EXR conditioning settings unchanged.
6. Confirm that the video VAE passes through **LTXVVAEForceFloat32** before every HDR encode and decode.
7. Set the EXR output color space for your downstream pipeline, then run the workflow.

The workflow performs a low-resolution distilled pass, 2× latent spatial upscaling, and a short high-resolution refinement pass. The source still is applied again during stage 2.

### Inpainting

1. Load `example_workflows/2.5/HDR_workflows/LTX-2.5_ICLoRA_Inpaint_HDR_Two_Stage_Distilled.json`.
2. Load the source EXR sequence and declare its color space.
3. Load a black-and-white mask video that matches the source sequence's frame count and aspect ratio. White regions are generated; black regions are retained.
4. Provide an optional prompt describing the intended scene content rather than an editing instruction.
5. Keep the workflow's EXR conditioning settings unchanged and confirm the float32 VAE path.
6. Adjust mask and blend dilation if the transition edge requires more coverage.
7. Set the EXR output color space and run the workflow.

The In/Outpainting IC-LoRA was trained with a specific green value under the generated region. The workflow intentionally retains that training cue even when the surrounding plate uses an ACEScct representation. If green remains at an edge, increase dilation, try another seed, or use a lossless mask source.

### Key HDR nodes

| Node                         | What it does                                                                                                                                                                             |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **LTXVLoadEXRSequence**      | Loads one EXR still or a folder of frames, declares the source color space, converts the input to ACEScct, returns sequence geometry, and supplies silent audio for graph compatibility. |
| **LTXVVAEForceFloat32**      | Forces the supplied video VAE to float32 for native HDR encode and decode.                                                                                                               |
| **LTXVHDRDecodePostprocess** | Converts VAE-decoded ACEScct or legacy LogC3 output into a tonemapped preview and scene-linear HDR output; it can also write EXR frames.                                                 |
| **LTXVSaveHLG**              | Converts scene-linear HDR into a BT.2020/HLG 10-bit HEVC master and optionally muxes audio.                                                                                              |

When saving EXR from **LTXVHDRDecodePostprocess**, set the output color space, output directory, filename prefix, and float16/float32 precision explicitly. The `exposure` control affects only the tonemapped preview, not the scene-linear output or saved EXR frames.

> **Warning**
>
> **LTXVVAEForceFloat32** mutates the VAE object supplied to it; it does not create an independent float32 copy. Use one chain from the VAE loader through this node to all HDR encode and decode operations. Do not share the unpatched loader output with a parallel branch.

The decode nodes expose spatial and temporal tiling to manage VAE memory. Fewer, larger tiles are faster but require more VRAM. This decode tiling is not the separate Native Resolution generation workflow.

## Use Native HDR in Python

The public [`ltx-pipelines` HDR guide](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/docs/hdr.md) is the authoritative source for current CLI flags, accepted EXR inputs, output behavior, and pipeline constraints. It documents native `--hdr` operation for LTX-2.5, including EXR stills and sequences, float32 HDR VAE decode, half-float EXR output, and a BT.2020/HLG master.

### Image-to-video from an ACEScg HDR plate

```bash
python -m ltx_pipelines.ti2vid_two_stages \
  --checkpoint-path /path/to/checkpoint.safetensors \
  --prompt "your prompt" \
  --image /path/to/plate.exr 0 1.0 \
  --hdr ACESCG \
  --output-path /tmp/out.mp4
```

This produces `/tmp/out.mp4` as an HLG master and `/tmp/out_exr/*.exr` as ACEScg-tagged frames.

### Video conditioning from an EXR sequence

```bash
python -m ltx_pipelines.ic_lora \
  --distilled-checkpoint-path /path/to/distilled.safetensors \
  --video-conditioning /path/to/exr_frames/ 1.0 \
  --hdr ACESCG \
  --prompt "your prompt" \
  --output-path /tmp/out.mp4
```

### Retake on an EXR sequence

```bash
python -m ltx_pipelines.retake \
  --distilled-checkpoint-path /path/to/distilled.safetensors \
  --video-path /path/to/exr_frames/ \
  --frame-rate 24 \
  --hdr ACESCG \
  --start-time 1.0 \
  --end-time 2.0 \
  --prompt "your prompt" \
  --output-path /tmp/out.mp4
```

## Viewing EXR files

Standard image viewers do not display HDR EXR files correctly. Use an OCIO-aware viewer such as DJV or Nuke, and set the input transform to match the EXR's actual color space.

| EXR output                | Input interpretation          |
| ------------------------- | ----------------------------- |
| Scene-linear Rec.709/sRGB | Linear Rec.709 or Linear sRGB |
| Scene-linear ACEScg       | ACEScg                        |
| ACEScct                   | ACEScct                       |

[DJV](https://darbyjohnston.github.io/DJV/) is a free, open-source viewer designed for professional image sequences, including EXR.

> **Note**
>
> The input transform must match the EXR output setting. Do not use the legacy LTX-2.3 Linear Rec.709 viewing setup for an ACEScct- or ACEScg-tagged LTX-2.5 sequence.

## Importing EXR files into DaVinci Resolve

Import the EXR sequence at its native frame rate and assign the input transform that matches the color-space setting used when the frames were written. Do not assign a scene-linear transform to ACEScct-encoded frames or an ACEScct transform to scene-linear frames.

The exact LTX-2.5 Resolve project and output settings depend on the EXR output space and delivery target. Validate the transform chain with representative frames before grading a full sequence.

> Bring production EXR/HDR material through LTX-2.5's Native HDR path in ComfyUI and native Python, and return color-managed EXR and HLG output ready for compositing, grading, and finishing.