LTX-2.5: The Open-Weights World Model Built for Speed, and How to Run It on Runpod

TL;DR: from zero to generation in just a few steps:

1. Deploy a pod with the official ComfyUI template (recommend at least a 32GB 5090 to give yourself a headroom)
2. Request access. The Lightricks/LTX-2.5 repo on Hugging Face is gated. Accept the license on the repo page.
3. Update ComfyUI from the ComfyUI manager within the pod.
4. Run the following commands inin the terminal to authenticate using the HF CLI and download the models to the correct folders.

pip install -U "huggingface_hub[cli]"
hf auth login   # Read token; fine-grained tokens need the gated-repos scope

cd /workspace/ComfyUI
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 \
  text_encoders/gemma4_e2b_it_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 models

For the last year, the open video model race has split into two camps. One camp chases raw output quality and accepts that a single clip might take five minutes and a rack of GPUs. The other camp bets that speed and local deployability are what actually change how people work. If a model generates faster than the clip's own runtime, video generation stops being a render queue and starts being an iteration loop. This has been the thesis ever since Lightricks released the original LTXV model.

With LTX-2.5, released August 11, LTX is arguing you no longer have to choose. The company (spun out of Lightricks, the team behind Facetune and Videoleap) says the LTX family has now passed 33 million downloads, making it the most-used open world model line on the market. And rather than bolting new features onto the LTX-2.3 core from March, LTX-2.5 rebuilds nearly every stage of the generation pipeline. Here's what that means in practice, what the benchmarks actually show, and how to size and deploy it on Runpod, including the exact CLI commands to pull the weights into a day-zero ComfyUI setup.

What LTX-2.5 actually is

LTX-2.5 is a 22B-parameter open-weights audio-video "world model" that generates synchronized video and audio in a single pass, and LTX positions it as a foundation not just for film and short-form content but for real-time applications, simulation, and physical AI. Where large language models predict the next word, world models predict the next moment: they generate environments and simulate how those environments behave.

The headline capability change is native multishot generation. With the exception of the very recently released Minimax H3, previous open models generated one shot at a time, and you stitched sequences together hoping the character's face, the room's lighting, and the voice survived the cut. LTX-2.5 renders a full multi-shot sequence as one output likecharacter, environment, lighting, and voice held consistent across explicit cuts described in a single prompt. If you've spent any time fighting shot-to-shot drift in Wan or earlier LTX releases, this is the feature that changes your workflow.

The second big swing is Diffusion Fidelity Rendering (DFR), a new rendering approach that allocates compute by scene complexity, spending more where the pixels are hard and less where they aren't. Paired with a new diffusion video decoder that replaces the old VAE decode step, it cuts the blotches, smearing, and melted-texture artifacts that plagued high-motion footage while preserving LTX's signature high compression ratio (the thing that makes it fast in the first place).

The rest of the rebuild, briefly:

• A custom Gemma 4 12B text encoder fine-tuned for LTX, plus a prompt enhancer, for holding multiple subjects, actions, lighting, and camera direction across complex prompts. Shorter prompts now get you further.
• Auto duration where the model predicts the right clip length for the described action before diffusion begins, instead of padding or truncating to a fixed length.
• Native 4K HDR output at up to 50 FPS with a RAW workflow, so output drops into professional color and finishing pipelines without compromising a master.
• A pretrained physical-AI checkpoint intended as a fine-tuning base for robotics and simulation data that looks nothing like cinematic video.
• A substantially improved distilled model, co-optimized with NVIDIA, that runs locally on RTX-class GPUs with a 16GB VRAM floor.

The specific increases

LTX publishes aggressive numbers, so it's worth being precise about what was measured and where.

Generation speed. On LTX's own image-to-video benchmark on a 10-second, 24fps clip, LTX-2.5 generates in 6.8 seconds self-hosted on 2x NVIDIA GB200 at steady state. That's faster than the clip's own runtime. The same job through the LTX API lands at 23.7 seconds end-to-end at 1080p (the API has no 720p tier, so it renders at higher resolution than most of the comparison set and still wins). By LTX's end-to-end measurements of competitor APIs on the same task: Gemini Omni Flash at 52 seconds, Grok 1.5 at 63, Veo 3.1 at 70 (for an 8-second clip), MiniMax H3 at 180, Seedance 2.5 at 317, and Kling 3.0 Pro at 398. That makes LTX roughly 7.6x faster than the nearest closed alternative and ~58x faster than the slowest — with the usual caveat that these are vendor-run benchmarks, and the on-prem number assumes hardware most teams don't have in a rack.

Cost: LTX claims roughly one-eighth the cost and one-seventh the render time of comparable models across hardware ranging from datacenter GPUs down to a 16GB consumer card.

Local efficiency: Through the NVIDIA optimization pass, LTX-2.5 delivers up to 20% faster performance and 40% memory savings on an RTX 6000 PRO versus prior releases. The minimum VRAM floor is 16GB for quantized variants.

