# How to Use the LTX-2 Model with ComfyUI: Complete Integration Guide

> Easily integrate the LTX-2 model into ComfyUI with this complete guide. Discover how the LTX-2 checkpoints load seamlessly with the standard Checkpoint Loader for instant use.

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

---

**LTX-2 checkpoints are exported with the `diffusion_model.` prefix automatically applied during training, making them immediately compatible with ComfyUI's standard Checkpoint Loader without requiring conversion scripts or custom nodes.**

The Lightricks LTX-2 repository includes a specialized training framework that handles weight key renaming during the export process. This built-in compatibility layer ensures that any checkpoint saved from the `ltx-trainer` package follows the exact naming convention expected by ComfyUI's native loaders.

## How LTX-2 Ensures ComfyUI Compatibility

The LTX-2 training pipeline performs automatic key transformation during checkpoint serialization. This eliminates the manual conversion steps typically required when moving models between training frameworks and inference UIs.

### Key Renaming During Checkpoint Export

When the trainer saves a checkpoint, it rewrites the state dictionary keys to match ComfyUI's expected format. In [`packages/ltx-trainer/src/ltx_trainer/trainer.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-trainer/src/ltx_trainer/trainer.py) (lines 950-952), the `LtxvTrainer` class applies the following transformation:

```python

# LtxTrainer: convert to Comfy-UI-compatible format (add "diffusion_model." prefix)

state_dict = {f"diffusion_model.{k}": v for k, v in state_dict.items()}

```

This operation prefixes every weight key with `diffusion_model.`, which is the standard naming convention used by ComfyUI's UNet and diffusion model loaders.

### Helper Mapping for Loading

On the consumption side, the LTX-2 core library provides a mapping definition that strips this prefix when loading within Comfy-compatible pipelines. Found in [`packages/ltx-core/src/ltx_core/loader/sd_ops.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/loader/sd_ops.py) (lines 135-138), the `LTXV_LORA_COMFY_RENAMING_MAP` handles the reverse operation:

```python
LTXV_LORA_COMFY_RENAMING_MAP = (
    SDOps("LTXV_LORA_COMFY_PREFIX_MAP").with_matching().with_replacement("diffusion_model.", "")
)

```

This dual-layer approach ensures that exported checkpoints work seamlessly with ComfyUI's native loading mechanisms while maintaining flexibility for other inference pipelines.

## Exporting LTX-2 Checkpoints for ComfyUI

To generate a ComfyUI-compatible checkpoint from your LTX-2 training run, use the standard trainer API. The conversion happens automatically during the save operation:

```python
from ltx_trainer.trainer import LtxvTrainer
from ltx_trainer.config import LtxTrainerConfig

# 1. Load a trainer configuration (e.g. from a YAML file)

cfg = LtxTrainerConfig.from_yaml("configs/my_ltxv.yaml")

# 2. Create the trainer and run training

trainer = LtxvTrainer(cfg)

# ... training loop ...

trainer.train()

# 3. Save a checkpoint (automatically applies ComfyUI-compatible naming)

checkpoint_path = trainer._save_checkpoint()
print(f"Comfy-UI-compatible checkpoint written to: {checkpoint_path}")

```

The resulting file will be saved as a **.safetensors** file in your checkpoints directory, with all weight keys already prefixed with `diffusion_model.` and ready for immediate use in ComfyUI.

## Loading LTX-2 in ComfyUI

Since the exported checkpoint follows ComfyUI's native naming scheme, you can load it using the standard workflow:

1. Copy the `.safetensors` file to your ComfyUI checkpoints folder (typically `ComfyUI/models/checkpoints`).

2. Launch ComfyUI and add a **Checkpoint Loader** node.

3. Select your LTX-2 checkpoint from the dropdown menu.

4. Connect the loader's outputs (**MODEL**, **CLIP**, **VAE**) to your standard generation pipeline (KSampler, VAE Decode, etc.).

No custom nodes or additional conversion steps are required. The checkpoint behaves identically to standard Stable Diffusion models within the ComfyUI node graph.

## Programmatic Loading (Optional)

If you are developing a custom ComfyUI node or need to load the checkpoint programmatically, you can use the same helper that ComfyUI uses internally:

```python
import torch
from comfy import sd

# Path to the exported LTX-2 checkpoint

ckpt_path = "/path/to/ComfyUI/models/checkpoints/model_weights_step_01000.safetensors"

# Load the checkpoint - expects the "diffusion_model." prefix already present

model = sd.load_checkpoint(ckpt_path)

# model now contains the UNet, VAE, and text-encoder weights ready for inference

```

## Summary

- **Automatic prefixing**: The `LtxvTrainer` class in [`packages/ltx-trainer/src/ltx_trainer/trainer.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-trainer/src/ltx_trainer/trainer.py) automatically adds the `diffusion_model.` prefix to all weight keys during checkpoint export.
- **Native compatibility**: Exported **.safetensors** files load directly into ComfyUI's standard Checkpoint Loader without conversion scripts.
- **Bidirectional mapping**: The `LTXV_LORA_COMFY_RENAMING_MAP` in [`sd_ops.py`](https://github.com/Lightricks/LTX-2/blob/main/sd_ops.py) ensures weights can be loaded back into LTX-2 pipelines while maintaining ComfyUI compatibility.
- **No custom nodes required**: Standard ComfyUI installations can load and run LTX-2 models immediately after copying the checkpoint file.

## Frequently Asked Questions

### Do I need to install custom nodes to use LTX-2 with ComfyUI?

No. LTX-2 checkpoints are exported in ComfyUI's native format with the `diffusion_model.` prefix already applied. You can load them immediately using the standard Checkpoint Loader node that comes with ComfyUI. The `ltx-trainer` package handles all necessary key conversions during the export process.

### What file format does LTX-2 export for ComfyUI?

LTX-2 exports checkpoints in the **.safetensors** format. This is the standard, safe tensor serialization format preferred by ComfyUI and the Stable Diffusion ecosystem. The file contains the complete state dictionary with keys prefixed according to ComfyUI's expectations.

### Can I use LoRA checkpoints from LTX-2 in ComfyUI?

Yes. The same key renaming logic applies to both full model checkpoints and LoRA (Low-Rank Adaptation) checkpoints exported from the LTX-2 trainer. The `LTXV_LORA_COMFY_RENAMING_MAP` defined in [`packages/ltx-core/src/ltx_core/loader/sd_ops.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/loader/sd_ops.py) ensures that LoRA weights follow the same compatibility standards, allowing you to use LTX-2 trained LoRAs with ComfyUI's LoRA loading nodes.

### Where does the key renaming happen in the LTX-2 codebase?

The key renaming occurs in two specific locations: first, during checkpoint export in [`packages/ltx-trainer/src/ltx_trainer/trainer.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-trainer/src/ltx_trainer/trainer.py) (lines 950-952) where the `diffusion_model.` prefix is added; and second, in [`packages/ltx-core/src/ltx_core/loader/sd_ops.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/loader/sd_ops.py) (lines 135-138) where the mapping definition is created for loading the checkpoint back into LTX-2 compatible pipelines.