Run LTX-2 and LTX-2.5 in ComfyUI on a cloud GPU

LTX-2.5 is the LTX model I would run today: Lightricks' 22B open-weight model that generates a video and its soundtrack together, free for commercial use until your company reaches $10M in annual revenue. ComfyUI's template loads 39.71 GB of files (our calculation), and Lightricks asks for a GPU with at least 32 GB, so a 48 GB card runs it and the 96 GB RTX PRO 6000 Blackwell has room for the full-precision files. LTX-2 and LTX-2.3 are the earlier 19B and 22B releases, and I would only pick them for a workflow or LoRA that was built on them.

LTX-2, LTX-2.3 and LTX-2.5 compared#

The three releases are one family: a diffusion transformer that produces synchronized video and audio in a single model, with a Gemma text encoder beside it.

LTX-2's own model card now names LTX-2.3 as its newer version, and Lightricks' documentation is written for LTX-2.5. LTX-Video, the 2B and 13B models people still search for as LTXV, is the line before these. ComfyUI still ships LTXV templates, but I would start new work on LTX-2.5.

What the licence allows, in Lightricks' words#

The licence is permissive for small companies and paid for large ones. The LTX-2.x Community License, which covers LTX-2.5, grants a worldwide licence to use the model "for any purpose, subject to the restrictions set forth in Attachment A", with one condition: "Entities with annual revenues of at least $10,000,000" are "required to obtain a paid license for any use". A company above that line may still test and evaluate the model in a non-production environment without one.

LTX-2 and LTX-2.3 fall under the earlier LTX-2 Community License, which has the same $10M threshold and the same clause on competing products. One difference sits in the text encoder: LTX-2 and LTX-2.3 use Gemma 3, which Google publishes under its own Gemma terms, while Google's Gemma 4 repositories carry an Apache-2.0 tag. The text I quote is the version on Lightricks' repository on 2026-11-12, amended on October 29, 2026. Read it before you ship a product, and treat this section as a summary, not legal advice.

The LTX-2.5 checkpoints and their sizes#

LTX-2.5 ships as separate files, one per component, in a gated Hugging Face repository. These are the ones that matter in ComfyUI.

The five files the text-to-video and image-to-video templates need come to 39.71 GB, or 44.91 GB with the prompt enhancer. The same five files at 16-bit, the set Lightricks' own documentation lists first, come to 71.11 GB, or 81.39 GB with the 16-bit prompt enhancer (our calculation).

The earlier models are single checkpoints that go in the checkpoints folder. ComfyUI's LTX-2 template loads ltx-2-19b-dev-fp8 at 27.08 GB with a 9.45 GB Gemma 3 text encoder, an upscaler and a 7.67 GB distilled LoRA, 45.20 GB in all. Its LTX-2.3 template loads ltx-2.3-22b-dev-fp8 at 29.15 GB with the same text encoder, two LoRAs and an upscaler, 42.96 GB in all (our calculation). Lightricks also publishes both at 16-bit, 43.29 GB and 46.15 GB, and in NVFP4.

Resolution, length and audio#

The limits Lightricks states are simple: width and height must be divisible by 32, and the frame count must be a multiple of 8 plus 1. ComfyUI's text-to-video template starts at 16:9 and 0.9 megapixels, which its own size table lists as 1280 x 736, for 5 seconds at 24 fps. It works out the frame count as seconds times frames per second plus one, so 5 seconds is 121 frames.

The template works in two stages. It samples video and audio together for 8 steps at half the width and height you set, upscales the video latent 2x with the spatial upscaler, and refines it for 3 more steps at the full size, all with the euler_ancestral sampler at CFG 1. The clip comes out at the size you set. Sampling the two together is what keeps the sound in step with the picture, and the result is one MP4 with its soundtrack. For larger output, ComfyUI's documentation describes native 4K HDR at up to 50 fps, and Lightricks' own 4K example renders at 3840 x 2176. Both cost memory and time that the default clip does not.

How much VRAM LTX-2.5 needs#

The official figure is Lightricks' own: a minimum of "32GB+ VRAM", 32 GB of system RAM and 100 GB of free disk, with an A100 80GB or H100 and 64 GB of RAM recommended. Every QuantaCloud GPU clears the minimum. What changes with the card is which files stay in memory at once, so I convert the file totals to GiB and compare them with each card's memory budget, 0.92 of what the card reports to nvidia-smi (our calculation).

Two details matter on the older cards. The INT8 files are not a compromise forced on the Ampere RTX A6000 and A100: ComfyUI's code treats INT8 as native on every NVIDIA GPU, while FP8 needs an Ada, Hopper or Blackwell card. And offloaded weights wait in system RAM. RTX A6000 1x offers had 24 to 64 GB of RAM on 2026-09-27, and Lightricks asks for 32 GB, so check the RAM column on the RTX A6000 page before you launch.

Which GPU I would rent for LTX#

The rule I follow is the 48 GB card for the template as it ships and the 96 GB card for anything heavier.