Quality: In LTX's blind human-preference tests (evaluators vote on side-by-side videos from the same prompt without knowing the source model), LTX-2.5 recorded a 67% win rate, narrowly ahead of Seedance 2.5 at 65%, with Gemini Omni Flash at 55%, MiniMax H3 at 50%, Seedance 2.0 at 44%, and Wan 2.6 at 42%. On the artifact benchmark which measures visible glitches per clip across 98 text-to-video prompts run through ten models with automated scoring. LTX-2.5 Pro ranks first of ten. LTX flags these as preliminary results, but the direction is consistent: the quality gap that used to justify slower models has substantially narrowed.

Sizing GPUs for LTX-2.5 on Runpod

The distilled bf16 component pack including transformer, Gemma 4 text encoder, video and audio VAEs, and the spatial upscaler  totals roughly 66 GiB on disk. That's your storage floor before ComfyUI, dependencies, and outputs; provision a 100GB+ network volume so you never download the weights twice.

For VRAM, the practical tiers look like this:

‍

‍

Getting it running: ComfyUI day zero on Runpod

ComfyUI shipped native LTX-2.5 support on launch day through a strategic day-one partnership with three built-in workflow templates: Text-to-Video, Image-to-Video, and First/Last-Frame-to-Video (FLF2V). Here's the fastest path from zero to generating.

1. Deploy the pod

Sign in at runpod.io, create a network volume of at least 100GB in a datacenter that supports them, and mount it at /workspace. Then deploy a Pod with aRTX PRO 6000 or H100 recommended per the sizing above  using a current ComfyUI template from the Runpod Hub or a PyTorch 2.7 / CUDA 12.8 base image. Attach the network volume, and set container disk to 50GB+ separately from the volume.

If you're starting from a base image, get ComfyUI current with the Update feature from the manager once your pod is up and running.

cd /workspace
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

2. Authenticate with Hugging Face

The repo is gated. Accept the license at huggingface.co/Lightricks/LTX-2.5 and wait for approval, then in your pod terminal:

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

Use a Read token, and if you use a fine-grained token, make sure the "read access to gated repos" scope is enabled. A 401/403 on download means one of those two steps is missing.

3. Download the weights

For the ComfyUI pipeline, pull the Comfy-optimized int8 checkpoints plus the shared VAEs and upscaler directly into your ComfyUI model directories:

cd /workspace/ComfyUI

# Transformer (distilled, ComfyUI int8)
hf download Lightricks/LTX-2.5 \
  diffusion_models/ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors \
  --local-dir models

# Text encoders (Gemma 4 12B + prompt enhancer companion)
hf download Lightricks/LTX-2.5 \
  text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors \
  text_encoders/gemma4_e2b_it_bf16.safetensors \
  --local-dir models

# Video + audio VAEs
hf download Lightricks/LTX-2.5 \
  vae/ltx-2.5-video-vae-bf16.safetensors \
  vae/ltx-2.5-audio-vae-bf16.safetensors \
  --local-dir models

# Spatial upscaler (for the 2x latent upscale stage)
hf download Lightricks/LTX-2.5 \
  latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors \
  --local-dir models

The CLI preserves the repo's folder layout under --local-dir, and that layout matches ComfyUI's expected directory structure exactly

If you're on an 80GB+ card and want the full-precision path instead (or plan to run the ltx-pipelines Python package rather than ComfyUI), swap the int8 files for the bf16 pack:

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 models

That's the ~66 GiB pack. Two things worth knowing: the *-comfy-int8-convrot files are ComfyUI-only and won't load in the PyTorch/ltx-pipelines path, and the bundled Gemma 4 encoder is LTX-specific. Google's stock Gemma 4 release is not a substitute, since the pipeline validates the encoder version against what the checkpoint was trained with.

4. Generate

Launch ComfyUI, open the workflow templates browser, and load the LTX-2.5 Text-to-Video template (Image-to-Video and FLF2V sit alongside it). Write your prompt as one flowing paragraph covering shot type, scene, action, character detail, camera movement, and describe the audio, since the model generates synchronized sound with the video. For multishot, write the whole sequence chronologically and name your cuts in prose ("A hard cut transitions to a close-up..."). The built-in prompt enhancer will expand short prompts into detailed cinematic instructions, so start simple and iterate.

Queue the workflow, and on a PRO 6000 or H100 you'll be reviewing your first synchronized audio-video clip in well under a minute.

The verdict

The H3 release two weeks ago proved that frontier-quality open video was possible; LTX-2.5 makes the case that it can also be practical. A 22B model with a 16GB VRAM floor, single-pass synchronized audio, multishot consistency that holds across cuts, and generation speed that turns overnight render queues into interactive iteration loops  

The honest caveats: the 6.8-second headline was measured on 2x GB200, the benchmarks are vendor-run and preliminary, and 22B parameters is still 22B parameters; comfortable production use starts around 48GB of VRAM even with the distilled checkpoint. But the fit with Runpod is unusually clean. Speed-per-dollar is LTX's entire thesis, and per-hour GPU rental is exactly where that thesis pays off: batch a hundred ad variants overnight on an H100, A/B them in the morning, and terminate the pod. Your weights stay on your network volume, your footage never touches a third-party API, and your cost scales with what you actually render.

Spin up a PRO 6000 or H100 on Runpod, pull the weights with the commands above, and you'll be inside the ComfyUI workflow before your coffee's done.

‍