# The Quickest LTX-2 Pipeline for Prototyping: One-Stage Text-to-Video Generation

> Discover the fastest LTX-2 pipeline for prototyping with the one-stage text-to-video model. Generate videos quickly in a single pass, reducing processing time and memory usage.

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

---

**The quickest LTX-2 pipeline for prototyping is the single-stage text-to-video implementation in [`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py), which completes the entire diffusion process in one pass without upscaling or super-resolution stages, minimizing preprocessing and memory transfers while supporting optional image conditioning and audio generation.**

Lightricks/LTX-2 provides multiple inference configurations, but the one-stage pipeline offers the fastest path from prompt to video output. By eliminating the computationally expensive two-stage upsampling process used in production-quality pipelines, this configuration reduces runtime significantly while maintaining the core diffusion capabilities needed for rapid experimentation. The implementation consolidates model loading, diffusion, and decoding into a streamlined workflow defined in [`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).

## Why the One-Stage Pipeline is Fastest

The **one-stage pipeline** executes the entire generation process in a single diffusion loop. Unlike the two-stage variants (`ti2vid_two_stages*`) that require intermediate latent-to-latent upsampling steps, this implementation decodes latents directly to video and audio after the initial diffusion stage.

This architecture minimizes:

- **Memory transfers** between pipeline stages
- **Preprocessing overhead** from multiple model initializations  
- **I/O operations** by sharing checkpoints and device contexts across components

The pipeline instantiates `PromptEncoder`, `ImageConditioner`, a single `DiffusionStage`, and decoders for video and audio—all sharing the same checkpoint and device context. This consolidation avoids redundant model loading and keeps the entire generation workflow in GPU memory.

## Core Architecture and Components

### Model Loading and Initialization

In [`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), the pipeline initializes all required components in a single configuration block. The **model loading** sequence creates:

- `PromptEncoder` for text conditioning
- `ImageConditioner` for optional image inputs  
- A single `DiffusionStage` for the noise-to-latent process
- `VideoDecoder` and `AudioDecoder` for final output generation

All components share the same checkpoint path and device placement, eliminating the latency of sequential model transfers.

### Diffusion and Guidance

The diffusion process utilizes **classifier-free guidance (CFG)** through the `create_multimodal_guider_factory` function. This creates optional multimodal guiders for both video and audio generation.

The pipeline executes a single diffusion loop using a sigma schedule generated by `LTX2Scheduler`. No intermediate latent refinement steps are required, as the diffusion stage outputs final latents ready for decoding.

### Direct Decoding

Following the diffusion loop, the pipeline decodes latents directly to final media formats:

- `VideoDecoder` converts latent representations to video frames
- `AudioDecoder` generates synchronized audio tracks

This direct path bypasses the upscaling stages that characterize the two-stage pipelines, significantly reducing per-sample generation time.

## Implementation Methods

### Python API Integration

For programmatic prototyping, instantiate the `TI2VidOneStagePipeline` class directly:

```python
import torch
from ltx_pipelines.ti2vid_one_stage import TI2VidOneStagePipeline
from ltx_pipelines.utils.args import detect_checkpoint_path, detect_params
from ltx_pipelines.utils.constants import MultiModalGuiderParams

# Detect checkpoint and load optimized defaults

ckpt = detect_checkpoint_path()
params = detect_params(ckpt)

# Initialize the one-stage pipeline

pipeline = TI2VidOneStagePipeline(
    checkpoint_path=ckpt,
    gemma_root="/path/to/gemma",
    loras=(),
    quantization=None,
    offload_mode=None,
)

# Generate video with minimal configuration

video, audio = pipeline(
    prompt="A sunrise over a calm lake",
    negative_prompt="low quality, blurry",
    seed=42,
    height=512,
    width=768,
    num_frames=8,
    frame_rate=24.0,
    num_inference_steps=params.num_inference_steps,
    video_guider_params=MultiModalGuiderParams(cfg_scale=3.0),
    audio_guider_params=MultiModalGuiderParams(cfg_scale=7.0),
    images=[],
)

# Export results using the built-in encoder

from ltx_pipelines.utils.media_io import encode_video
encode_video(video, fps=24.0, audio=audio, output_path="quick_demo.mp4")

```

This approach leverages `detect_params` from [`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 automatically configure checkpoint-specific defaults, including inference steps and resolution settings.

### Command-Line Interface

For rapid testing without code modification, use the built-in `main()` entry point:

```bash
python -m ltx_pipelines.ti2vid_one_stage \
    --checkpoint-path /path/to/checkpoint.safetensors \
    --gemma-root /path/to/gemma \
    --prompt "A sunrise over a calm lake" \
    --seed 42 \
    --num-frames 8 \
    --output-path quick_demo.mp4

```

The command-line parser in [`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) handles argument validation and automatically applies default parameters through `detect_params`, streamlining the prototyping workflow.

## Configuration Optimization

### Parameter Detection

The `detect_params` function 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) automatically infers optimal settings from your checkpoint metadata. This eliminates manual tuning for:

- Inference step counts
- Resolution configurations  
- Sigma schedule parameters

### Memory and Speed Trade-offs

For fastest iteration:

- Set `quantization=None` to use native fp16/bfloat16 precision
- Keep `offload_mode=None` to retain models in GPU memory between runs
- Limit `num_frames` to 8-16 for initial concept validation
- Use `loras=()` to skip adapter loading when not required

## Summary

- **The one-stage pipeline** in [`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py) provides the fastest LTX-2 prototyping path by eliminating upscaling stages.
- **Single-pass diffusion** using `DiffusionStage` and `LTX2Scheduler` generates final latents without intermediate refinement.
- **Shared device context** across `PromptEncoder`, `ImageConditioner`, and decoders minimizes memory transfers and I/O overhead.
- **Automatic parameter detection** via `detect_params` in [`utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/constants.py) configures optimal defaults for your specific checkpoint.
- **Both Python API and CLI** entry points support rapid iteration, with the Python `TI2VidOneStagePipeline` class offering granular control for experimentation.

## Frequently Asked Questions

### What is the difference between the one-stage and two-stage LTX-2 pipelines?

The one-stage pipeline executes diffusion and decoding in a single pass, while two-stage pipelines (`ti2vid_two_stages*`) add an intermediate upsampling or super-resolution step. The two-stage approach produces higher quality output but requires significantly more computation time and memory bandwidth, making the one-stage variant preferable for rapid prototyping.

### Can I use image conditioning with the quickest pipeline?

Yes. The `TI2VidOneStagePipeline` accepts an `images` parameter that passes through the `ImageConditioner` component. You can provide conditioning images via the Python API `images` list or through the command-line interface using the parser utilities in [`utils/args.py`](https://github.com/Lightricks/LTX-2/blob/main/utils/args.py).

### What hardware specifications are required for fast prototyping?

The one-stage pipeline runs efficiently on a single high-end GPU such as an RTX 4090, typically completing short clips (8-16 frames) within minutes. The pipeline avoids the memory overhead of two-stage processing by keeping all components (`PromptEncoder`, `DiffusionStage`, and decoders) in device memory without intermediate offloading.

### How do I customize default parameters for faster iteration?

Default parameters are loaded via `detect_params` 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), which reads checkpoint-specific configurations. For custom values, pass explicit arguments to the `TI2VidOneStagePipeline` constructor or override CLI flags. Reducing `num_inference_steps` and resolution (height/width) provides the most significant speed improvements for iterative testing.