How To Use A Community LoRA With LTX-2.5

A LoRA is a small adapter file that teaches an LTX model something new: a style, a motion, a character, a control signal, all without retraining the whole model. It's a set of trainable layers added on top of a frozen base, producing a portable weight file that's a fraction of the base checkpoint's size.

Because LTX is open-weights, the community trains and shares its own. (This is the low-rank adapter for AI models, not the radio protocol or the typeface sharing the name.)

LTX-2.5's transformer is a 22B-parameter dual-stream diffusion model, the same parameter class as LTX-2.3's 22B and not a further scale-up, paired with a new, LTX-specific fine-tuned Gemma 4 12B text encoder. This guide covers loading, tuning, and stacking a community LoRA with LTX-2.5, and what that architecture change means for your existing LTX-2.3 LoRAs.

Do your LTX-2.3 LoRAs still work on LTX-2.5?

Mostly, yes. Per LTX's own testing, the large majority of LoRAs and IC-LoRAs trained on LTX-2.3 run on LTX-2.5 without changes, despite the new text encoder and the move to a split, Comfy-aligned checkpoint pack.

A small number of exceptions exist, so validate any adapter against your actual use case before relying on it in production. Don't assume a LoRA that looks fine in a quick test will hold up across your full range of prompts and settings.

Examples from the LTX Community Library

LTX curates a Community Library: LoRAs, IC-LoRAs, and ComfyUI workflows, each tagged with a license and a compatibility line. A sample of the range:

• CRT LoRA (Apache 2.0, LTX-2.3 LoRA). A late-'80s CRT monitor look: scanlines, phosphor glow, choppy motion.
• IC-LoRA-Cameraman (Apache 2.0, LTX-2.3 IC-LoRA). Transfers camera motion (pan, tilt, zoom, orbit) from a reference video into a new scene.
• Foley (LTX License, LTX-2.3 IC-LoRA), from the LTX team. Generates synced Foley sound for a silent video while suppressing music and speech.
• Clean Plate (LTX License, LTX-2.5 IC-LoRA), from the LTX team. Removes people and their moving shadows from a shot, for VFX cleanup.

Most listings are still tagged LTX-2.3 and, per the note above, run fine on LTX-2.5. Clean Plate is one of the few built and tagged specifically for LTX-2.5. The tag on each listing is the fastest compatibility check before downloading.

What you need before you start

• A GPU with enough VRAM. Official baseline: 32GB+ VRAM, 32GB RAM, ~100GB storage, CUDA 12.7+ (fits the distilled checkpoint with quantization). Full-precision inference on the unquantized dev checkpoint runs closer to an 80GB card per third-party estimates; not an official figure, so confirm against your exact checkpoint before budgeting hardware. Below that, the hosted LTX API is the lower-barrier route, though custom-LoRA loading is an open-source pipeline feature.
• The split LTX-2.5 checkpoint pack: separate safetensors files for transformer, video VAE, audio VAE, duration head, and spatial upscaler, unlike LTX-2.3's monolithic files.
• The correct Gemma root: LTX-2.5 needs its own LTX-fine-tuned Gemma 4 encoder, not Google's stock Gemma 4; the pipeline checks encoder metadata against the checkpoint and fails if they don't match.
• The LoRA file itself, as .safetensors: existing LTX-2.3 ones mostly work; IC-LoRAs also need a reference video or image.

How do you load a community LoRA?

LTX-2.5's pipelines load LoRAs via CLI flags: --lora-paths points at your .safetensors file alongside the pipeline's other required paths, and --lora-scale sets blend strength. For example:

uv run python -m ltx_pipelines.distilled \
 --transformer-path models/ltx-2.5/diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors \
 --text-encoder-path models/ltx-2.5/text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors \
 --video-vae-path models/ltx-2.5/vae/ltx-2.5-video-vae-bf16.safetensors \
 --audio-vae-path models/ltx-2.5/vae/ltx-2.5-audio-vae-bf16.safetensors \
 --duration-head-path models/ltx-2.5/model_patches/ltx-2.5-duration-head-bf16.safetensors \
 --spatial-upsampler-path models/ltx-2.5/latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors \
 --lora-paths /path/to/community_lora.safetensors \
 --lora-scale 0.8 \
 --prompt "A golden retriever running through a sunny meadow, cinematic lighting" \
 --output-path output.mp4


Building in code instead of via CLI? The same pipeline classes expose equivalent arguments. Check --help for exact names, since they vary by pipeline.

Loading a community LoRA in ComfyUI

LTX-2.5 launched with native, day-one ComfyUI support. A LoRA loader node takes your .safetensors file into the sampler, same pattern as before. Just use a template built for LTX-2.5's split checkpoint pack, not an LTX-2.3-era workflow, since the file layout differs.

Tuning the LoRA effect

--lora-scale typically runs 0.8–1.2 for LTX-2.5: lower blends the LoRA with the base model's own behavior, higher applies it more strongly. Change one value at a time with a fixed seed so you can see what the strength actually did.

Stacking multiple LoRAs

Pass multiple paths to --lora-paths to load several at once. Effects are additive, so conflicting LoRAs (e.g. two different character identities) can average out rather than clearly reflecting either. Verify multi-LoRA outputs and adjust scales rather than assuming a clean layer.

A different pipeline for IC-LoRAs

Structural IC-LoRAs (pose, depth, canny, like Clean Plate or IC-LoRA-Cameraman above) use the dedicated ICLoraPipeline instead, which only works with the distilled checkpoint, not the dev checkpoint. They also need a reference video as the source of the control signal, alongside the text prompt. For a Union Control adapter bundling multiple signals, activating one group at a time tends to give cleaner results than running them all together.

Can you make your own community LoRA?

Yes. LTX ships an open-source trainer, and the dev checkpoint is fully trainable. The config-driven workflow carries over from LTX-2.3, with two things to get right: training needs Linux + CUDA (the trainer depends on Triton), and the matching LTX-2.5 Gemma 4 root, not LTX-2.3's Gemma 3 root or a stock Gemma 4 checkpoint.

A separate LTX-2.5-Pre-Trained checkpoint (a raw, non-instruction-tuned base) exists for teams doing heavier fine-tuning rather than a lightweight LoRA. Good results are welcome in the Community Library, which credits every creator.

Where community LoRAs come from

The Community Library at ltx.io/ltx-community is the most direct place to browse LoRAs, crediting each creator and linking to Hugging Face, Civitai, and GitHub. The LTX-2 Community License Agreement covers LTX-2.5: free commercially under $10M ARR, commercial license required above that or when embedded in a product you sell.

Each LoRA also carries its own license (Apache 2.0, MIT, LTX Community License, OpenRAIL, or sometimes none listed) on top of the base model's terms, so check both before commercial use.

Summary

Get the file, load it via --lora-paths and --lora-scale (or ComfyUI's native LTX-2.5 templates), and set a strength. Most existing LTX-2.3 LoRAs carry over, so validate before production and check each listing's compatibility tag in the Community Library.

Structural IC-LoRAs need the separate ICLoraPipeline and the distilled checkpoint. Train your own with the open-source LTX trainer and the LTX-2.5 Gemma 4 root. Check both the base license and each LoRA's own license before commercial use.