LTX-2.5 on RTX 5090: 22B Audio-Video in 32 GB via ComfyUI's INT8 Path

What You'll Build

Generate short clips with synchronised video and audio locally using LTX-2.5, Lightricks' 22B audio-video DiT, on a 32 GB RTX 5090. The lead path is ComfyUI's own built-in LTX-2.5: Image to Video / Text to Video template driving the vendor's INT8 transformer — the one configuration on this card with a public "it runs" report. A second section covers the ltx-pipelines CLI for people who want a scriptable, headless pipeline.

Hardware data: RTX 5090 (32GB VRAM, Blackwell sm_120) · INT8-ConvRot distilled transformer, 22.666 GiB of resident weights (derived, not measured) · See benchmark data

⚠️ Known issue, vendor-acknowledged: do not start with the NVFP4 checkpoint. ltx-2.5-22b-distilled-transformer-nvfp4.safetensors is the smallest transformer in the repo (18.721 GB) and looks like the obvious Blackwell pick — but three separate people report the official file failing in ComfyUI, including an RTX 5090 owner on ComfyUI 0.32.0 / Ubuntu 24.04 / PyTorch 2.13.0+cu130, whose run dies at the first sampling step with RuntimeError: mat1 and mat2 shapes cannot be multiplied (3520x4096 and 2048x4096). A Lightricks org member has replied in that thread — "Thank you for reporting about this issue." — and says they are on it (LTX-2.5 discussions #16). Expect this to move, so check the thread before assuming it still applies. The same reporter confirms the INT8-ConvRot checkpoint works in the same template, which is why this recipe leads with INT8 today. The CLI has a separate NVFP4 route with its own prerequisites — see NVFP4 on a 5090 under Running.

Variant pin — and the upscaler that looks like a trap. This recipe targets LTX-2.5 (canonical repo Lightricks/LTX-2.5, 22B, Gemma 4 12B encoder). It is not for the legacy LTX-2.3 line (Lightricks/LTX-2.3, single-file checkpoints + a separate Gemma 3 encoder) and not for the older LTX-2 19B line. The two lines each ship a ~0.996 GB spatial upscaler with near-identical file sizes, and the LTX-2.3 one is still listed in the repo's legacy models page — so it is easy to grab the wrong one. For the two paths this recipe documents — ComfyUI's built-in LTX-2.5 templates and the ltx-pipelines CLI — use ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors from the 2.5 repo. That is what the LTX-2 README Quick Start downloads, what the DFR example passes, and what the core video_ltx2_5_i2v template fetches. There is no default: --spatial-upsampler-path is declared required=True in utils/args.py, so nothing is auto-resolved from either repo.

That imperative is path-scoped, not model-scoped. There are two ComfyUI workflow families for LTX-2.5 and they disagree on this file. The built-in templates that ship with ComfyUI — the ones this recipe uses — pair the INT8-ConvRot checkpoint with the 2.5 upscaler. Lightricks' own node pack, which the LTX-2 README's ComfyUI section sends you to, ships a different set: example_workflows/2.5/LTX-2.5_T2V_I2V_Two_Stage_Distilled.json runs the BF16 transformer and encoder and names ltx-2.3-spatial-upscaler-x2-1.1.safetensors from the LTX-2.3 repo, with a direct download link. If you take that route, follow its own model list: the upscaler and the whole VRAM envelope differ from the built-in templates described below. Its Model Links note lists the same prompt-enhancer model as a required download, so that part does carry over.

ℹ️ Gated weights. Lightricks/LTX-2.5 is a gated repository under the LTX-2 Community License. ComfyUI's own template note is blunt about it: "Before you download all the models, please make sure you have granted access to" LTX-2.5 first (workflow template). Accept the terms on the model page, then hf auth login with a Read token — a fine-grained token needs the read-gated-repos scope. Unauthenticated file requests return 401, not 404.

Requirements

LTX-2.5 support landed in ComfyUI core with commit 57ce8e1 ("Add support for LTX 2.5"), which is an ancestor of tag v0.32.0, released the same day. That release pins comfyui-workflow-templates==0.11.39, and the three local LTX-2.5 templates (video_ltx2_5_t2v, video_ltx2_5_i2v, video_ltx2_5_flf2v, all dated 2026-08-11) first appear in templates v0.11.38 — so any ComfyUI at or above v0.32.0 has them. Anything older will not load the checkpoint at all.

Installation

1. Update ComfyUI to v0.32.0 or newer

export COMFY="$HOME/ComfyUI"        # anywhere you like; every later block reads this
git clone https://github.com/comfyanonymous/ComfyUI "$COMFY"
cd "$COMFY"
git checkout v0.32.0
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

If you already have ComfyUI, point $COMFY at that directory instead of cloning, then git pull and reinstall requirements.txt — the templates ship as the pinned comfyui-workflow-templates wheel, so a code-only update leaves the LTX-2.5 templates missing. Every later block in this recipe reads $COMFY, so set it once per shell and the blocks stay correct whatever order you run them in. Your PyTorch wheel needs sm_120 kernels; the RTX 5090 stack with a public working report on this template is ComfyUI 0.32.0 on Ubuntu 24.04 with PyTorch 2.13.0+cu130 (discussions #16).

2. Accept the licence and authenticate

hf auth login

Open huggingface.co/Lightricks/LTX-2.5, accept the LTX-2 Community License, then log in above with a Read token. Skipping this returns 401 on every file.

3. Download the five LTX-2.5 files ComfyUI's template expects

The repository's folder layout is already ComfyUI's models/ layout — diffusion_models/, text_encoders/, vae/, latent_upscale_models/ — and the HF CLI "keeps the repository's folder layout under --local-dir" (LTX-2 README). So one command puts every file exactly where ComfyUI looks for it:

hf download Lightricks/LTX-2.5 \
    diffusion_models/ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors \
    text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors \
    vae/ltx-2.5-video-vae-bf16.safetensors \
    vae/ltx-2.5-audio-vae-bf16.safetensors \
    latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors \
    --local-dir "$COMFY/models"

That is five of the six entries in the models manifest of ComfyUI's video_ltx2_5_i2v template, whose own storage map places them in the same four folders. The sixth is the prompt-enhancer model, which lives in a different repository and is step 4 below — you need it too, unless you turn the enhancer off.

All byte counts are live reads of the LTX-2.5 tree API, converted at 10⁹ and 2³⁰ bytes respectively.

Two notes on the encoder. It is a purpose-built checkpoint, not stock Gemma: "Google's stock Gemma 4 release is not a substitute: loading checks the encoder's version against the one the checkpoint was trained with" (LTX-2 README). And the *-comfy-int8-convrot files are ComfyUI-only — they are not loadable by the ltx-pipelines CLI, which wants the BF16 or NVFP4 checkpoints instead.

4. Prompt enhancer — enabled by default, so do not skip this

The sixth manifest entry is the enhancer model, which comes from ComfyUI's own repackage rather than the gated repo:

hf download Comfy-Org/gemma-4 \
    text_encoders/gemma4_e2b_it_bf16.safetensors \
    --local-dir "$COMFY/models"

That adds 10.279 GB (9.573 GiB), for 49.989 GB (46.556 GiB) of downloads in total. The stock template ships with enhancement on — the node titled Boolean (Enable Prompt Enhance) is a PrimitiveBoolean set to true in both the Image-to-Video and Text-to-Video templates — so queueing the workflow without this file fails validation before sampling starts. If you would rather not spend the 10.279 GB, that is fine, but you must go and set that boolean to false yourself; it is not off to begin with.

Running

Start ComfyUI, then open Workflow → Browse Templates → Video → "LTX-2.5: Image to Video" (or Text to Video, or FLF2V).

cd "$COMFY"
source "$COMFY/.venv/bin/activate"
python main.py --listen

The main node is a subgraph — click Enter subgraph to reach the sampler, dual-CFG guider, latent upscaler and the tiled VAE decode. What is worth checking before the first queue:

Output is a single video file with the audio track muxed in, written by the SaveVideo node to $COMFY/output/.

Alternative: the ltx-pipelines CLI

If you want a headless, scriptable path, the vendor's own package runs LTX-2.5 directly. It uses different files — BF16, not the ComfyUI INT8 set.

export LTX="$HOME/LTX-2"            # same idea as $COMFY above; a separate checkout
git clone https://github.com/Lightricks/LTX-2.git "$LTX"
cd "$LTX"
uv sync --extra natten

ltx-core v1.2.0 declares requires-python = ">=3.10" and torch~=2.7, and resolves torch from the project's own https://download.pytorch.org/whl/cu132 index, a CUDA 13.2 build (ltx-core pyproject) — the same CUDA generation as the PyTorch 2.13.0+cu130 stack the working RTX 5090 report above is running. Let uv sync pick the wheel rather than substituting one of your own; a wheel without sm_120 kernels will not drive this card. The natten extra is the fast neighbourhood-attention backend for the diffusion VAE decoder and is pinned Linux-only; on Windows and macOS it is skipped and decoding falls back to Triton or eager.

hf download Lightricks/LTX-2.5 \
    diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors \
    text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors \
    vae/ltx-2.5-video-vae-bf16.safetensors \
    vae/ltx-2.5-audio-vae-bf16.safetensors \
    latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors \
    --local-dir "$LTX/models/ltx-2.5"

The README calls this set "That is roughly 66 GiB." — the exact sum of those five files is 71,114,919,816 bytes, i.e. 71.115 GB or 66.231 GiB.

This is a second download, not a continuation of step 3. Two of the five are genuinely new: the BF16 transformer and the BF16 text encoder, 68.282 GB (63.593 GiB) between them, because step 3 fetched the INT8-ConvRot builds and the CLI cannot load those. The other three — both VAEs and the spatial upscaler — are the same BF16 files you already have, and the command above writes a second copy into a separate tree, costing you 2.833 GB (2.638 GiB) twice over. If that matters, drop those three lines and symlink or copy them across from $COMFY/models instead; the layouts match folder for folder.

cd "$LTX"    # uv run needs the project root
PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True uv run python -m ltx_pipelines.distilled \
    --transformer-path       "$LTX/models/ltx-2.5/diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors" \
    --text-encoder-path      "$LTX/models/ltx-2.5/text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors" \
    --video-vae-path         "$LTX/models/ltx-2.5/vae/ltx-2.5-video-vae-bf16.safetensors" \
    --audio-vae-path         "$LTX/models/ltx-2.5/vae/ltx-2.5-audio-vae-bf16.safetensors" \
    --spatial-upsampler-path "$LTX/models/ltx-2.5/latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors" \
    --quantization fp8-cast \
    --offload cpu \
    --num-frames 121 \
    --width 1280 --height 704 \
    --seed 42 \
    --output-path output.mp4 \
    --prompt "A medium close-up of a woman in a workshop turning toward the camera and saying, 'It finally works.'"

Three constraints this path enforces that ComfyUI's grid does not:

• Resolution must be a multiple of 64, not 32. DistilledPipeline calls assert_resolution(..., is_two_stage=True), and that helper's contract is "For two-stage pipelines, the resolution must be divisible by 64." (utils/helpers.py). 1280 × 704 is legal; 1376 × 768 is not.
• Frame count must satisfy (frames - 1) % 8 == 0 — the causal VAE temporal grid, whose default scale factors are time=8, height=32, width=32 in ltx_core/types.py. 121 is legal; so are 9, 17, …, 241.
• --quantization only touches the transformer. FP8 cast "Downcasts transformer linear weights to FP8 during loading; upcasts on the fly during inference. No extra dependencies." (optimization.md), and the README adds that "Fp8-cast should be used with bf16 checkpoints, it shall downcast them on the fly." It does not quantise the Gemma 4 encoder, which stays BF16 at 26.264 GB (24.460 GiB) — see Troubleshooting.

NVFP4 on a 5090 — what it actually costs

NVFP4 is real, it is aimed at this card, and it is not a drop-in. Version 1.2.0 "Added NVFP4 quantization, which cuts transformer memory use and speeds up inference on Blackwell GPUs." (CHANGELOG), exposing --quantization nvfp4-cast (online from BF16) and --quantization nvfp4-prequant (loads ltx-2.5-22b-distilled-transformer-nvfp4.safetensors, 18.721 GB / 17.436 GiB — "Pair with a BF16 VAE."). The RTX 5090 is a supported target at source level: the kernel build's arch list comments that the "block-scaled FP4 kernels are Blackwell-only (sm_100a datacenter, sm_120a consumer)." (ltx-kernels/setup.py), and TORCH_CUDA_ARCH_LIST=12.0 maps to the 120a target there.

The cost is that ltx-kernels is not a wheel — it compiles CUDA extensions on your machine, is excluded from the default uv sync, and lists its requirements as "CUDA toolkit (nvcc) matching your GPU architecture", a CUDA build of PyTorch, and Linux (ltx-kernels README):

uv sync --group kernels

Two things to get right. Do not copy TORCH_CUDA_ARCH_LIST=10.0 from the docs — that is the datacenter arch, and _nvfp4_gencode() in setup.py would then build only sm_100a, leaving your card with no kernel. Either leave the variable unset (the build targets every arch your nvcc supports) or set TORCH_CUDA_ARCH_LIST="12.0". And note the vendor's own NVFP4 tests are gated on a datacenter Blackwell GPU and skip elsewhere, so the consumer sm_120a path is targeted but not covered by their test suite. Separately, the fused CuTe DSL VAE decoder backend is explicitly "Not used on consumer Blackwell (sm_120)." — it needs Tensor Memory this card does not have — so --diffvae-optimization blackwell_dsl is not for you; use the default chunked_eager or, with natten installed, chunked_compile.

So NVFP4 is two separate stories on this card. In the CLI, it is a supported, documented route whose cost is a from-source kernel build. In ComfyUI, the official file currently fails for three reporters and Lightricks has said publicly that they are on it — a state that should not be read as permanent. Either way it is not the path to install first: build the INT8 template, confirm you get video and audio out, and treat NVFP4 as the optimisation you reach for afterwards.

Results

• Speed: Omitted. /check/ltx-2-5/rtx-5090 has no benchmark rows, and no RTX 5090 timing for LTX-2.5 at a stated resolution, frame count and step count has been published on any surface searched (the Lightricks/LTX-2 issue tracker, every thread on the model's HuggingFace discussions tab enumerated individually, and web search). The model shipped on 2026-08-11. If you measure one, please send it via /contribute and it will appear at /check/ltx-2-5/rtx-5090.

• VRAM usage: Derived, not measured. No VRAM figure for LTX-2.5 on a 32 GB card appears in the Lightricks/LTX-2 issue tracker, in any thread on the model's HuggingFace discussions tab (all enumerated individually), or in web search. At the sampling stage the ComfyUI lead path holds the transformer plus everything downstream of it:

  Resident component	Bytes	GiB
  INT8-ConvRot distilled transformer	21,504,034,224	20.027
  Video VAE (diffusion decoder)	1,472,223,346	1.371
  Audio VAE	364,866,540	0.340
  Latent spatial upscaler	995,778,752	0.927
  Total weights	24,336,902,862	22.666

  Against the 5090's 32 GiB that leaves 9.334 GiB for latents, activations and the tiled decode. (GPU capacity is binary-sized, so the "32GB" on the box is 32 GiB — the same unit as the column above.) The Gemma 4 encoder is deliberately absent from that table: at 14.317 GiB it would push the total to 36.983 GiB, past the card. Since an RTX 5090 owner reports this exact template running (discussions #16), the encoder cannot be co-resident with the transformer — ComfyUI stages and frees the text encoder before the sampler loads the transformer. That is also why min_vram_gb is 24 rather than 32: 22.666 GiB of weights fits under 24 GiB, and a 24 GB card owner reports the same ComfyUI workflow completing 5-second clips (discussions #15). The 5090's extra headroom is what turns "fits" into "comfortable".

• Quality notes: The distilled checkpoint runs two stages — 8 steps in stage 1, 4 in stage 2, from a fixed set of predefined sigmas — and trades some fine motion detail for speed. The dev transformer is the higher-fidelity option and ships in both forms: BF16 at 42.018 GB (39.132 GiB, needs --quantization fp8-cast --offload cpu to be plausible here) and an INT8-ConvRot build at exactly the same 21.504 GB as the distilled one, so swapping it into ComfyUI costs no extra VRAM — only steps and guidance, which the distilled template's fixed sigmas do not provide. NVFP4 is published for the distilled transformer only; there is no dev NVFP4 file in the repo. The repo ships two video VAEs: the diffusion decoder used above, and a lighter convolutional one (ltx-2.5-video-vae-conv-bf16.safetensors, 1.452 GB) described as the "convolutional decoder; lighter and needs no extra dependencies" against the diffusion decoder's "improved quality at the cost of longer decode time and more VRAM" (LTX-2 README). Swap to the conv VAE if decode is the bottleneck.

For the full benchmark data, see /check/ltx-2-5/rtx-5090.

Troubleshooting

mat1 and mat2 shapes cannot be multiplied with the NVFP4 checkpoint in ComfyUI

Reported on an RTX 5090 (ComfyUI 0.32.0, Ubuntu 24.04, PyTorch 2.13.0+cu130) using the built-in LTX-2.5 Image-to-Video template with ltx-2.5-22b-distilled-transformer-nvfp4.safetensors; sampling fails immediately with RuntimeError: mat1 and mat2 shapes cannot be multiplied (3520x4096 and 2048x4096). Two other users confirm the same checkpoint failing, and a Lightricks org member has replied in the thread — "Thank you for reporting about this issue." — saying they are on it (discussions #16). So this is acknowledged, not a mystery, and it is likely to be fixed: read the thread before concluding NVFP4 is unusable. Fix for now: use ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors, which the same reporter confirms works in the same template.

Generation hangs forever at the decode step on longer clips

A community user on a 24 GB card reports 5-second clips completing normally while a 10-second clip stalls indefinitely in decoding, with the console showing an otherwise-successful run minus the final timing line. Another user's fix in the same thread: enter the subgraph and lower the VAE Decode (Tiled) node's tile size from 768 to 512 (discussions #15 — both participants are community members, not Lightricks org members). Shorter clips and a smaller decode tile are the two levers; the tile-size knob matters because the diffusion decoder is the memory-hungrier of the two VAEs.

CUDA OOM in the ltx-pipelines CLI while encoding the prompt

The BF16 Gemma 4 encoder is 26.264 GB (24.460 GiB) and --quantization explicitly targets only the transformer, so on a 32 GB card the encode stage is the tightest moment in the run. --offload {cpu,disk} is a single global knob that streams transformer weights, and there is an open request for per-component control so the encoder can stream while the transformers stay resident (LTX-2 issue #232); a related request asks for a smaller or quantised encoder for this exact reason (issue #164). Until either lands, run --quantization fp8-cast --offload cpu together as the README's memory-constrained recipe advises, drop the resolution and frame count, and set PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True. If you only want the easy path, ComfyUI's INT8 encoder is 14.317 GiB instead of 24.460 GiB.

--quantization nvfp4-cast / nvfp4-prequant is rejected as an invalid choice

packages/ltx-pipelines/docs/installation.md still documents --quantization {fp8-cast,fp8-scaled-mm}; the NVFP4 policies were added in v1.2.0 and are present in the live parser via QUANTIZATION_POLICIES (utils/args.py). If your build rejects them, you are on a pre-1.2.0 checkout — git pull and re-run uv sync. If they parse but fail at load, ltx-kernels is not built — see NVFP4 on a 5090 under Running.

401 on every model file

The repo is gated. Accept the licence on the model page and hf auth login with a Read token; fine-grained tokens need the read-gated-repos scope. Note that ComfyUI cannot fetch these files for you from the template's download buttons unless your HF credentials are already configured, and unlike LTX-2 and LTX-2.3 there is no ungated Comfy-Org repackage to fall back on — the Comfy-Org model listing filtered on "ltx" returns only ltx-2 and ltx-2.3.

FlashAttention 4 makes things worse, not better

Do not install a FlashAttention 4 beta on this card. The README pins one specific revision for datacenter Blackwell (B200) and warns that "newer betas have known issues on consumer Blackwell"; for everything else "On other CUDA GPUs, PyTorch SDPA is used automatically." (LTX-2 README). SDPA is the correct default here — leave it alone.

Anything else, report it via the submission form.