LTX 2.5 on RTX 5090: Local Inference Benchmark, Speed Consistency and VRAM Realities

Generating temporal consistency from diffusion models locally has long been constrained by memory bandwidth and compute latency. The arrival of distilled video diffusion architectures, paired with Blackwell consumer silicon, alters the efficiency curve for local production pipelines.

Testing the LTX 2.5 transformer pipeline inside ComfyUI on an NVIDIA GeForce RTX 5090 reveals real-world inference throughput, VRAM behavior, and the practical caveats that don’t show up in a single spec sheet number.

Architectural overview: the distilled 22B transformer

LTX 2.5 relies on a high-parameter spatial-temporal transformer backbone designed for high-resolution, synchronized audio-video synthesis. While the full bf16 model demands server-grade or high-VRAM enterprise hardware, the community and official quantization pipeline, specifically the INT8 rotary-position-preserving variant (ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors), substantially lowers memory allocation for the transformer itself.

By leveraging 8-bit quantization on core linear projections while preserving rotary positional embeddings (RoPE) precision, this checkpoint keeps the transformer’s own footprint well below its bf16 original without forcing aggressive CPU offloading of that component.

The distilled scheduling reduces the required sampling steps, enabling sub-minute generation runs for standard-definition clips while maintaining frame coherence across extended sequences.

+-------------------------------------------------------------+
|                      ComfyUI Pipeline                       |
+-------------------------------------------------------------+
                               |
                               v
            [ Gemma 4 12B Text Encoder (loaded, then freed) ]
                               |
                               v
    +----------------------------------------------------+
    |   LTX 2.5 22B Distilled Transformer (INT8 ConvRot) |
    |   Execution on RTX 5090 (Blackwell SM Architecture)|
    +----------------------------------------------------+
                               |
                               v
           [ Spatial-Temporal Video + Audio VAE Decode ]
                               |
                               v
            [ 1280x736 @ 10 Seconds Raw MP4 Output ]

VRAM requirements: the nuance that matters

LTX 2.5 is not a single-file model. The pipeline is split into a transformer, a text encoder (Gemma 4 12B), and separate video/audio VAEs. Any VRAM figure that only refers to the transformer checkpoint is incomplete, and this is where a lot of “fits in 16GB” claims floating around become misleading.

Here is the honest breakdown:

• Transformer (INT8 ConvRot): this is the component that shrinks meaningfully with quantization, and it is what stays resident in VRAM during the sampling loop.
• Text encoder (Gemma 4 12B): a substantial model in its own right, available in several precisions (bf16 down to 4-bit quantized variants, NVFP4). It does not need to stay loaded during sampling.
• Video + audio VAE: decoded after the transformer pass; adds its own — comparatively smaller — peak.

The crucial nuance: ComfyUI’s default model management frees the text encoder from VRAM before the transformer’s sampling pass begins. Peak VRAM during a run is therefore not the sum of “transformer + text encoder resident at the same time” — it’s closer to the largest single stage’s footprint, plus overhead. This is why a 16GB-class card can realistically run this pipeline with a quantized text encoder and the INT8 transformer, provided nothing forces both to stay resident simultaneously (e.g. certain custom nodes, batch prompt caching setups, or manual VRAM pinning can break this assumption).

In short: don’t read “16GB minimum” as “16GB for the whole pipeline held in memory at once.” Read it as “16GB is workable if your workflow lets ComfyUI sequence the components instead of holding them all resident.” On 24GB+ cards this distinction matters much less in practice.

Benchmark protocol and test environment

To establish a baseline, five consecutive execution runs were recorded using identical parameters to observe execution variance.

• GPU: NVIDIA GeForce RTX 5090
• OS: Windows 11
• Framework: ComfyUI 0.33.3
• Frontend: ComfyUI_frontend v1.49.6
• Templates: v0.11.44
• Model Checkpoint: ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors
• Prompt: Default ComfyUI Template Setup
• Output Resolution: 1280 x 736 (0.9 Megapixels, 16:9 native aspect ratio)
• Clip Duration: 10 seconds per run

