> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs-dev.ltx.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs-dev.ltx.io/_mcp/server.

# Text-to-Video Workflow for Beginners

> Generate a video with synchronized audio from a text prompt using the built-in LTX-2.5 Text-to-Video ComfyUI template.

This tutorial shows you how to generate a video with synchronized audio entirely from a text prompt, using the built-in **LTX-2.5 Text-to-Video** template in ComfyUI.

## When to Use

Text-to-Video is the right starting point when you want to explore a concept from scratch, test a style or mood, or generate a scene where you don't have a specific frame to anchor from. If you have a source image you want to animate, see the [Image-to-Video guide](/open-source-model/usage-guides/image-to-video) instead.

## Step-by-Step Guide

> **Note**
>
> This guide assumes ComfyUI is already installed. If not, see the [ComfyUI download page](https://comfy.org/download) and our [ComfyUI setup guide](/open-source-model/integration-tools/comfy-ui), and check the [system requirements](/open-source-model/getting-started/system-requirements) to confirm your hardware is supported.

### 1. Load the Template and Download Models

1. Open ComfyUI.
2. Click the **Templates** button and search **LTX-2.5**.
3. Select the **Text-to-Video** template (`video_ltx2_5_t2v`). The workflow loads as a node graph with everything pre-configured.
4. Open the **Workflow Overview** panel. On first use it lists **Missing Models**.
5. Click **Download all** to fetch the model files directly in ComfyUI.

> **Note**
>
> You only download the models once — they're reused on every run.

The template uses these files (also on the [LTX-2.5 HuggingFace repository](https://huggingface.co/Lightricks/LTX-2.5) if you prefer to download them manually):

| File                                                      | Purpose                                                                  | Placement                               |
| --------------------------------------------------------- | ------------------------------------------------------------------------ | --------------------------------------- |
| `ltx-2.5-22b-distilled-transformer-bf16.safetensors`      | Distilled model                                                          | `ComfyUI/models/diffusion_models/`      |
| `gemma4-12b-with-proj-ltx-2.5-bf16.safetensors`           | Gemma 4 text encoder                                                     | `ComfyUI/models/text_encoders/`         |
| `gemma4_e2b_it_bf16.safetensors`                          | Gemma 4 prompt enhancer (from `Comfy-Org/gemma-4`, not the LTX-2.5 repo) | `ComfyUI/models/text_encoders/`         |
| `ltx-2.5-video-vae-bf16.safetensors`                      | Video VAE                                                                | `ComfyUI/models/vae/`                   |
| `ltx-2.5-audio-vae-bf16.safetensors`                      | Audio VAE                                                                | `ComfyUI/models/vae/`                   |
| `ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors` | Spatial upscaler (2×)                                                    | `ComfyUI/models/latent_upscale_models/` |

### 2. Write Your Prompt

The prompt is the most important input in a Text-to-Video workflow. Without visual guidance, the model relies entirely on your description to build the scene. See the [Prompting Guide](/open-source-model/usage-guides/prompting-guide) for detailed tips.

The template turns on **Prompt Enhance** by default, which expands a short prompt into a more detailed one before it's encoded. Turn it off to use your prompt exactly as written.

### 3. Set Resolution, Length, and Frame Rate

The template's defaults are a fast, low-VRAM starting point:

| Parameter      | Default   | Notes                                                                                   |
| -------------- | --------- | --------------------------------------------------------------------------------------- |
| **Width**      | 768       | Base resolution. Must be divisible by 32.                                               |
| **Height**     | 512       | Base resolution.                                                                        |
| **Length**     | 97 frames | Frame count must be `1 + a multiple of 8` (e.g. 97 = 1 + 96).                           |
| **Frame rate** | 24 fps    | 24 for cinematic, 25 standard, 30 for smoother motion. 97 frames at 24 fps ≈ 4 seconds. |

The pipeline generates at the base resolution, then upscales **2×** in the second stage — so the final output is double the width and height you set (768×512 → 1536×1024 by default).

> **Warning**
>
> Higher resolution and longer length need more VRAM. Start near the defaults for testing and increase once you know your hardware handles it.

### 4. Generate

Click **Run**. The template runs a two-stage pipeline automatically:

1. **Stage 1** — generates video and audio together at the base resolution.
2. **Upscale** — the video latent is upscaled 2× by the spatial upscaler.
3. **Stage 2** — refines the upscaled video at full resolution.

Audio is generated jointly with the video in Stage 1 and carried through to the final output.

### 5. Review and Iterate

The output saves as an MP4 with synchronized audio. To iterate:

* **Change the prompt** and re-run to explore different scenes.
* **Adjust length** if the video is too short or long for your content.
* **Try different resolutions** to match your target format (landscape, portrait, square).

> **Note**
>
> The Stage 1 seed randomizes by default, so each run differs. To reproduce a result, note its seed and switch the seed control from randomize to fixed.

## How the Pipeline Works

Understanding the two-stage pipeline helps when troubleshooting or fine-tuning results.

**Model loading:** The template loads the distilled transformer directly (no separate base model or distilled LoRA), the Gemma 4 text encoder and prompt enhancer, and the video and audio VAEs. A negative prompt (`"pc game, console game, video game, cartoon, childish, ugly"`) is applied automatically.

**Stage 1 (base resolution):** Empty video and audio latents are created and concatenated into a single audio-video latent, then sampled together with the `euler_ancestral` sampler and a dual-CFG guider (CFG 1 for both video and audio) on a fixed distilled sigma schedule. Sampling them jointly is what keeps audio and video in sync. The audio and video latents are then separated.

**Upscale:** The video latent passes through the spatial upscaler, doubling its resolution.

**Stage 2 (full resolution):** The upscaled video latent is recombined with the Stage 1 audio latent and refined — sharpening detail without regenerating the composition.

**Decode:** Video decodes through tiled VAE decoding (to keep VRAM down), audio through the audio VAE, and the two are merged into the final file.

## Advanced Techniques

The built-in template gets you generating quickly with sensible defaults. For more control, move to a fuller workflow.

### Recommended Next Step

Once you're comfortable with the template, the [Two-Stage Generation](/open-source-model/usage-guides/two-stage-generation) workflow uses the same two-stage structure but runs the full-precision base model with the distilled LoRA applied, and adds a higher-quality **Full** sampler path plus direct control over settings the template handles automatically. Everything you've learned here still applies.

### Distilled vs. Full

The template uses the **distilled** model — optimized to produce good results in a few steps, which makes it fast and ideal for iteration. The **full** model (in the Two-Stage Generation workflow) takes more steps but can yield finer detail and more nuanced motion. Match the model and workflow to best meet your needs and available hardware.

### Using LoRAs

The official template does not include a standard-LoRA node. For a compatible standard LoRA, manually insert ComfyUI's `LoraLoaderModelOnly` after the shared **Model** output and route its modified `MODEL` output to both sampler stages. See the [LoRA guide](/open-source-model/usage-guides/lo-ra).

### Python

Text-to-Video is also available through the PyTorch API for programmatic use. See the [PyTorch API documentation](/open-source-model/integration-tools/pytorch-api).