LTX-2.5: Multishot Narrative, 4K HDR, and DFR
In the previous lesson, LTX-2.3 already managed to generate videos with audio in one go. This lesson's LTX-2.5 is its upgraded version: multishot narrative (cutting between shots within one video while characters, environments, lighting, and audio stay consistent), native 4K HDR (officially listed at up to 50 FPS), and a multi-stage rendering pipeline called DFR (Diffusion Fidelity Rendering).
The ComfyUI template library natively includes four workflows for LTX-2.5: text-to-video (T2V), image-to-video (I2V), first-last-frame (FLF2V), and DFR. This lesson runs the LTX-2.5 workflow end to end, from downloading the models to producing output with DFR.
What You'll Be Able to Do After This Lesson
- Apply for LTX-2.5 Hugging Face access and place the six model files into their directories
- Use the official text-to-video template to generate 1280×736, roughly 5-second, 24 fps videos with built-in audio tracks
- Write "multishot + audio" LTX-2.5 prompts, and know when to turn on the prompt enhancer
- Switch among the T2V, I2V, and FLF2V templates depending on the task, sharing the same model files
- Install the ComfyUI-LTXVideo custom nodes, run the DFR three-stage pipeline, and be able to explain what each stage does
Your Current Pain Points
- A single 5-second clip can't tell a story; you want several shots within one video, but the moment you cut, the characters and scenes break consistency
- LTX-2.3's image quality still isn't good enough for a finished piece—blurry faces, smearing during fast motion—and you've heard about "4K HDR" but don't know how to use it in ComfyUI
- The LTX-2.5 tutorials you've found are either cloud API versions or fail halfway through the model download (access not approved), leaving you stuck at step one
When to Use This Technique
When you need:
- Multiple coherent shots within one video, with characters, environments, lighting, and audio staying consistent across cuts
- Higher finished quality: clearer faces, readable text, no smearing during fast motion
- Picture and sound generated in one pass—dialogue, sound effects, and ambient audio without post-production dubbing
And you don't want to:
- Generate shot by shot and then manually edit and stitch them together
- Run a separate dubbing and lip-sync pipeline after generating the visuals
🎒 Preparation Before You Start
- You've run the LTX-2.3 audio-video workflow: you know how to load workflows from the template library and understand wrapper nodes
- ComfyUI updated to v0.32.0 or later (the minimum version marked by the template library for the LTX-2.5 T2V/I2V/FLF2V templates; the DFR template requires v0.35.0 or later—updating straight to the latest is the easiest)
- A registered Hugging Face account, with access to the two gated repositories applied for in advance (see Step 1—approval takes time, so apply first and do other things while you wait)
- Enough disk space: the prompt enhancer encoder takes 4.84 GB (9.57 GB for the DFR version); the official sources on this page don't list the size of the 22B main model, so reserve on the order of 22B @@I18N_KEEP_000041@@
- Know your VRAM situation: first run with the template's default 0.9 MP, then consider raising the resolution
- Weak network? The Gemma 4 encoder has an official ModelScope mirror (
Comfy-Org/gemma-4)—see Step 2
Core Idea
LTX-2.5 carries on LTX-2.3's foundation of "producing picture and sound in a single inference pass," with the main upgrades in these areas:
| Upgrade | Description |
|---|---|
| Multishot narrative | Generates multiple coherent shots in one pass, keeping characters, environments, lighting, audio, and style consistent across cuts |
| Gemma 4 12B custom encoder | Remembers multiple subjects, actions, lighting, and camera movements in complex prompts |
| DFR pipeline | Keyframe-first rendering path: allocates rendering compute based on scene complexity for higher final quality |
| Diffusion video decoder | Clearer faces, readable text, and less motion blur in fast movement |
| Auto Duration | The official introduction says the model predicts an appropriate duration based on the actions described in the prompt before diffusion |
| Native 4K HDR | Officially listed as outputting up to 4K HDR at 50 FPS, with a RAW workflow for professional post-production pipelines |
| Better distilled version | The distilled model retains more quality, prompt adherence, and sense of motion than the previous generation while running faster |
The biggest usage difference from LTX-2.3: LTX-2.5's local templates use the distilled main model directly (ltx-2.5-22b-distilled-transformer-comfy-int8-convrot), no longer needing to attach a distillation LoRA to the dev model as with LTX-2.3; the text encoder has also changed from Gemma 3 12B to a custom Gemma 4 12B.
Division of roles among the four official templates:
| Template (template library search name) | Minimum version | Input | Extra requirements |
|---|---|---|---|
| LTX-2.5: text-to-video | v0.32.0 | Prompt | None |
| LTX-2.5: image-to-video | v0.32.0 | First-frame image | None |
| LTX-2.5: FLF2V | v0.32.0 | First frame + last frame images | None |
| LTX-2.5 DFR: image-to-video | v0.35.0 | First-frame image (or text only) | ComfyUI-LTXVideo custom nodes |
Follow along with me
Step 1: Update ComfyUI and request access to the LTX-2.5 model
Why: LTX-2.5's weights are hosted in a gated repository on Hugging Face, and downloads will fail outright without an approved request — this is the biggest difference in the download experience between LTX-2.5 and LTX-2.3, and approval takes time, so it must be done first.
- Update ComfyUI to the latest version (use the built-in updater on desktop, or run the
update_comfyuiupdate script on the portable version) - Log in to Hugging Face, open the repository
Lightricks/LTX-2.5, read and agree to the usage terms, and submit an access request - Also open the repository
Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler(the detail IC-LoRA used by the DFR pipeline, in a separate gated repository) and submit a request there as well - Wait for approval; while waiting, you can go ahead and update ComfyUI
You should see: both repository pages show that you have been granted access. Before approval, the download links in Step 2 will fail.
- Access to both gated repositories has been approved
💡 Request access first, then do everything else
Approval isn't instant. Submit your requests first, then go back to updating ComfyUI and reviewing the templates; by the time model access is approved, you can proceed straight to downloading.
Step 2: Download and place six model files (with domestic mirrors)
Why: The LTX-2.5 text-to-video template needs six files (one optional), and the directory layout is completely different from LTX-2.3 — the main model goes in diffusion_models/ instead of checkpoints/, and the audio VAE has also been split out of the main model into a standalone file. A popup after loading the template offers one-click downloads; when downloading manually, place the files according to the table below.
| File | Size | Destination directory | Purpose |
|---|---|---|---|
ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors | — | models/diffusion_models/ | 22B distilled main model (int8 quantized), shared by all four templates |
gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors | — | models/text_encoders/ | Gemma 4 12B custom text encoder (int8) |
gemma4_e2b_it_int8_convrot.safetensors | 4.84 GB | models/text_encoders/ | Optional: small encoder for the prompt enhancer; skip it if you don't enable prompt_enhance |
ltx-2.5-video-vae-bf16.safetensors | — | models/vae/ | Video VAE |
ltx-2.5-audio-vae-bf16.safetensors | — | models/vae/ | Audio VAE (in LTX-2.5 it's a standalone file, not built into the main model) |
ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors | — | models/latent_upscale_models/ | Latent 2x spatial upscaler (not used by the FLF2V template) |
The directory structure looks like this:
ComfyUI/
├── models/
│ ├── 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
│ │ └── gemma4_e2b_it_int8_convrot.safetensors # 可选
│ ├── vae/
│ │ ├── ltx-2.5-video-vae-bf16.safetensors
│ │ └── ltx-2.5-audio-vae-bf16.safetensors
│ └── latent_upscale_models/
│ └── ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors💡 For users in mainland China: the Gemma 4 encoder has an official mirror on ModelScope Comfy-Org/gemma-4 (including the gemma4_e2b_it_int8_convrot used by the enhancer) — just search for the repository name; the distilled main model, both VAEs, and the spatial upscaler are in the Lightricks/LTX-2.5 repository on Hugging Face, which requires the access approved in Step 1.
You should see: all six files in place; every model dropdown in the template selects the corresponding file name, with no red errors.
- Model files in place, all dropdowns showing the correct files
Step 3: Run the LTX-2.5 workflow template (text-to-video)
Why: The official template wraps LTX-2.5's two-stage sampling pipeline into a single subgraph node, so you only manage the parameters on the subgraph's surface; this is also the starting point of the entire LTX-2.5 workflow — the later I2V, FLF2V, and DFR variants all build on it by swapping inputs.
- Open the template library (Browse Templates), go to the Video category, and find LTX-2.5: Text to Video (searching for "LTX-2.5" directly is faster)
- Click to load it
- Get familiar with the Text to Video (LTX-2.5) subgraph node on the canvas, with the following parameters:
| Parameter | Template Default | Description |
|---|---|---|
| Prompt | Comes with an English example (Arctic hunter) | Write visuals + audio together, see step 4 |
| prompt_enhance | Off | Prompt enhancer: when on, it uses a 4.84 GB small encoder to expand your prompt first, costing an extra 1–2 minutes |
| ResolutionSelector | 16:9 / 0.9 MP | Aspect ratio + megapixel budget, automatically converted to width and height in multiples of 32; 0.9 MP corresponds to 1280×736 |
| duration | 5 | Duration (seconds) |
| frame_rate | 24 | Frame rate |
| seed | Random | Fix the seed for easy reproduction |
- Without changing anything, just press
Ctrl+Enterto run it once and confirm the pipeline can produce a video - To inspect the internal pipeline, click the enter button (Enter subgraph) on the subgraph node: you can see two-stage sampling — the first stage runs on the half-resolution latent space 8 steps (euler_ancestral sampler, CFG 1, fixed sigma schedule), then
LTXVLatentUpsamplerupsamples the latent space spatially by 2×, and the second stage runs another 3 steps to refine the final quality
You should see:
The SaveVideo node outputs a **1280×736, about 5 seconds, 24 fps video file **with an audio track
The two sampling stages total 11 steps — the distilled main model works directly at this step count, with no need to attach an extra distillation LoRA like LTX-2.3
The sound descriptions in the prompt (wind, voices, etc.) are actually present in the final video
It runs with default parameters, and the output video has both visuals and sound
You can describe the two-stage sampling: 8 steps at half resolution → spatial ×2 → 3 refinement steps
Step 4: Write a "multi-shot + sound" prompt
Why: LTX-2.5 switched to a custom Gemma 4 12B encoder, which the developers say can remember multiple subjects, actions, lighting, and camera movements in complex prompts — the more complete your prompt, the more apparent the advantages for multi-shot and sound.
The official prompt structure:
- Write the entire scene in one flowing passage of text: shot type, scene, actions, characters, and camera movement all in this single passage
- Include the audio as well: describe what sounds are present in the scene and what the characters say; the model generates them together with the visuals; put dialogue in quotation marks
- Write multiple shots in order: if you want to cut between shots, write each shot into the same passage in the order it occurs — the model will keep characters, environment, lighting, sound, and style consistent across shots
The default example that ships with the official text-to-video template is a standard demonstration (Arctic hunter, paraphrased):
A close-up of an Arctic hunter's face, his gaze locked onto something far ahead, frost crusted on his beard, one hand slowly reaching for the rifle on his back,
his breathing quick and shallow. The camera slowly pulls back, revealing him crouched at the edge of an ice floe, and in the direction he is watching, on a distant ice ridge,
a polar bear is moving slowly, its pale fur blending into the white mist. The camera keeps pulling back, the hunter in the foreground, the bear in the distance,
the two facing off across a dark channel of water, seabirds circling overhead. Halfway through the shot, the full title "LTX-2.5"
fades in centered in large white sans-serif letters, slowly emerging from the fog. Amid the sound of the wind comes the noise of distant ice shifting,
and a low roar rolls across the water.Note what this example contains: shot type (close-up), camera movement (continuous pull-back), multiple subjects (hunter + bear + seabirds), on-screen text (title fade-in), audio (wind, ice sounds, low roar) — all written into one passage of text.
Two optional switches:
- prompt_enhance (prompt enhancer): off by default. When enabled, the template first uses a small 4.84 GB Gemma 4 encoder to expand your short prompt into detailed instructions before sampling, costing about 1–2 extra minutes. Turn it on when you write briefly but want detail; if you write it fully yourself, there's no need
- Auto Duration: the official introduction says the model predicts an appropriate duration from the actions described in the prompt before diffusion starts; this is a built-in model capability. The local template's
durationparameter defaults to 5 seconds — just change the number for whatever length you want
You should see: a coherent passage of text in the prompt box, with shots, actions, characters, and sound all included, and dialogue (if any) in quotation marks.
- The prompt contains both shot descriptions and audio descriptions
Step 5: Switch to the image-to-video and first-last-frame templates
Why: once T2V works, I2V and FLF2V are just a change of input — the model files are mostly shared, and the prompt is written from a different angle.
| Template | Input | How to write the prompt |
|---|---|---|
| LTX-2.5: Image to Video | One first-frame image | Write what happens next: actions, camera movement, sound; don't repeat what is already visible in the image. The developers recommend anchoring it with a phrase like "Use the provided start image as the first frame" |
| LTX-2.5: FLF2V | First-frame image + last-frame image | Write the transition that happens between the two frames: including camera movement and audio; use the same aspect ratio for both images so the transition is smooth |
Steps:
- Search "LTX-2.5" in the template library and load the image-to-video or FLF2V template
- Image to video: upload your image on Load First Frame (the template's default example is
neon_cyborg_portrait.png); FLF2V: upload one image each on Load First Frame and Load Last Frame (default examplesrobot_hand.png/robot_hand_energy.png) - Subgraph parameters are the same as T2V: prompt, resolution, duration, frame rate, seed
- Run to generate the video
You should see: the canvas structure is roughly the same as T2V, just with an extra entry point for uploading images; the two templates share the same set of model files with T2V, where FLF2V does not use the spatial upscaler (it can still run without that one file).
- Run I2V or FLF2V end to end with your own images
Step 6: Produce high-quality videos with the DFR three-stage pipeline
Why: DFR (Diffusion Fidelity Rendering) is the official "final video" path — the distilled main model paired with a detail IC-LoRA; the first pass generates one detail keyframe per second within the video, and subsequent rendering passes reuse these keyframes as guidance. That is how the quality is built up.
First, add two things:
- Update ComfyUI to v0.35.0 or later, and install the custom node package ComfyUI-LTXVideo (nodes like
LTXVAddGeneratedKeyframesin the DFR template come from this package; install it by searching "LTXVideo" in ComfyUI Manager) - Add three model files (the DFR model set differs from the earlier ones):
| File | Size | Put in directory | Notes |
|---|---|---|---|
gemma4-12b-with-proj-ltx-2.5-bf16.safetensors | — | models/text_encoders/ | Full-precision (bf16) encoder, replacing the int8 version |
ltx-2.5-22b-ic-lora-pixel-spatial-upscaler-x2-1.0.safetensors | — | models/loras/ | Detail IC-LoRA, in the separate gated repository (the second repository you requested in step 1) |
ltx-2.5-latent-temporal-upscaler-x2-bf16-1.0.safetensors | — | models/latent_upscale_models/ | Temporal upscaler, used in the third stage |
The enhancer encoder also switches to the bf16 version: gemma4_e2b_it_bf16.safetensors (9.57 GB, optional). The main model, dual VAEs, and spatial upscaler are shared with the earlier setup.
Load the template and get to know the three stages: search "LTX-2.5 DFR" in the template library and load the image-to-video DFR template. Inside subgraph Image to Video (LTX-2.5 DFR) there are three sampling stages:
| Stage | Runs at what size | Steps | What it does |
|---|---|---|---|
| 1 Generation | Half of the output size | 8 | Denoises the video, one detail keyframe per second, and audio together |
| 2 Spatial ×2 | Output size | 3 | Resamples after upscaling the latent space ×2, attaches the detail IC-LoRA, and injects the half-resolution latent as reference |
| 3 Temporal ×2 | 241 frames @ 48 fps | 4 | Doubles frames and frame rate at the same duration (121→241 frames, 24→48 fps); the second stage's keyframes are pinned back as guidance at 0.95 strength |
All three stages use the euler sampler, CFG 1.0, and a fixed ManualSigmas table — distilled recipe; do not change the steps or sigmas arbitrarily, or the visual style will shift.
Main switches:
| Switch | Location | Effect |
|---|---|---|
| Start image (I2V) | Top level | Upload the first-frame image (default example office_garden_169_outpaint.png) |
| Output size | Top level | Aspect ratio + megapixel budget, ×32; the first stage automatically runs at half of it |
| Switch to T2V | Inside the subgraph | When enabled, ignores the first-frame image and generates from text only |
| Float (fps) / Float (Duration) | Inside the subgraph | Defaults to 24 fps / 5 seconds = 121 frames |
| Enable Prompt Enhancer | Inside the subgraph | Expands the prompt first with the small encoder (requires the 9.57 GB bf16 version) |
| Run 3rd stage - Temporal Upscale | Inside the subgraph | Turn off to skip the third stage: faster, outputs 24 fps / 121 frames |
| Enable Tiled Decode | Inside the subgraph | Tiled VAE decoding, reduces VRAM usage, slightly softer details |
DFR prompts differ from T2V; the official guidance gives three rules:
- Write it as one continuous shot: DFR is built around keyframes within the video, so describe a single one-take scene rather than a series of cuts
- Generate audio in the same pass: put dialogue in quotes and describe ambient sounds and sound effects
- Keep camera movement gentle: the pipeline is most prone to "boiling" or banding when fast motion sweeps over high-frequency textures and smooth gradients
You should see:
Save video (mp4 + audio)Output the final video: with all three stages enabled it is 48 fps; with the third stage disabled it is 24 fpsThe audio in the final video always comes from the first stage — in the third stage audio only participates in cross-attention guidance and is then discarded, without changing the sound
If the enhancer is enabled, the
Preview as Text (Final Prompt)node lets you see the final expanded promptGet DFR running end to end and be able to explain what each of the three stages does
Know that turning off the third stage yields a 24 fps version
Checkpoint ✅
- Access to both restricted repositories has been approved, and model downloads no longer fail
- Ran the text-to-video template with default parameters: 1280×736, about 5 seconds, 24 fps, with a built-in audio track
- Can explain the two-pass sampling: 8 steps at half resolution → spatial ×2 → 3 refinement steps; DFR's three stages: 8 generation steps → 3 spatial steps → 4 temporal steps
- Write the whole prompt in one paragraph: shot type, action, characters, camera movement, sound; put dialogue in quotes
- Know how to choose among the four templates: text-only uses T2V, a single image uses I2V, locked first/last frames use FLF2V, and for higher quality go with DFR (DFR requires additionally installing the ComfyUI-LTXVideo custom nodes, and ComfyUI must be 0.35.0 or above)
Pitfall reminders
❌ Model download fails (access not approved)
The LTX-2.5 weights live in restricted repositories on Hugging Face. If you click the download link without applying for access (or before your application is approved), it will inevitably fail.
Correct approach: in step 1, first apply for access to both the Lightricks/LTX-2.5 and Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler repositories, and download only after approval; the template popup's one-click download likewise requires access to be approved.
❌ The DFR template loads with a screen full of red nodes
The DFR template has two hard requirements beyond the other three templates: ComfyUI v0.35.0 or above, and the ComfyUI-LTXVideo custom node pack (LTXVAddGeneratedKeyframes and other nodes come from it). Missing either one raises a "node does not exist" error.
Correct approach: update ComfyUI first, then use the ComfyUI Manager to install ComfyUI-LTXVideo, and reload the template after restarting. The T2V/I2V/FLF2V templates do not need custom nodes.
❌ Thinking the step count is too low and manually raising it to improve quality
The LTX-2.5 local templates use the distilled main model; 8+3 steps (plus 4 more for DFR) and the fixed ManualSigmas table are part of the recipe—the official documentation states plainly: change them, and the look of the final video changes.
Correct approach: keep the template's default step count, sampler, CFG, and sigma table untouched; to improve quality, use the DFR pipeline, raise the megapixel budget, or enable the enhancer, rather than touching sampling parameters.
❌ Textures "boiling" in moving shots, gradients showing banding
High-frequency repeated textures and smooth gradients may show boiling/banding when the camera moves. The official notes did an A/B test: same prompt, same seed, with tiled decoding and temporal upscaling toggled on and off in all four combinations, the problem was equally severe—this is a characteristic of the model and pipeline, not a misconfigured node.
Correct approach: wide framing plus gentle camera movement is the most stable; the official notes also observed that bf16 weights are cleaner than int8. If you really must shoot fast-moving shots, try several different seeds.
Advanced tips (optional)
Megapixel budget and resolution reference
The ResolutionSelector on the subgraph determines output size via "aspect ratio + megapixels" (automatically snapping to multiples of 32). The 16:9 reference table from the template notes:
| Megapixels | Width×Height |
|---|---|
| 0.2 | 608×352 |
| 0.5 | 960×544 |
| 0.9 (default) | 1280×736 |
| 1.0 | 1376×768 |
| 2.0 | 1920×1088 |
Raising the megapixel budget means raising the resolution, and VRAM usage rises accordingly. The model itself supports native 4K HDR output at up to 50 FPS; how far you can push it locally depends on your GPU—test in small increments first.
Two switches for when VRAM runs short
- Enable Tiled Decode (DFR): tiled VAE decoding drops VRAM usage by a tier, at the cost of slightly softer detail
- Turn off the third stage (Run 3rd stage - Temporal Upscale): skips a 241-frame sampling pass and produces a 24 fps final video at the fastest speed
No big local VRAM? Use the cloud API nodes
ComfyUI also offers Lightricks' official LTX-2.5 cloud API nodes (search "LTX-2.5" in the template library; the T2V/I2V/FLF2V workflows each have an API-version template), in two tiers, Pro/Fast: Fast goes up to 4K (a 3840×2160 preset), duration is Pro 2–10 seconds / Fast 2–20 seconds, frame rate options are 24/25/50 for Pro and 24/25/48/50 for Fast. When your local machine can't run 4K HDR, this is the official alternative path.
Lesson summary
✅ In this lesson we ran the LTX-2.5 workflow all the way from downloading the models to producing video with DFR:
- ✅ The weights are in restricted repositories: apply for access to the
Lightricks/LTX-2.5and IC-LoRA repositories before downloading; the Gemma 4 encoder has a ModelScope mirror - ✅ The biggest differences from LTX-2.3 in usage: the distilled int8 main model is used directly (no distilled LoRA attached), the audio VAE is a separate file, and the main model goes in
diffusion_models/ - ✅ Write the shot, action, characters, camera movement, and sound all in one prompt paragraph; for multiple shots, write them in order in the same paragraph, with dialogue in quotes
- ✅ Choose among the four templates by task: T2V, I2V, and FLF2V largely share models; DFR requires installing ComfyUI-LTXVideo, and its three stages (8/3/4 steps) use keyframe guidance to stack up quality, producing a 48 fps final video
Key configuration fields recap:
| Field | Recommended value | Notes |
|---|---|---|
| Main model | ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors | Distilled int8, shared by all four templates, placed in diffusion_models/ |
| Text encoder | gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors | For DFR, switch to the bf16 full-precision version |
| Enhancer encoder | gemma4_e2b_it_int8_convrot.safetensors (4.84 GB) / gemma4_e2b_it_bf16.safetensors (9.57 GB) | Optional; only needed when prompt_enhance is enabled |
| VAE | ltx-2.5-video-vae-bf16 + ltx-2.5-audio-vae-bf16 | one each for video and audio, placed in vae/ |
| Spatial upscaler | ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors | for T2V/I2V/DFR; not needed for FLF2V |
| Temporal upscaler | ltx-2.5-latent-temporal-upscaler-x2-bf16-1.0.safetensors | DFR stage three only |
| Detail IC-LoRA | ltx-2.5-22b-ic-lora-pixel-spatial-upscaler-x2-1.0.safetensors | DFR only, a separate gated repository, placed in loras/ |
| Resolution | 16:9 / 0.9 MP → 1280×736 | via ResolutionSelector, a multiple of 32 |
| Duration / frame rate | duration 5 / fps 24 | DFR defaults to 121 frames, doubled to 241 frames in stage three 48 fps |
| Sampling | euler_ancestral (T2V) / euler (DFR), CFG 1, 8+3 steps (DFR +4) | Distillation recipe, don't change it arbitrarily |
| Negative prompt | the template ships with a default | keep it unchanged |
Next lesson preview
The model×task workflow chapter ends here—you now know how to pick models by task. The next lesson moves into the e-commerce practice chapter: E-commerce image practice: from white-background images to product videos, applying the generation capabilities you've learned to real business scenarios. You will learn:
- Product cutout and background replacement: BiRefNet locally, Qwen-2.1 transparent background, Bria in the cloud
- Product image upscaling: conservative upscaling and Z-Image-Turbo 2K
- Product mockups and virtual try-on: placing design drafts onto real items
- Product videos: bringing product images to life (using the video models from this chapter)
Appendix: source code reference
— click to expand and view source code locations
Last updated: 2026-11-06 (template library templates video_ltx2_5_t2v / video_ltx2_5_i2v / video_ltx2_5_flf2v / video_ltx2_5_dfr_i2v, officially marked minimum ComfyUI version 0.32.0, DFR template 0.35.0 and requires ComfyUI-LTXVideo)
| Content | Location |
|---|---|
| Official tutorial (LTX-2.5 four workflows) | https://docs.comfy.org/tutorials/video/ltx/ltx-2-5 |
| Official tutorial (LTX-2.5 DFR three stages) | https://docs.comfy.org/tutorials/video/ltx/ltx-2-5-dfr |
| Workflow template JSON (T2V) | https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_ltx2_5_t2v.json |
| Workflow template JSON (DFR) | https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_ltx2_5_dfr_i2v.json |
| Weights repository (Hugging Face, application required) | https://huggingface.co/Lightricks/LTX-2.5 |
| Detail IC-LoRA repository (application required) | https://huggingface.co/Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler |
| Encoder mirror (ModelScope) | https://modelscope.cn/models/Comfy-Org/gemma-4 |
| Custom nodes (required for DFR) | https://github.com/Lightricks/ComfyUI-LTXVideo |
| Cloud API version of the tutorial | https://docs.comfy.org/tutorials/partner-nodes/lightricks/ltx-2-5 |
The parameters on this page (subgraph default 1280×736 cached values come from ResolutionSelector 16:9/0.9 MP, duration 5, frame_rate 24, prompt_enhance off by default, two-stage sampling 8+3 steps euler_ancestral CFG 1, DFR three stages 8/3/4 steps euler, 121→241 frames, keyframe guidance strength 0.95, the six model filenames and directories, enhancer encoders 4.84 GB / 9.57 GB, ModelScope mirror repository names, minimum versions for each template 0.32.0 / 0.35.0 and requiresCustomNodes) were all verified against the actual node values and built-in notes in the template JSON video_ltx2_5_t2v.json (repo-notes copy) and video_ltx2_5_dfr_i2v.json (repo-templates original), as well as the minComfyUIVersion field in templates/index.zh.json; multi-shot / 4K HDR / auto-duration / encoder capabilities and prompt tips for the four workflows come from the official tutorial ltx-2-5.mdx; the DFR three-stage mechanism, switches, and boiling/banding caveats come from ltx-2-5-dfr.mdx and the built-in guide note in the DFR template; the cloud API's Pro/Fast tiers come from partner-nodes/lightricks/ltx-2-5.mdx.