# LTX-2 DistilledPipeline vs. Full-Model Pipelines: When to Use Which for Video Generation

> Discover when to use LTX-2 DistilledPipeline for faster inference and lower VRAM needs versus full-model pipelines for ultimate quality in video generation.

- Repository: [Lightricks/LTX-2](https://github.com/Lightricks/LTX-2)
- Tags: deep-dive
- Published: 2026-08-15

---

**Use the LTX-2 DistilledPipeline when you need faster inference with lower VRAM (roughly half the memory), and switch to full-model pipelines when maximum quality is your priority.**

The LTX-2 video generation framework from Lightricks offers two distinct execution paths: a memory-efficient **DistilledPipeline** that runs a compressed transformer with fewer denoising steps, and **full-model pipelines** that preserve the complete diffusion process. Understanding their architectural differences helps you pick the right tool for your hardware constraints and quality requirements.

## Core Architectural Differences

### Checkpoint Types and Model Size

The fundamental split begins with which weights you load. In [`utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/args.py), the `detect_checkpoint_path` function (lines 460-470) inspects metadata to determine whether you've provided a distilled checkpoint:

- **DistilledPipeline**: Loads `--distilled-checkpoint-path` containing compressed transformer weights (~½ the size of full weights)
- **Full-model pipelines**: Loads `--checkpoint-path` with the complete non-distilled transformer

This size reduction directly translates to lower memory pressure during inference.

### Noise Schedule: Fixed Short vs. Configurable Long

The sigma schedules are hardcoded differently between the two approaches. [`utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/constants.py) (lines 15-24) defines the distilled schedule:

```python

# From utils/constants.py

DISTILLED_SIGMA_VALUES = [14.615, 6.315, 2.865, 1.340, 0.615]  # 5 values, typically 9→4 steps

STAGE_2_DISTILLED_SIGMA_VALUES = [0.615, 0.291, 0.125, 0.029]   # Even shorter for refinement

```

- **DistilledPipeline**: Uses fixed `DISTILLED_SIGMAS` — typically 9 steps reduced to 4 effective steps
- **Full-model pipelines**: Inherit 30-40 step schedules from checkpoint metadata via `DiffusionStage` defaults

## Stage Layout: Two-Stage with Upsampling

### DistilledPipeline Structure

The `DistilledPipeline` in [`distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/distilled.py) implements a specific two-stage strategy:

1. **Stage 1**: Generate video at **½ target resolution** using the distilled sigma schedule
2. **Stage 2**: Upsample 2× and refine with `STAGE_2_DISTILLED_SIGMAS`

This resolution-cascade approach reduces compute in the heavy diffusion steps.

### Full-Model Pipeline Variants

| Pipeline | Stages | Resolution Strategy |
|----------|--------|---------------------|
| `TI2VidOneStagePipeline` ([`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py)) | Single | Generate at full target resolution directly |
| Two-stage HQ ([`ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_two_stages.py)) | Two | Both stages use **full-resolution** diffusion, no distilled schedule |

The full-model two-stage variant still upsamples, but runs the complete transformer and full sigma schedule at both scales — unlike the distilled version's lightweight Stage 1.

## LoRA Compatibility: Distilled-Specific Weights

LoRA loading differs meaningfully. From [`ti2vid_two_stages_hq.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_two_stages_hq.py) (lines 64-77):

- **DistilledPipeline**: Requires `--distilled-lora` with `--distilled-lora-strength-stage-1/2` — these LoRAs are trained specifically for the shortened distilled schedule
- **Full-model pipelines**: Use standard `--lora` arguments with regular LoRA weights trained for full diffusion schedules

You cannot interchange these LoRA types — the schedule mismatch causes degraded output.

## Sampler Behavior: Ancestral vs. Deterministic

The distilled path includes conditional sampler logic. In [`distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/distilled.py) (lines 76-84), `should_use_ancestral_sampler` selects an **ancestral Euler sampler** for newer checkpoints (version ≥ 2.5), adding controlled stochasticity that can improve perceptual quality with fewer steps.

Full-model pipelines default to the deterministic `LTX2Scheduler` unless explicitly overridden.

## VRAM and Performance Trade-offs

According to type hints in [`utils/types.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/types.py) (lines 133-134), the full model requires **~28 GB VRAM** when generating at target resolution.

The DistilledPipeline achieves roughly **half the memory footprint** through:
- Smaller checkpoint size
- Stage 1 operating at reduced resolution
- Fewer active diffusion steps

**Performance summary:**

| Metric | DistilledPipeline | Full-Model Pipelines |
|--------|-------------------|----------------------|
| VRAM | ~14 GB | ~28 GB |
| Inference steps | 4-9 | 30-40 |
| Speed | Faster | Slower |
| Quality | Good (mitigated by Stage 2) | Best |

## Practical Code Examples

### DistilledPipeline: Two-Stage Generation

```python
from ltx_pipelines.model_paths import ModelPaths
from ltx_pipelines.distilled import DistilledPipeline
from ltx_pipelines.utils.args import resolve_cli_params

# Enable distilled mode

args = resolve_cli_params(distilled=True)

paths = ModelPaths(
    transformer=args.distilled_checkpoint_path,
    video_vae=args.video_vae_path,
    audio_vae=args.audio_vae_path,
    spatial_upsampler=args.spatial_upsampler_path,
    duration_head=args.duration_head_path,
)

pipeline = DistilledPipeline(
    model_paths=paths,
    spatial_upsampler_path=args.spatial_upsampler_path,
    loras=args.distilled_lora,  # Distilled-specific LoRA

)

video_iter, audio, tiling_cfg = pipeline(
    prompt="A sunrise over a misty forest",
    seed=42,
    height=720,
    width=1280,
    frame_rate=24.0,
    images=[],
)

```

### Full-Model One-Stage Pipeline

```python
from ltx_pipelines.ti2vid_one_stage import TI2VidOneStagePipeline
from ltx_pipelines.utils.args import resolve_cli_params

# Standard (non-distilled) mode

args = resolve_cli_params(distilled=False)

paths = ModelPaths(
    transformer=args.checkpoint_path,  # Full checkpoint

    video_vae=args.video_vae_path,
    audio_vae=args.audio_vae_path,
    spatial_upsampler=args.spatial_upsampler_path,
    duration_head=args.duration_head_path,
)

pipeline = TI2VidOneStagePipeline(
    model_paths=paths,
    loras=args.lora,  # Standard LoRA

)

video_iter, audio, tiling_cfg = pipeline(
    prompt="A futuristic city at night",
    negative_prompt="low quality, blurry",
    seed=123,
    height=720,
    width=1280,
    frame_rate=30.0,
    num_inference_steps=40,  # Full schedule

    video_guider_params=args.video_guider_params,
    audio_guider_params=args.audio_guider_params,
    images=[],
)

```

## Decision Framework: When to Choose Each

Choose **DistilledPipeline** when:
- VRAM is constrained (16 GB GPUs, consumer hardware)
- Iteration speed matters (prototyping, batch generation)
- Slight quality trade-offs are acceptable

Choose **full-model pipelines** when:
- Maximum fidelity is required (final production renders)
- Hardware budget allows 28+ GB VRAM
- You're using LoRAs trained for standard diffusion schedules

## Key Source Files Reference

| File | Purpose |
|------|---------|
| [`packages/ltx-pipelines/src/ltx_pipelines/distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py) | `DistilledPipeline` implementation, ancestral sampler logic |
| [`packages/ltx-pipelines/src/ltx_pipelines/ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/ti2vid_one_stage.py) | Single-stage full-model pipeline |
| [`packages/ltx-pipelines/src/ltx_pipelines/ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/ti2vid_two_stages.py) | Two-stage full-model pipeline |
| [`packages/ltx-pipelines/src/ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/utils/constants.py) | `DISTILLED_SIGMA_VALUES`, `STAGE_2_DISTILLED_SIGMA_VALUES` |
| [`packages/ltx-pipelines/src/ltx_pipelines/utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/utils/args.py) | `detect_checkpoint_path`, CLI argument routing |
| [`packages/ltx-pipelines/src/ltx_pipelines/utils/types.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/utils/types.py) | VRAM requirement documentation |

## Summary

- **DistilledPipeline** uses compressed checkpoints, fixed short sigma schedules, and a two-stage resolution cascade to deliver ~2× memory efficiency and faster inference
- **Full-model pipelines** preserve complete transformer weights and full diffusion schedules for maximum quality at ~28 GB VRAM cost
- **LoRA weights are not interchangeable** — distilled pipelines require schedule-matched distilled LoRAs
- **Source implementation** lives in [`distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/distilled.py) vs. [`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py)/[`ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_two_stages.py), with configuration handled through [`utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/args.py)

## Frequently Asked Questions

### Can I switch between distilled and full-model pipelines without changing checkpoints?

No. The `--distilled-checkpoint-path` and `--checkpoint-path` arguments load fundamentally different weight formats. The `detect_checkpoint_path` function in [`utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/args.py) validates checkpoint metadata and routes to the appropriate pipeline class. Attempting to load a distilled checkpoint into a full-model pipeline (or vice versa) will fail at initialization.

### Why does the DistilledPipeline use an ancestral sampler for newer checkpoints?

The `should_use_ancestral_sampler` check in [`distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/distilled.py) (lines 76-84) enables stochastic sampling for checkpoint versions ≥ 2.5. This injects controlled noise during generation, which helps compensate for the reduced step count by improving sample diversity and perceptual richness that deterministic schedules might flatten with fewer iterations.

### How much quality do I actually lose with the DistilledPipeline?

The trade-off is modest and context-dependent. Stage 2's 2× upsampling with `STAGE_2_DISTILLED_SIGMA_VALUES` recovers significant detail. In practice, the distilled output suits most preview and production use cases, while full-model pipelines excel for high-stakes final renders where diffusion artifacts must be minimized. Benchmark against your specific quality bar using identical seeds.

### Can I use the same LoRA on both pipeline types?

No. Distilled LoRAs are trained on the shortened sigma schedule and expect the fixed `DISTILLED_SIGMAS` distribution. Standard LoRAs assume the full 30-40 step diffusion trajectory. The `distilled_lora` and `lora` argument namespaces in [`utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/args.py) exist precisely because these training regimes produce incompatible weight adaptations.