These are first-party measurements taken directly on this machine, not figures pulled from vendor marketing or third-party reports.

---

---

Latency analysis: 5-run empirical data

The benchmark measured the full execution cycle inside ComfyUI, from prompt conditioning and latent denoising passes down to the final VAE decoding step.

Run Index	Model Checkpoint Variant	Resolution / Duration	Compute Time
Run 1	LTX 2.5 22B INT8 ConvRot	1280 x 736 (10s)	46.83 s
Run 2	LTX 2.5 22B INT8 ConvRot	1280 x 736 (10s)	48.44 s
Run 3	LTX 2.5 22B INT8 ConvRot	1280 x 736 (10s)	48.46 s
Run 4	LTX 2.5 22B INT8 ConvRot	1280 x 736 (10s)	51.72 s
Run 5	LTX 2.5 22B INT8 ConvRot	1280 x 736 (10s)	48.33 s

Across all runs, the generation time stabilized at an average of 48.75 seconds.

Run 4 (51.72 s) came in noticeably above the other four. No specific cause was identified for this deviation — background OS activity, driver-level scheduling, or thermal factors are all plausible, but none were confirmed. Since this was a single occurrence out of five runs and not a reproducible pattern, it’s treated here as an outlier rather than a characteristic of the pipeline. A larger run count would be needed to say anything more definitive about how often — or why — this kind of spike occurs.

Technical bottlenecks: quantization tradeoffs and VAE overhead

While rendering 10 seconds of coherent 0.9 MP video in under a minute on consumer hardware is a genuinely strong result, several practical boundaries remain:

1. Quantization noise in fine detail: INT8 weight quantization effectively resolves VRAM starvation on the transformer side, but minor high-frequency texture smearing can still emerge in intricate background geometry during rapid pan movements.
2. VAE decoding latency floor: the spatial-temporal video/audio VAE decode remains a non-negligible fraction of total execution time and doesn’t shrink proportionally with transformer quantization.
3. Text encoder VRAM behavior is workflow-dependent: as noted above, whether a 16GB-class card stays comfortable depends on ComfyUI correctly freeing the Gemma 4 text encoder before sampling. Custom nodes or non-default caching behavior can undo that assumption and push a card into offloading territory.

FAQ

What are the VRAM requirements for LTX 2.5 with the INT8 ConvRot transformer?

There is no single number that covers the whole pipeline. The INT8 transformer itself is the component quantization actually shrinks. The Gemma 4 12B text encoder is a separate, sizeable model that is loaded, used to produce the prompt conditioning, and then freed from VRAM before sampling starts under ComfyUI’s default behavior. Because of that sequencing, a 16GB-class card can run the pipeline in practice — but this depends on the text encoder not staying resident alongside the transformer. 24GB or higher removes this dependency and gives comfortable headroom for higher resolutions or batch sizes.

Why is the distilled transformer variant preferred over the base model?

Distillation collapses the necessary denoising steps down to a fraction of the base model’s budget, meaningfully reducing total inference time with limited loss in temporal consistency.

Does rotary position embedding quantization cause drift?

Using the convrot-specific safetensors preserves rotary positional embedding logic while compressing linear weights. This setup is designed to avoid the structural temporal drift and camera perspective collapses that naive INT8 quantization can introduce elsewhere.

Conclusion

Running LTX 2.5 on modern consumer flagship hardware achieves a strong speed-to-fidelity ratio, producing clean 10-second outputs averaging ~48.75 seconds on a single RTX 5090 across five measured runs. The VRAM picture is more nuanced than a single headline number suggests — it depends on how the pipeline sequences the text encoder and transformer rather than on quantization alone. As quantized video architectures and memory-efficient decoders continue to mature, local production pipelines are moving rapidly from experimental curiosity to viable local generation workflows.

---