The RTX PRO 6000 Blackwell page lists its configurations with RAM and disk. An H100 PCIe is the other card Lightricks names, and it is an option when the catalog lists one. For a standing video pipeline on hardware the catalog does not list, send a capacity brief and we quote a build to your spec in writing.

The ComfyUI version each LTX model needs#

LTX-2.5's main templates are native in ComfyUI and need no custom nodes. ComfyUI's template index gives a minimum version for each: 0.8.0 for LTX-2, 0.21.0 for LTX-2.3, 0.32.0 for the LTX-2.5 text-to-video, image-to-video and first-last-frame templates, and 0.37.2 plus Lightricks' ComfyUI-LTXVideo custom nodes for the LTX-2.5 DFR template. ComfyUI itself was at v0.45 on 2026-11-12. The version inside QuantaCloud's ComfyUI template is not published yet, so check it before you download 40 GB of files:

curl -s http://127.0.0.1:8188/system_stats | python3 -c 'import json, sys; print(json.load(sys.stdin)["system"]["comfyui_version"])'

If the version is older than 0.32.0, install a current ComfyUI yourself on the Bare Metal template, as running ComfyUI on a cloud GPU shows. LTX-2.5 also runs in ComfyUI as a paid API node on Lightricks' servers. That is a different thing from the open weights this guide installs.

Launch ComfyUI and download the files#

The quickest route is QuantaCloud's ComfyUI template: launch it on the GPU from the table, wait for Running, and connect over SSH as ubuntu.

The LTX-2.5 repository is gated, so the download needs a token. Follow these steps in order.

1. Log in to Hugging Face, open the Lightricks/LTX-2.5 model page and accept the licence.
2. Create a read token in your Hugging Face settings, and on the VM run export HF_TOKEN=... with it.
3. Find the ComfyUI container and its models folder. The /internal route belongs to ComfyUI's own frontend and can change between releases, so check the path it prints:

