LTX-2.5 on RTX 4090: Fitting the 22B Audio-Video DiT in 24 GB via ComfyUI int8

What You'll Build

Generate short clips with synchronised video and audio from a text prompt or a still image, locally, using LTX-2.5 — Lightricks' 22B-parameter audio-video diffusion transformer — on a 24 GB RTX 4090. The route is ComfyUI's own LTX-2.5 template, which shipped in ComfyUI v0.32.0 on 2026-08-11 and loads the vendor's int8 transformer rather than the 42 GB bf16 one.

Hardware data: RTX 4090 (24GB VRAM, Ada sm_89) · int8-convrot transformer, 20.03 GiB resident · See benchmark data

⚠️ The single thing that decides whether this works: the text encoder cannot stay in VRAM. LTX-2.5 ships as separate component files. The transformer the template loads is 20.03 GiB and the Gemma 4 12B text encoder is another 14.32 GiB — 34.34 GiB of weights for a 24 GiB card. They never coexist. ComfyUI encodes the prompt, frees the encoder, then loads the transformer. (With the Prompt Enhancer on, a third model — Gemma 4 E2B, 9.57 GiB — runs and is freed before either of those.) If the encoder is still resident when sampling starts, you do not get an out-of-memory error — you get a run that crawls while weights shuttle over PCIe. See Troubleshooting.

⚠️ Gated repository. Lightricks/LTX-2.5 is gated. You must accept the licence on the model page and authenticate before any download — ComfyUI's own template note says to "please make sure you have granted access to" the repository before fetching models. There is no anonymous download path.

ℹ️ No benchmark data yet. LTX-2.5 was published on 2026-08-11 and /check/ltx-2-5/rtx-4090 currently returns verdict: unknown with zero benchmarks. Every figure below is either a measured file size, arithmetic shown in full, or an attributed community report. Nothing here was measured by us. If you run this, please contribute your numbers.

Requirements

The ComfyUI route runs entirely inside ComfyUI, so it inherits that install's PyTorch and CUDA and adds nothing. The CLI alternative at the end of this recipe is the one with its own floor: ltx-core and ltx-pipelines both declare requires-python = ">=3.10" and ltx-core pins torch~=2.7 (ltx-core/pyproject.toml).

Which transformer build to use

LTX-2.5 publishes five transformer files. What matters on a 24 GB card is the precision, not dev-versus-distilled:

Two things follow. Dev and distilled cost the same memory — an int8 build exists for both and they are identical in size, so choosing between them on this card is a question of sampling steps and output quality, not of fit. And nvfp4 is the one genuinely distilled-only build, which is moot here since it needs Blackwell anyway.

VRAM budget

All four files below are the ones resident during sampling and decode, after the text encoder has been freed. Byte counts are from the HF tree API for Lightricks/LTX-2.5:

The GiB column is each component rounded for display; the total is rounded once from the summed bytes (24,336,902,862 B = 22.6655 GiB), which is why the displayed column reads 22.665 and the total 22.666.

This is a deliberate upper bound: ComfyUI frees the transformer before VAE decode, so all four are unlikely to be resident at the same instant. The point is that even the pessimistic reading fits. Add the 14.317 GiB Gemma 4 12B encoder to that total and you get 36.98 GiB — 12.98 GiB over the card, which is why the eviction in the warning above is structural rather than an optimisation.

Installation

1. Update ComfyUI

