Skip to content

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:

UpgradeDescription
Multishot narrativeGenerates multiple coherent shots in one pass, keeping characters, environments, lighting, audio, and style consistent across cuts
Gemma 4 12B custom encoderRemembers multiple subjects, actions, lighting, and camera movements in complex prompts
DFR pipelineKeyframe-first rendering path: allocates rendering compute based on scene complexity for higher final quality
Diffusion video decoderClearer faces, readable text, and less motion blur in fast movement
Auto DurationThe official introduction says the model predicts an appropriate duration based on the actions described in the prompt before diffusion
Native 4K HDROfficially listed as outputting up to 4K HDR at 50 FPS, with a RAW workflow for professional post-production pipelines
Better distilled versionThe 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 versionInputExtra requirements
LTX-2.5: text-to-videov0.32.0PromptNone
LTX-2.5: image-to-videov0.32.0First-frame imageNone
LTX-2.5: FLF2Vv0.32.0First frame + last frame imagesNone
LTX-2.5 DFR: image-to-videov0.35.0First-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.

  1. Update ComfyUI to the latest version (use the built-in updater on desktop, or run the update_comfyui update script on the portable version)
  2. Log in to Hugging Face, open the repository Lightricks/LTX-2.5, read and agree to the usage terms, and submit an access request
  3. 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
  4. 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.

FileSizeDestination directoryPurpose
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.safetensors4.84 GBmodels/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:

text
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.

  1. 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)
  2. Click to load it
  3. Get familiar with the Text to Video (LTX-2.5) subgraph node on the canvas, with the following parameters:
ParameterTemplate DefaultDescription
PromptComes with an English example (Arctic hunter)Write visuals + audio together, see step 4
prompt_enhanceOffPrompt enhancer: when on, it uses a 4.84 GB small encoder to expand your prompt first, costing an extra 1–2 minutes
ResolutionSelector16:9 / 0.9 MPAspect ratio + megapixel budget, automatically converted to width and height in multiples of 32; 0.9 MP corresponds to 1280×736
duration5Duration (seconds)
frame_rate24Frame rate
seedRandomFix the seed for easy reproduction
  1. Without changing anything, just press Ctrl+Enter to run it once and confirm the pipeline can produce a video
  2. 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 LTXVLatentUpsampler upsamples 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:

  1. Write the entire scene in one flowing passage of text: shot type, scene, actions, characters, and camera movement all in this single passage
  2. 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
  3. 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):

text
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 duration parameter 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.

TemplateInputHow to write the prompt
LTX-2.5: Image to VideoOne first-frame imageWrite 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: FLF2VFirst-frame image + last-frame imageWrite 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:

  1. Search "LTX-2.5" in the template library and load the image-to-video or FLF2V template
  2. 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 examples robot_hand.png / robot_hand_energy.png)
  3. Subgraph parameters are the same as T2V: prompt, resolution, duration, frame rate, seed
  4. 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:

  1. Update ComfyUI to v0.35.0 or later, and install the custom node package ComfyUI-LTXVideo (nodes like LTXVAddGeneratedKeyframes in the DFR template come from this package; install it by searching "LTXVideo" in ComfyUI Manager)
  2. Add three model files (the DFR model set differs from the earlier ones):
FileSizePut in directoryNotes
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:

StageRuns at what sizeStepsWhat it does
1 GenerationHalf of the output size8Denoises the video, one detail keyframe per second, and audio together
2 Spatial ×2Output size3Resamples after upscaling the latent space ×2, attaches the detail IC-LoRA, and injects the half-resolution latent as reference
3 Temporal ×2241 frames @ 48 fps4Doubles 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:

SwitchLocationEffect
Start image (I2V)Top levelUpload the first-frame image (default example office_garden_169_outpaint.png)
Output sizeTop levelAspect ratio + megapixel budget, ×32; the first stage automatically runs at half of it
Switch to T2VInside the subgraphWhen enabled, ignores the first-frame image and generates from text only
Float (fps) / Float (Duration)Inside the subgraphDefaults to 24 fps / 5 seconds = 121 frames
Enable Prompt EnhancerInside the subgraphExpands the prompt first with the small encoder (requires the 9.57 GB bf16 version)
Run 3rd stage - Temporal UpscaleInside the subgraphTurn off to skip the third stage: faster, outputs 24 fps / 121 frames
Enable Tiled DecodeInside the subgraphTiled VAE decoding, reduces VRAM usage, slightly softer details

DFR prompts differ from T2V; the official guidance gives three rules:

  1. 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
  2. Generate audio in the same pass: put dialogue in quotes and describe ambient sounds and sound effects
  3. 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 fps

  • The 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 prompt

  • Get 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:

MegapixelsWidth×Height
0.2608×352
0.5960×544
0.9 (default)1280×736
1.01376×768
2.01920×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.5 and 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:

FieldRecommended valueNotes
Main modelltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensorsDistilled int8, shared by all four templates, placed in diffusion_models/
Text encodergemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensorsFor DFR, switch to the bf16 full-precision version
Enhancer encodergemma4_e2b_it_int8_convrot.safetensors (4.84 GB) / gemma4_e2b_it_bf16.safetensors (9.57 GB)Optional; only needed when prompt_enhance is enabled
VAEltx-2.5-video-vae-bf16 + ltx-2.5-audio-vae-bf16one each for video and audio, placed in vae/
Spatial upscalerltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensorsfor T2V/I2V/DFR; not needed for FLF2V
Temporal upscalerltx-2.5-latent-temporal-upscaler-x2-bf16-1.0.safetensorsDFR stage three only
Detail IC-LoRAltx-2.5-22b-ic-lora-pixel-spatial-upscaler-x2-1.0.safetensorsDFR only, a separate gated repository, placed in loras/
Resolution16:9 / 0.9 MP → 1280×736via ResolutionSelector, a multiple of 32
Duration / frame rateduration 5 / fps 24DFR defaults to 121 frames, doubled to 241 frames in stage three 48 fps
Samplingeuler_ancestral (T2V) / euler (DFR), CFG 1, 8+3 steps (DFR +4)Distillation recipe, don't change it arbitrarily
Negative promptthe template ships with a defaultkeep 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)

ContentLocation
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 tutorialhttps://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.

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.