C=$(sudo docker ps -q --filter publish=8188)
MODELS=$(curl -s http://127.0.0.1:8188/internal/folder_paths | python3 -c 'import json, os, sys; print(os.path.dirname(json.load(sys.stdin)["checkpoints"][0]))')
echo "$MODELS"

4. Save the file list as models.txt. The first word of each line is the folder under models:

# LTX-2.5 text to video and image to video: 39.71 GB, gated
diffusion_models      https://huggingface.co/Lightricks/LTX-2.5/resolve/main/diffusion_models/ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors
text_encoders         https://huggingface.co/Lightricks/LTX-2.5/resolve/main/text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors
vae                   https://huggingface.co/Lightricks/LTX-2.5/resolve/main/vae/ltx-2.5-video-vae-bf16.safetensors
vae                   https://huggingface.co/Lightricks/LTX-2.5/resolve/main/vae/ltx-2.5-audio-vae-bf16.safetensors
latent_upscale_models https://huggingface.co/Lightricks/LTX-2.5/resolve/main/latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors
# optional prompt enhancer, 5.20 GB, not gated:
# text_encoders       https://huggingface.co/Comfy-Org/gemma-4/resolve/main/text_encoders/gemma4_e2b_it_int8_convrot.safetensors
# on an 80 GB or 96 GB card, the 16-bit model and text encoder instead of the two INT8 files:
# diffusion_models    https://huggingface.co/Lightricks/LTX-2.5/resolve/main/diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors
# text_encoders       https://huggingface.co/Lightricks/LTX-2.5/resolve/main/text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors

# LTX-2.3, not gated: 42.96 GB
# checkpoints           https://huggingface.co/Lightricks/LTX-2.3-fp8/resolve/main/ltx-2.3-22b-dev-fp8.safetensors
# text_encoders         https://huggingface.co/Comfy-Org/ltx-2/resolve/main/split_files/text_encoders/gemma_3_12B_it_fp4_mixed.safetensors
# loras                 https://huggingface.co/Comfy-Org/ltx-2.3/resolve/main/split_files/loras/ltx_2.3_22b_distilled_1.1_lora_dynamic_fro09_avg_rank_111_bf16.safetensors
# loras                 https://huggingface.co/Comfy-Org/ltx-2/resolve/main/split_files/loras/gemma-3-12b-it-abliterated_lora_rank64_bf16.safetensors
# latent_upscale_models https://huggingface.co/Lightricks/LTX-2.3/resolve/main/ltx-2.3-spatial-upscaler-x2-1.1.safetensors

5. Save the download script as get-models.sh. It sends the token when HF_TOKEN is set and skips files that are already there:

#!/usr/bin/env bash
# Usage: MODELS=/path/to/ComfyUI/models bash get-models.sh models.txt
set -euo pipefail
MODELS="${MODELS:-$HOME/comfy/ComfyUI/models}"
AUTH=()
if [ -n "${HF_TOKEN:-}" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi

while read -r folder url; do
  case "$folder" in ""|\#*) continue ;; esac
  dest="$MODELS/$folder/$(basename "$url")"
  if [ -s "$dest" ]; then echo "already there: $dest"; continue; fi
  mkdir -p "$MODELS/$folder"
  echo "downloading $dest"
  curl -fL --retry 3 "${AUTH[@]}" -o "$dest.part" "$url"
  mv "$dest.part" "$dest"
done < "${1:-models.txt}"

6. Run it inside the template's container, or directly on your own install:

sudo docker cp get-models.sh "$C":/tmp/ && sudo docker cp models.txt "$C":/tmp/
sudo docker exec -e MODELS="$MODELS" -e HF_TOKEN="${HF_TOKEN:-}" "$C" bash /tmp/get-models.sh /tmp/models.txt

# on your own install instead:
MODELS=~/comfy/ComfyUI/models bash get-models.sh models.txt

A download that stops with error 401 or 403 means the token is missing or the licence has not been accepted on the model page. You will run this on every launch: stopping a QuantaCloud instance deletes it and its disk, and there are no volumes to keep models between sessions. Loading models on a new ComfyUI instance covers gated files and pinned downloads.

Load the workflow and generate a clip#

The easiest workflows are the ones ComfyUI ships. Press r so the loaders see the new files, open the Templates icon in the sidebar and search for LTX-2.5. The text-to-video, image-to-video and first-last-frame templates share the same files, and the first-last-frame one skips the upscaler. The table shows the text-to-video template's defaults on 2026-11-12.

Two corrections to Lightricks' own guide. It says the templates turn the prompt enhancer on by default, but ComfyUI switched it off in the template files on 2026-08-20, and its tutorial says the enhancer adds about 1 to 2 minutes per generation. And its table of defaults, 768 x 512 doubled to 1536 x 1024, does not match ComfyUI's template either, which halves the size you set for the first stage and doubles it back. Queue with Ctrl+Enter. The Save Video node writes the clips under output/video in the ComfyUI folder.

LoRAs and IC-LoRAs#

The LoRA advice from Lightricks is short: most LoRAs trained on LTX-2.3 run on LTX-2.5 unchanged, a few do not, so test yours before you depend on it. The built-in templates have no LoRA node. Put the file in models/loras, add a Load LoRA node after the template's shared model output, and connect its output to both sampling stages, not just one. Start at strength 1.0 when the LoRA's card gives no value.

IC-LoRAs are Lightricks' adapters for jobs that take a reference video, such as depth, edge and pose control, restoration, colorization and upscaling. Each LTX-2.5 one sits in its own gated Hugging Face repository, and the workflows for them live in the ComfyUI-LTXVideo custom nodes, not in the built-in templates.

GGUF files for LTX-2#

On a 48 GB card I would not use GGUF for LTX. The Q8_0 file of LTX-2.5 is 22.78 GB, larger than the 21.50 GB INT8 file ComfyUI loads natively, and the 13.58 GB Q4_K_M file only earns its place on a card below Lightricks' 32 GB minimum. GGUF files need the ComfyUI-GGUF custom node as well. GGUF models in ComfyUI covers when a quant is worth it.

Save your clips before you stop#

Copy the videos off the instance before you press Stop, every time, because Stop deletes the disk. On the template, copy them out of the container first, in the same session where you set C and MODELS:

COMFY=$(dirname "$MODELS")
sudo docker cp "$C:$COMFY/output" ~/comfy-output
sudo chown -R ubuntu: ~/comfy-output

Then pull the folder to your own machine with rsync -avP ubuntu@<instance-ip>:comfy-output/ ./comfy-output/. Moving files to and from a GPU server covers the other ways. Billing runs from launch to stop, so downloads and idle time count too, and unused seconds of the current hour are refunded when you stop.

LTX-2 questions#

Is LTX-2 open source?

The weights are open and free to download, under Lightricks' own community licences, not an open-source licence such as Apache-2.0. Commercial use is free below $10M in annual revenue and needs a paid agreement at or above it. The inference and training code in Lightricks' repository is Apache-2.0.

How much VRAM does LTX-2.5 need?

Lightricks gives 32 GB as the minimum and recommends an A100 80GB or H100. ComfyUI's template loads 39.71 GB of INT8 files, which fit a 48 GB card with about 4.4 GiB of its 41.39 GiB budget to spare (our calculation), and the 16-bit set is 71.11 GB.

What is the difference between LTX-2 and LTX-2.5?

LTX-2 is the 19B model from January 2026 and LTX-2.5 the 22B model from August 2026. LTX-2.5 adds several connected shots in one generation, a new video decoder, a Gemma 4 text encoder and a better distilled model, and it moves to the LTX-2.x Community License.

Does LTX-2 generate audio?

Yes. LTX-2, LTX-2.3 and LTX-2.5 all generate synchronized audio with the video in one model, and ComfyUI saves the two as one MP4.

My decision rule for LTX: LTX-2.5 with the template's INT8 files on a 48 GB card to start, the RTX PRO 6000 Blackwell when you want the 16-bit files, the DFR template or longer clips, and the licence read before anything ships. Check the template's ComfyUI version first, and copy clips off before you stop. Open-source video generation models compares LTX with Wan and the rest, Wan 2.2 in ComfyUI covers the Apache-2.0 alternative, and the ComfyUI page lists every GPU with the template and its live price.