# How 8-Step Distilled Inference Works in LTX-2

> Discover how LTX-2's 8-step distilled inference accelerates diffusion models. Learn about its fixed 8-step schedule and hardcoded sigma tensors for efficient, variable-free configuration.

- Repository: [Lightricks/LTX-2](https://github.com/Lightricks/LTX-2)
- Tags: internals
- Published: 2026-06-20

---

**LTX-2 replaces the traditional 30–40 step diffusion process with a fixed 8-step distilled inference schedule that runs eight denoising steps at low resolution followed by three refinement steps after upsampling, using hardcoded sigma tensors that eliminate the need for variable inference configuration.**

LTX-2 ships with a distilled variant that trades iterative sampling for deterministic speed. This **8-step distilled inference** pipeline, implemented in [`packages/ltx-pipelines/src/ltx_pipelines/distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py), relies on pre-computed sigma schedules defined in [`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) to generate video in exactly two stages without exposing a `num_inference_steps` parameter.

## Fixed Sigma Schedules in LTX-2 Distilled Inference

The distilled pipeline operates on **hard-coded sigma tensors** created at import time. These tensors define the noise levels for each timestep and cannot be modified at runtime, ensuring deterministic latency across generations.

### Stage 1 Low-Resolution Denoising (8 Steps)

The first stage uses the `DISTILLED_SIGMAS` tensor containing nine values that define eight denoising intervals:

```python
DISTILLED_SIGMAS = [1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0]

```

According to the source code at lines 14–22 of [`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), this schedule generates video at half the target resolution. The diffusion loop iterates exactly eight times, with each step corresponding to the interval between consecutive sigma values.

### Stage 2 Upsampling Refinement (3 Steps)

After upsampling with `VideoUpsampler`, the second stage applies the `STAGE_2_DISTILLED_SIGMAS` tensor for final refinement:

```python
STAGE_2_DISTILLED_SIGMAS = [0.909375, 0.725, 0.421875, 0.0]

```

This creates three additional denoising steps, bringing the total to eleven steps (eight plus three), though the architecture is referred to as **8-step distilled inference** based on the primary stage. The stage 2 sigmas begin at 0.909375 to match the tail end of the stage 1 schedule, ensuring smooth transitions between resolutions.

## Two-Stage Generation Pipeline Architecture

The `DistilledPipeline` class orchestrates generation through two distinct diffusion stages that share the same `DiffusionStage` object. Both stages utilize the `SimpleDenoiser` class from [`packages/ltx-pipelines/src/ltx_pipelines/utils/denoisers.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/utils/denoisers.py), which performs **non-guided denoising** without classifier-free guidance (CFG) or style conditioning.

The process flows as follows:

1. **Prompt encoding** converts text inputs into video and audio contexts.
2. **Stage 1** passes `stage_1_sigmas` to the denoiser, executing eight diffusion steps to produce a low-resolution latent.
3. **Spatial upsampling** via `VideoUpsampler` doubles the latent resolution.
4. **Stage 2** runs `stage_2_sigmas` through three additional diffusion steps for refinement.
5. **Decoding** converts the final latent to video and audio via `VideoDecoder` and `AudioDecoder`.

As implemented in [`packages/ltx-pipelines/src/ltx_pipelines/distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py) (lines 99–101), the pipeline accepts the fixed sigma tensors as arguments to the `__call__` method, ensuring reproducible behavior across runs.

## Why Eight Steps? The Distillation Strategy

The eight-step schedule represents the output of a **distillation process** where the full 30–40 step diffusion model is compressed into a minimal step count while preserving output quality. The nine sigma values in `DISTILLED_SIGMAS` are specifically tuned so that each step corresponds to a meaningful denoising jump that matches the latent distribution of the full model.

This design eliminates the `num_inference_steps` parameter entirely for distilled models. The schedule is documented in the repository's [`CLAUDE.md`](https://github.com/Lightricks/LTX-2/blob/main/CLAUDE.md) file (lines 39–41), which confirms that distilled pipelines use a fixed schedule rather than exposing step configuration to users.

## Implementing 8-Step Distilled Inference in Python

To run the distilled pipeline, import `DistilledPipeline` from the distilled module and initialize it with the required checkpoint paths:

```python
from ltx_pipelines.distilled import DistilledPipeline
from ltx_pipelines.utils.args import detect_checkpoint_path, default_2_stage_distilled_arg_parser

# Locate distilled model weights

checkpoint = detect_checkpoint_path(distilled=True)

# Configure arguments

parser = default_2_stage_distilled_arg_parser()
args = parser.parse_args([
    "--distilled_checkpoint_path", checkpoint,
    "--gemma_root", "/path/to/gemma",
    "--spatial_upsampler_path", "/path/to/upsampler",
    "--prompt", "A sunrise over a calm lake",
    "--seed", "42",
    "--height", "720",
    "--width", "1280",
    "--num_frames", "24",
    "--frame_rate", "24",
])

# Initialize pipeline

pipeline = DistilledPipeline(
    distilled_checkpoint_path=args.distilled_checkpoint_path,
    gemma_root=args.gemma_root,
    spatial_upsampler_path=args.spatial_upsampler_path,
    loras=(),
)

# Execute 8-step stage 1 + 3-step stage 2

video, audio = pipeline(
    prompt=args.prompt,
    seed=args.seed,
    height=args.height,
    width=args.width,
    num_frames=args.num_frames,
    frame_rate=args.frame_rate,
)

```

For command-line execution, use the module entry point:

```bash
python -m ltx_pipelines.distilled \
    --distilled_checkpoint_path <ckpt> \
    --gemma_root <gemma_dir> \
    --spatial_upsampler_path <upsampler_ckpt> \
    --prompt "A sunrise over a calm lake" \
    --height 720 \
    --width 1280 \
    --num_frames 24 \
    --output_path result.mp4

```

## Summary

- **8-step distilled inference** in LTX-2 uses fixed sigma tensors (`DISTILLED_SIGMAS` and `STAGE_2_DISTILLED_SIGMAS`) defined in [`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).
- The pipeline runs a **two-stage generation process**: eight denoising steps at low resolution followed by three refinement steps after upsampling.
- The `DistilledPipeline` class in [`packages/ltx-pipelines/src/ltx_pipelines/distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py) does not expose `num_inference_steps`; the schedule is hard-coded for deterministic latency.
- Both stages use `SimpleDenoiser` without classifier-free guidance, making inference significantly faster than the full model.
- Memory is released after each call, allowing pipeline reuse without GPU state accumulation.

## Frequently Asked Questions

### Can I change the number of inference steps in LTX-2 distilled mode?

No. The **8-step distilled inference** pipeline uses hard-coded sigma schedules that are baked into the model weights. Unlike the full diffusion model, the distilled variant in [`packages/ltx-pipelines/src/ltx_pipelines/distilled.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py) does not accept a `num_inference_steps` argument. The `DISTILLED_SIGMAS` tensor contains exactly nine values defining eight intervals, and this schedule is fixed at import time.

### What is the difference between Stage 1 and Stage 2 in the distilled pipeline?

Stage 1 generates video at half the target resolution using the full `DISTILLED_SIGMAS` schedule (eight steps). Stage 2 begins after `VideoUpsampler` doubles the spatial resolution, applying the `STAGE_2_DISTILLED_SIGMAS` schedule (three steps) to refine details and reduce artifacts introduced during upsampling. Both stages share the same `DiffusionStage` object but operate on different sigma tensors.

### Why does the distilled pipeline use SimpleDenoiser instead of CFG?

The distilled pipeline uses `SimpleDenoiser` (defined in [`packages/ltx-pipelines/src/ltx_pipelines/utils/denoisers.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/utils/denoisers.py)) because the distillation process encodes guidance directly into the model weights. This eliminates the need for classifier-free guidance (CFG), which typically requires doubling the UNet forward passes. The result is faster inference with fewer memory allocations while maintaining output quality comparable to guided sampling.

### How do the sigma values translate to actual denoising steps?

Each sigma tensor defines the noise levels at the boundaries of denoising steps. The `DISTILLED_SIGMAS` tensor contains nine floating-point values, which create **eight denoising intervals** (steps). Similarly, `STAGE_2_DISTILLED_SIGMAS` contains four values creating three intervals. The diffusion loop iterates once per interval, with the model predicting noise to move from the current sigma level to the next.