Performance Benchmarks

LTX-2.3 and LTX-2.5 are large audio-video models, and local performance varies considerably between hardware configurations. The most useful benchmark is therefore a reproducible test using the same model, resolution, duration, frame rate, inference steps, and software configuration. Community benchmark results can be useful for comparison, but they should not be treated as official Lightricks performance guarantees.

For a meaningful LTX benchmark, record the GPU, VRAM, model checkpoint, precision or quantization, resolution, number of frames, frame rate, inference steps, and whether CPU offloading or compilation is enabled. Report both total generation time and, where available, the denoising and decoding portions separately.

A useful baseline is a short 24 fps clip at a fixed resolution. The same test can then be repeated with longer clips or higher resolutions to show how performance scales. LTX-2.5 also introduces automatic duration prediction, so explicit frame counts should be used when comparing runs to ensure that every benchmark generates the same amount of video.

GPU architecture and available VRAM are the most important hardware variables for local LTX inference. Modern NVIDIA GPUs with sufficient VRAM generally provide the most straightforward path for local execution. A 24 GB card can be a practical consumer target when using memory-optimized configurations, while larger-memory GPUs can reduce the need for CPU offloading and provide more headroom for demanding workloads.

As an example of the variation possible between configurations, a community LTX-2.5 implementation reported approximately 99 seconds for a complete generation on an RTX 4090 with 24 GB VRAM after optimizing the pipeline, while another community test reported around 229 seconds for a 2-second 960×576 clip on a 48 GB GPU. These results use different implementations and settings and therefore should not be interpreted as a direct GPU-vs-GPU comparison.

Having enough VRAM to keep the main model components resident can make a large difference to performance. When the transformer or other components do not fit, weights may be streamed between GPU and system memory. This can make otherwise unsupported configurations technically usable, but the additional data movement can significantly increase generation time.

The official LTX pipeline documentation also describes memory cleanup between stages and notes that users with sufficient VRAM can avoid some cleanup operations to reduce runtime. This illustrates why two systems with similar GPUs can produce different benchmark results when their memory-management configurations differ.

LTX-2.3 performance depends heavily on the selected checkpoint and inference pipeline. The model family includes full development and distilled variants, with the distilled path intended to reduce the amount of sampling required. Community reports also show that software versions and optimizations can materially change generation time, so benchmark results should always identify the exact software configuration used.

For example, a public LTX-2.3 community report measured a short 96-frame upscale operation on an RTX 5090 at roughly 34 seconds in one configuration, while a later report from the same setup observed approximately 60–70 seconds after software changes. This is a useful illustration of why benchmark numbers from different releases should not be compared without checking the pipeline and version.

LTX-2.5 adds a substantially improved distilled model and a new diffusion video decoder. The official repository also provides different decoder options, with the diffusion decoder offering higher reconstruction quality at the cost of longer decode time and higher VRAM usage, while the convolutional decoder is lighter.

The LTX-2.5 pipeline supports compilation of transformer blocks through torch.compile. According to the official optimization documentation, compilation is optional and can improve inference speed. This means benchmark results should distinguish between a default eager-mode run and an optimized, compiled configuration.

The exact speed advantage depends on the workflow and implementation because inference time is strongly affected by the number of denoising steps. The official LTX training configuration, for example, uses 30 inference steps for validation, while LTX-2.5 distilled workflows can use substantially fewer steps. A benchmark should therefore always report the number of steps rather than simply labeling a model as fast or slow.

Generation time generally increases as the spatial or temporal size of the output increases. A longer clip requires more frames, while a higher-resolution clip contains substantially more latent tokens to process. Consequently, a benchmark for a 2-second 576p clip cannot be directly compared with a 10-second 1080p generation.

For reliable comparisons, use fixed benchmark profiles such as short 24 fps clips at a defined resolution and frame count. Additional tests can then measure the impact of increasing duration and resolution independently.

Entry-level local test: 24 GB GPU, distilled model, short 24 fps clip, memory-optimized configuration. Performance test: 24–32 GB GPU, identical settings with compilation and optimized attention enabled. High-memory test: 48 GB+ GPU with minimal or no CPU offloading. Training test: report VRAM usage, batch size, precision, quantization, LoRA rank, gradient checkpointing, and samples per hour rather than generation time alone.

A useful LTX benchmark should provide enough information for another user to reproduce the test. At minimum, document the GPU, VRAM, system RAM, operating system, CUDA and PyTorch versions, LTX version, model checkpoint, quantization, resolution, frame count, frame rate, inference steps, attention backend, compilation status, and offloading settings.