LTX-2.5 support was added in ComfyUI v0.32.0, released 2026-08-11 (release notes; PR #15499). An older ComfyUI will not load these checkpoints.

export COMFY="$HOME/ComfyUI"        # point this at your install; every later block reads it
cd "$COMFY"
git pull
python -m pip install -r requirements.txt

Note that the separate ComfyUI-LTXVideo custom-node pack is not required here — its README still documents LTX-2.3 and states a prerequisite of a "CUDA-compatible GPU with 32GB+ VRAM", which is an LTX-2.3-era figure. The LTX-2.5 path in this recipe uses ComfyUI core and its bundled template.

2. Accept the licence and authenticate

Open huggingface.co/Lightricks/LTX-2.5, accept the LTX-2 Community License, then log in:

pip install -U "huggingface_hub[cli]"
hf auth login

The LTX-2 README is explicit about the failure mode: if you get a 401 or 403, accept the model terms and use a Read token — fine-grained tokens need the "read gated repos" scope enabled.

3. Download the six model files

The template declares six models, not five — the sixth is the Prompt Enhancer, and it lives in a different, ungated repository (Comfy-Org/gemma-4). The hf CLI preserves each repository's folder layout under --local-dir, and those layouts (diffusion_models/, text_encoders/, vae/, latent_upscale_models/) already match ComfyUI's own model directories — so pointing --local-dir at $COMFY/models lands every file where the template expects it, from both repositories:

Both commands write into $COMFY from step 1, so they do not care what directory you are standing in. If you opened a new shell since then, re-export it first:

export COMFY="$HOME/ComfyUI"        # only needed in a fresh shell; same value as step 1

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"

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

If the files land in models/models/ or the loader dropdowns come up empty, $COMFY was unset or wrong and --local-dir resolved against your current directory instead — echo "$COMFY" before re-running.

Total download: 49.99 GB. For contrast, the CLI route at the end of this recipe downloads the bf16 set instead, which the LTX-2 README puts at "That is roughly 66 GiB."

The Prompt Enhancer file is not optional, and turning the enhancer off does not make it so. Both the text-to-video and image-to-video templates ship a Boolean (Enable Prompt Enhance) node whose stored value is true, so the enhancer is live on a fresh queue. But even setting it to false does not let you skip the 10.28 GB download: ComfyUI validates the whole graph before executing any of it, and the enhancer's loader node names the file as a literal. The switch that would bypass that branch is lazy, and laziness is consulted at execution time — validation walks every linked input regardless, so an absent model file is rejected as a bad dropdown value at queue time. Download all six files.

4. Load the template

In ComfyUI, open the template browser and choose LTX-2.5: Text to Video (video_ltx2_5_t2v) or LTX-2.5: Image to Video (video_ltx2_5_i2v). A first-and-last-frame variant, LTX-2.5: FLF2V, ships alongside them.

⚠️ Pick the video_ templates, not the api_ ones. api_ltx2_5_t2v / api_ltx2_5_i2v are Lightricks' hosted Pro endpoints — they send your prompt to a paid cloud service and run nothing on your GPU.

Running

Enter the template's subgraph and confirm the loaders point at the files you downloaded — the transformer widget must read ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors. Then set your prompt, resolution and duration, and queue the prompt.

Resolution must be a multiple of 32. The template ships a size-reference note whose every entry is a multiple of 32 — 608 x 352 at 0.2 MP, 960 x 544 at 0.5 MP, 1376 x 768 at 1.0 MP, up to 1920 x 1088 at 2.0 MP. Start at 0.5 MP for a first run; the headroom table above leaves 1.334 GiB for activations, and that shrinks as pixel count and clip length grow.

First run downloads nothing further but does compile and warm caches, so it is slower than steady state. Output lands in $COMFY/output/ as an .mp4 with the audio track muxed in.

Alternative: the ltx-pipelines CLI

Lightricks also ships a Python CLI. It cannot use the int8 checkpoint — ltx-pipelines exposes exactly four quantization backends (fp8-cast, fp8-scaled-mm, nvfp4-cast, nvfp4-prequant) and no int8 path at all, so the comfy-int8-convrot files are ComfyUI-only artifacts. The CLI's low-VRAM route is fp8-cast against the bf16 checkpoint — "Fp8-cast should be used with bf16 checkpoints, it shall downcast them on the fly."

This route needs the bf16 files, not the int8 ones you downloaded above — a separate ~66 GiB set:

export LTX="$HOME/LTX-2"            # keep this outside your $COMFY tree
git clone https://github.com/Lightricks/LTX-2.git "$LTX"
cd "$LTX"
uv sync --extra natten

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"

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 --seed 42 --output-path output.mp4 \
    --prompt "A medium close-up of a woman speaking directly to camera in warm afternoon light"

This path is tighter than the ComfyUI one, not looser. fp8-cast "Downcasts transformer linear weights to FP8 during loading; upcasts on the fly during inference." — but its implementation only covers the attention and feed-forward Linears inside transformer_blocks.*, which is 88.2% of the parameters. The rest — norms, embeddings, AdaLN modulation, the audio and cross-modal projections — stay bf16. Applying that rule to the transformer's 4349-tensor inventory gives 2592 tensors at one byte per parameter and 1757 left at two, totalling 23,482,269,184 B = 23.48 GB = 21.87 GiB resident: a 44.1% reduction rather than a halving, leaving just 2.13 GiB of headroom.

How that inventory was obtained, since it matters for whether you can check it: Lightricks/LTX-2.5 is gated, so its safetensors header cannot be read anonymously. It was read instead from guillaume127/LTX-2.5-FP8, an ungated third-party conversion of the same official distilled transformer, via an HTTP range request for the file's JSON header. Reconstructing an all-bf16 size from that census gives 42,008,051,200 B against the official file's 42,018,190,584 B — a 0.024% gap that is header and alignment overhead — which is what establishes the census as a faithful list of the official transformer's tensors. --offload cpu lowers that further by "offload transformer weights to reduce peak GPU memory" into host RAM at the cost of speed (CLI flags). Use the ComfyUI route unless you specifically need the CLI's pipeline variants.

Results

• Speed: Not measured on an RTX 4090. The closest datapoint is on an RTX 3090 — same 24 GB capacity, one generation older (Ampere) — where a user running ComfyUI's I2V template reports it "works great and fast for 5sec vids (like 2mn30 or so without Sage Attention), I have a 3090, 128Gb RAM" (LTX-2.5 discussion #15). Because the 3090 is the slower card, roughly 2m30s for a 5-second clip is a pessimistic upper bound on the time — the 4090 should come in under it — and not an estimate for this card. No 4090 figure for this checkpoint has been published; contribute yours.
• VRAM usage: 20.03 GiB for the transformer, 22.67 GiB for all weights resident during sampling and decode, against the card's 24 GiB — derived from published file sizes in the budget table above, not measured. Live data, once anyone submits it, appears at /check/ltx-2-5/rtx-4090.
• Quality notes: This is the distilled transformer, which trades some fidelity for far fewer sampling steps. The dev build is the full-quality one, and it ships its own int8 file of exactly the same size — so it fits this card just as well, at the cost of more sampling steps per clip. On 24 GB that choice is about time and quality, not about whether it loads.

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

Troubleshooting

The run is extremely slow instead of crashing

The symptom of an over-full 24 GB card here is thrashing, not an exception. If the Gemma 4 12B encoder is still resident when sampling begins, the transformer cannot fit alongside it and weights stream over PCIe every step. Insert a VRAM-cleanup node before the sampler so the encoder is purged after conditioning. A community RTX 4090 build's author documents exactly this pattern, noting that the Gemma 4 12B text encoder alone consumes about 14.6 GB and that leaving it resident triggers dynamic VRAM loading (guillaume127/LTX-2.5-FP8).

⚠️ Do not reach for --highvram here, despite what you may read. It does the opposite of what this card needs: ComfyUI's own flag help is "By default models will be unloaded to CPU memory after being used. This option keeps them in GPU memory." (comfy/cli_args.py), and setting it also switches off dynamic VRAM management. Keeping the encoder resident is precisely the failure this section is about. Leave ComfyUI on its default policy.

Ten-second clips hang forever at the decode stage

Reported on a 24 GB card in LTX-2.5 discussion #15: 5-second clips complete normally, 10-second ones stall just before the video appears. The fix from that thread is to enter the subgraph and "change the VAE Decode (Tiled) node's tile size from 768 to 512". Smaller tiles cut decode peak memory at the cost of some decode time.

The NVFP4 checkpoint fails immediately

Do not use ltx-2.5-22b-distilled-transformer-nvfp4.safetensors on this card. Two independent reasons: NVFP4 "Requires Blackwell (SM ≥ 10)" and the RTX 4090 is Ada Lovelace (sm_89); and the checkpoint is currently broken in ComfyUI even on Blackwell hardware. A reporter on an RTX 5090 running ComfyUI 0.32.0 hits RuntimeError: mat1 and mat2 shapes cannot be multiplied at sampling, two other users confirm, and a Lightricks org member replies "Thank you for reporting about this issue." — the issue is acknowledged and open (LTX-2.5 discussion #16). The same reporter confirms the int8-convrot "checkpoint works with the same template."

Downloads return 401 or 403

The repository is gated. Accept the licence on the model page, run hf auth login, and if you use a fine-grained token make sure the "read gated repos" scope is enabled. This applies to ComfyUI's own automatic model downloads too — they will fail silently-ish against a gated repo if the CLI is not authenticated first.

Should I use a GGUF quant instead?

Not yet. Third-party GGUF conversions of the LTX-2.5 transformer appeared within a day of release — Abiray/LTX-2.5-Distilled-GGUF publishes Q3_K_M through Q8_0 (11.53 GB to 23.63 GB). As of 2026-08-12 those repositories report 0 downloads, ComfyUI's template library ships LTX-2.5 templates only for the int8 checkpoint, and the request for "gguf and gguf workflow" is an open thread on the model page (discussion #18). QuantStack — the publisher whose LTX-2.3 GGUFs the older recipes on this site use — created a LTX-2.5-GGUF repository on 2026-08-11 but had uploaded no model file to it as of 2026-08-12. The int8-convrot checkpoint is the vendor's own artifact, is what the official template loads, and already fits, so an unvalidated quant buys you nothing on a 24 GB card.

Which spatial upscaler?

It depends on which workflow you are running, and both answers are correct. For this recipe — ComfyUI core's built-in LTX-2.5 templates — use ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors from the LTX-2.5 repository; that is what those templates load, and it is also what the LTX-2 README's quick-start command passes to the CLI. But the separate ComfyUI-LTXVideo node pack is different: its README directs you to ltx-2.3-spatial-upscaler-x2-1.1.safetensors for two-stage pipelines, and its own LTX-2.5 example workflows load that 2.3 file. So if you are running a pack workflow rather than a core template, the 2.3 upscaler is the right file and you should not "fix" it.

What makes this worth flagging is that the two are near-identical in size (995,743,560 vs 995,778,752 bytes) and are not the same file, so a swap is easy to make and hard to notice. The temporal upscaler, by contrast, genuinely is byte-identical across the two repositories (261,944,000 bytes in both) — which is probably where the impression that these files are interchangeable comes from.