Field SOP
Field SOP

ComfyUI Video Generation SOP: Run LTX-2.5 on 12GB VRAM

A ComfyUI local video generation SOP, using LTX-2.5 to get a 12GB card through the full pipeline. Model files and directories (int8_convrot builds, not BF16): the transformer goes to models/diffusion_models/, gemma4-12b-with-proj to models/text_encoders/, the video and audio VAEs (both bf16) to models/vae/, and the 2x latent upscaler to models/latent_upscale_models/. Pitfalls first: the audio VAE is a separate file - skip it and you render a silent video; the prompt enhancer is an extra ~5GB model adding 1-2 minutes per generation and is off by default; HF gated=auto means you must log in and accept terms to download (even to read the model card). Hardware floor: 12GB VRAM with distilled/int8, CUDA 12.7+, PyTorch ~2.7, Python 3.12+ (innfactory's compilation); on 8GB cards, switch to Wan 2.2 TI2V-5B with offload instead. Three workflow types: two-stage T2V/I2V (generate, then 2x latent upsample refinement), single-stage (fast, for previews), and A2V (audio-driven video). VRAM strategy: quantized/distilled first, ComfyUI native offload, short low-res generation then upscale. Repos: github.com/Lightricks/ComfyUI-LTXVideo, huggingface.co/Lightricks/LTX-2.5.

Published October 10, 20269 min read
<!-- comfyui-video-workflow-sop | sop | ComfyUI Video Generation SOP: Run LTX-2.5 on 12GB VRAM -->

You have probably generated a thousand still images in ComfyUI. Your first video clip is a different animal: the models are ten times larger, the file layout is unfamiliar, one wrong VAE file leaves you with a silent render, and the VRAM math that worked for 1024x1024 images falls apart the moment motion enters the picture. That gap between "I know ComfyUI" and "I can run a video model locally" is exactly what this SOP closes.

To be precise about scope, this is not our ComfyUI resource roundup, which catalogs the ecosystem, and it is not our consistent-style image workflow, which locks a visual style across stills. This piece is about the thing those articles do not cover: running open-weight video models end to end inside ComfyUI, from the first download to a finished clip with sound. We use LTX-2.5 as the worked example because it currently has the lowest credible hardware bar among models that generate audio and video in one pass. Everything below reflects the state of play as of October 9, 2026.

Step 0: Check Your Hardware and Environment Before Downloading Anything

First, know what LTX-2.5 is. Lightricks released it on August 11, 2026 as the successor to LTX-2.3: a 22-billion-parameter model that generates video and 24kHz stereo audio in the same pass, built around a custom Gemma 4 12B text encoder and a diffusion video decoder. It outputs up to 4K HDR (3840x2176) at up to 50fps. That is the full-size architecture, and it is not what most of us will run: at full precision the model wants 80GB or more of VRAM, and all components together weigh in around 66GiB of downloads.

The ComfyUI path is different. The community runs LTX-2.5 through its distilled and int8-quantized builds, which drop the single-card requirement to 12GB of VRAM. That 12GB figure is the headline number of this entire workflow, and every file you download in Step 1 exists to make it true.

Before you download, verify three environment lines. Setup guides compiled by innfactory list CUDA 12.7 or newer, PyTorch around 2.7, and Python 3.12 or newer. If your stack is older, upgrade the toolkit before touching model files, because version mismatches here produce errors that look like model problems and waste an evening.

The honest triage:

  • 12GB VRAM or more: you can run LTX-2.5 distilled/int8 as described in this SOP. This covers most RTX 3060/4070-class cards and anything newer.
  • 8GB VRAM: do not force LTX-2.5. Load Wan 2.2's TI2V-5B model with ComfyUI's native offload instead. It is a smaller 5B model with the most permissive license in its class (Apache 2.0), and it will actually complete a render on your card.
  • 80GB-class hardware (A100/H100 territory): you can chase the full-precision build and the 4K pipeline, but that is outside this SOP's scope.

One more disk-space note: even the ComfyUI-oriented file set in Step 1 adds up to tens of gigabytes. Clear the space now rather than discovering a full drive at 90 percent of a download.

Step 1: Download Four File Types and Put Them in Exactly the Right Folders

The weights live at huggingface.co/Lightricks/LTX-2.5 on Hugging Face (plain form: huggingface.co/Lightricks/LTX-2.5). The repo is gated, but in the friendliest way: it is set to gated=auto, which means you log in, accept the community license terms once, and access is granted automatically with no manual review. Be aware that even viewing the model card requires that login first, so do not mistake a login wall for a broken page.

You also want the ComfyUI custom node pack ComfyUI-LTXVideo from Lightricks (plain form: github.com/Lightricks/ComfyUI-LTXVideo). It supplies the LTX-specific nodes the workflows in Step 2 are built on. Install it through ComfyUI Manager or clone it into your custom_nodes folder.

Now the critical part. ComfyUI expects four distinct file types in four distinct directories, and mixing them up is the most common install failure. For the 12GB setup, download the int8_convrot builds, not the BF16 builds, for the transformer and text encoder:

  1. The diffusion transformer goes to models/diffusion_models/. The exact file is ltx-2.5-22b-distilled-transformer-comfy-int8-convrot.safetensors. This is the 22B model itself, distilled and quantized to int8.
  2. The text encoder goes to models/text_encoders/. The exact file is gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot. This is the custom Gemma 4 12B encoder with the projection layer that maps its output into the diffusion model's input space.
  3. The VAEs go to models/vae/, and there are two of them: ltx-2.5-video-vae-bf16 for the video latent space and ltx-2.5-audio-vae-bf16 for the audio latent space. These ship in BF16 because VAEs are small; the quantization savings are in the big models, not here.
  4. The latent upscaler goes to models/latent_upscale_models/. The exact file is ltx-2.5-latent-spatial-upscaler-x2-bf16. This is the piece that makes the two-stage workflow in Step 2 possible.

Note the fourth category: latent_upscale_models is not a folder you may have used before with image models, and it is easy to create a wrong directory name out of habit. Copy the path exactly.

While you are on the model page, read the license terms you are agreeing to. LTX-2.5 ships under the LTX-2.x Community License, and Lightricks is explicit that it is not Apache 2.0. The short version: commercial use is free if your annual revenue is under 10 million US dollars (inclusive); at or above that threshold you need a Commercial Use Agreement. For individual creators and most studios, that means free, but it is a real contract you accept when you click through the gate.

Step 2: Pick One of Three Workflow Shapes

With files in place, the custom node pack gives you three workflow archetypes. Choose by intent, not by whichever template loads first.

Shape one: two-stage T2V or I2V, generate then upscale. This is the quality path. Stage one is a standard text-to-video or image-to-video pass at your base resolution, producing a latent clip. Stage two feeds that latent through the 2x spatial upscaler you placed in Step 1 and runs a refinement pass, roughly doubling effective resolution without re-rendering from scratch. The same skeleton handles both T2V and I2V; the only real difference is whether an image latent enters the first stage. Treat this as your default for anything you plan to keep.

Shape two: single-stage, fast preview. Same generation stage, no upscaler, no refinement. It is the fastest route from prompt to pixels and the right choice for testing prompt phrasing, checking composition, or iterating on camera motion. The output is visibly softer than the two-stage result, which is precisely why it is cheap: do not judge final quality on a single-stage preview, and do not ship one.

Shape three: A2V, audio-driven video. Here an audio track drives the generation, producing motion that follows sound. This is the workflow only audio-native models can support at all, and it is LTX-2.5's structural advantage: audio and video are generated in the same pass at 24kHz stereo, so there is no post-hoc dubbing step to synchronize.

How long can a single clip be? Two third-party numbers coexist and neither should be quoted as a hard spec. Pinggy's writeup puts the single-pass maximum at about 20 seconds, extendable through an Extend pipeline; innfactory's material lists 121 frames at 24fps, which is roughly 5 seconds. The discrepancy likely reflects different builds and settings, so treat duration as something to test on your own card rather than a number to promise a client.

Three Pitfalls That Quietly Ruin Renders

Pitfall one: the audio VAE is a separate file, and skipping it gives you a silent video. Because the video VAE and audio VAE are two different safetensors files, a partially completed download folder will still load, still render, and still produce a perfectly good-looking clip, just with no sound and no error message pointing at the cause. If your first render is silent, check that ltx-2.5-audio-vae-bf16 actually landed in models/vae/ before you rewire anything.

Pitfall two: the prompt enhancer is a hidden cost. The workflow supports an optional prompt enhancer model that rewrites your prompt into a richer description before generation. It works, but it is roughly a 5GB additional download and it adds one to two minutes to every single generation. It is off by default. Turn it on deliberately when you want prompt expansion, and leave it off when you are iterating, or your preview loop gets twice as slow for no reason.

Pitfall three: the instinct to render big in one pass. The reliable VRAM strategy on consumer cards is the opposite of what feels natural: generate a short, low-resolution clip, then let the dedicated upscaler carry the resolution. One giant render at high resolution and long duration is how 12GB turns into an out-of-memory crash at the last sampling step. Combine this with the defaults already built into your setup: run quantized/distilled builds first, and let ComfyUI's native offload move weights between VRAM and system RAM as needed. Short-plus-upscale reliably beats one-big-render on both success rate and total time.

Which Model Should You Actually Load?

LTX-2.5 is the worked example here, but the whole point of running models locally is that you can choose. For the full architecture story, including the diffusion video decoder that separates LTX-2.5 from its LTX-2.3 predecessor, see our LTX-2.5 open-source deep dive. For model selection, our open-video-model local comparison works through the four leading open-weight video models across five axes: license, VRAM, audio, duration, and regional availability. The compressed version for ComfyUI users:

  • Want the most permissive license? Wan 2.2. Apache 2.0, runs on 8GB with offload via TI2V-5B, outputs 480p-720p short clips. No native audio.
  • Want audio and video in one pass? LTX-2.5. 24kHz stereo in the same generation pass, 12GB distilled/int8 entry point, Community License with the 10-million-dollar revenue threshold.
  • Have a 24GB card and no EU/UK/South Korea exposure? HunyuanVideo 1.5. Starts around 14GB VRAM, but Tencent's community license does not apply in those regions and very large user bases need separate terms.
  • Need dialogue or reference audio? MiniMax H3, in the regions its license allows. Note its community license excludes the EU, UK, South Korea, and the US, and revenue above 20 million dollars needs written authorization.

For this SOP's audience, the decision is simpler: if your card has 12GB, load LTX-2.5 and follow the steps above; if it has 8GB, load Wan 2.2 TI2V-5B with offload and skip Step 1's int8 files entirely.

FAQ

Q1: What is the minimum hardware for ComfyUI video generation with LTX-2.5? 12GB of VRAM with the distilled/int8 builds is the working floor, alongside CUDA 12.7+, PyTorch around 2.7, and Python 3.12+. The full-precision model needs 80GB or more and is not the realistic target. On 8GB cards, run Wan 2.2 TI2V-5B with offload instead.

Q2: The Hugging Face page will not show me anything. Is the repo down? No, the repo is gated with gated=auto. Log in to your Hugging Face account, accept the license terms once, and access is granted automatically. Even the model card is hidden until you log in, so a login wall is the expected behavior, not an outage.

Q3: My clip rendered fine but has no audio. What broke? Almost certainly the audio VAE is missing. LTX-2.5 uses two separate VAE files in models/vae/, and the render completes silently without the audio one. Verify ltx-2.5-audio-vae-bf16 downloaded completely, then re-run the workflow.

Q4: Can I use LTX-2.5 output commercially? Yes, under the LTX-2.x Community License if your annual revenue is under 10 million US dollars (inclusive). At or above that threshold you need a Commercial Use Agreement from Lightricks. The license is custom, not Apache 2.0, so read the actual terms you accept when downloading.

Q5: Should I render long clips at high resolution in one pass? No. On consumer cards the reliable strategy is a short, low-resolution generation followed by the dedicated 2x latent upscaler. Single-pass big renders are the main cause of out-of-memory crashes near the end of sampling. Use single-stage output for previews only and the two-stage path for anything you keep.


References

This article is AI-assisted and human-edited. Last updated: 2026-10-10

FAQ

What is the minimum hardware for ComfyUI video generation with LTX-2.5?
12GB of VRAM with the distilled/int8 builds is the working floor, alongside CUDA 12.7+, PyTorch around 2.7, and Python 3.12+. The full-precision model needs 80GB or more and is not the realistic target. On 8GB cards, run Wan 2.2 TI2V-5B with offload instead.
The Hugging Face page will not show me anything. Is the repo down?
No, the repo is gated with `gated=auto`. Log in to your Hugging Face account, accept the license terms once, and access is granted automatically. Even the model card is hidden until you log in, so a login wall is the expected behavior, not an outage.
My clip rendered fine but has no audio. What broke?
Almost certainly the audio VAE is missing. LTX-2.5 uses two separate VAE files in `models/vae/`, and the render completes silently without the audio one. Verify `ltx-2.5-audio-vae-bf16` downloaded completely, then re-run the workflow.
Can I use LTX-2.5 output commercially?
Yes, under the LTX-2.x Community License if your annual revenue is under 10 million US dollars (inclusive). At or above that threshold you need a Commercial Use Agreement from Lightricks. The license is custom, not Apache 2.0, so read the actual terms you accept when downloading.
Should I render long clips at high resolution in one pass?
No. On consumer cards the reliable strategy is a short, low-resolution generation followed by the dedicated 2x latent upscaler. Single-pass big renders are the main cause of out-of-memory crashes near the end of sampling. Use single-stage output for previews only and the two-stage path for anything you keep.

Related

Field SOP

8GB VRAM, 4K Output: FLUX 3 Klein's Three Pitfalls

A practical path to running FLUX 3 Image Klein on consumer Nvidia cards, with three pitfalls found in the field; every command and filename comes from the official repositories or from third-party recipes that were actually run. The main line is ComfyUI. The repository black-forest-labs/flux-3-image-klein-comfy is gated, marked gated auto in the Hugging Face API, so an anonymous request returns 401 with x-error-code GatedRepo; sign in, accept the terms, then run hf auth login. Next, hf download pulls four files: the distilled int8 transformer at 5,827,874,779 bytes, the Qwen3-VL-4B int8 text encoder at 4,858,559,240 bytes, the w4a8 prompt upsampler at 6,724,090,780 bytes and the FLUX.2 VAE at 336,211,292 bytes. Start with python main.py, open Workflow and then Browse Templates, search FLUX 3 and pick distilled Text to Image with template id image_flux3_klein_distilled_t2i; the template defaults to 1024 by 1024, euler with the simple scheduler, 16 steps and CFG 1, both text-encoder loaders set to type flux3, and the upsampler switch left on. Then the three pitfalls. First, following the card's example and downloading the int8 upsampler at 9,748,113,996 bytes, about 9.08GiB, brings the four files to 19.343GiB, which will not fit a 16GB card, while the ComfyUI v0.41.2 distilled template actually loads the w4a8 file, 2.816GiB smaller. Second, the model card says the editing templates have no upsampler branch and that you should run your own LLM and paste the caption, yet the v0.41.2 editing template does contain an upsampler branch behind a switch that is off by default, a TextGenerate node with the W4A8 loader and an image-editing system prompt, so either route works. Third, running the model without an upsampler gives unstable results in editing and Ref2Image; the card states plainly not to use the model without a prompt upsampler. Memory budget: 11.2GB in BF16, 5.6GB in FP8, INT8 running on 8GB RTX cards, and NVFP4 aimed at data centres. All speed figures are vendor-reported: about 4 seconds per 1MP image on an RTX 5090 and under 9 seconds on an RTX 4070 with the distilled INT8 build, under 0.6 seconds in NVFP4 on a GB300, with a served LoRA adding about 5 percent. Resolution reaches 4K with width and height in multiples of 16, up to 10 reference images are accepted, and official defaults are 16 steps with no guidance for the distilled checkpoint and 50 steps at CFG 3.5 for the base. The Diffusers route is described only as far as is verifiable - it works, and BFL ships reference inference code including a Gradio demo with bounding-box control, with the repository README as the authority; no class names or parameters are invented here. Before commercial use, check the FLUX Kommunity License: free commercial use for individuals and companies under 5 million dollars in annualized revenue, free research and non-commercial use, and self-hosted licensing or the API beyond that, with the LICENSE text governing the details.

Oct 17, 202610 min read
Field SOP

LLaDA-Image Local Deploy SOP: Setup, Inference, Production

A five-step SOP for running Ant's open-source 6B image model LLaDA-Image: (1) environment setup with dependencies and mirror-accelerated downloads; (2) choosing among four weight variants (Base 50-step / Turbo 4-step, each in BF16 or FP8, with ModelScope for China); (3) generating the first image with minimal Base and Turbo commands; (4) advanced work - reference-image editing, text rendering, ComfyUI integration, and degradation strategies when VRAM runs short; (5) productionizing with batch queues, concurrency sizing, cost monitoring, result storage and graceful failure modes. Includes 6 pitfalls and a 10-item launch checklist, with every command copied verbatim from the official README; note the repo license is null, so confirm rights before commercial use.

Sep 9, 202611 min read
Field SOP

Can One GPU Run Matrix-Game 4.0? A Local Deploy SOP

A nine-step SOP for running Matrix-Game 4.0 locally on a single GPU, with every command and flag taken verbatim from the v4 subdirectory README (repository: github.com/SkyworkAI/Matrix-Game, file Matrix-Game-4/README.md). Step 1, align on requirements: model inference needs Linux, an NVIDIA GPU and Python 3.12 together, the reference A100 80 GB deployment uses PyTorch 2.12.0 / CUDA 13.2, and the repo ships a dedicated RTX 5090 runtime that does not auto-detect hardware, so the matching preset must be selected explicitly; the browser demo needs a Linux server that also builds the game and GStreamer pipeline while the Safari/Chrome client needs no GPU; standalone play and recording need macOS or Linux plus CMake, C++20, SDL2 and FFmpeg, with the legacy Windows entry retained but not validated for feature parity; and weights and assets are not shipped in the repo, so budget extra space for the Hugging Face Hub cache. Step 2, install inside the Matrix-Game-4/ subdirectory or everything after is wrong: git clone, cd Matrix-Game/Matrix-Game-4, python3.12 -m venv .venv and source .venv/bin/activate, then pip install torch==2.12.0 torchvision==0.27.0 --index-url https://download.pytorch.org/whl/cu132 as a matched pair, then pip install -e '.[inference,server,download,test]' with all four extras; FlashAttention is optional and only rtx5090-sage needs SageAttention while plain rtx5090 uses PyTorch SDPA. Step 3, downloads come as two manifests, game assets and model weights, pinned to revision 4419accdb7bb7881234c5914de8cd915266e0325 with --scene switchable across castle, racing and all, and one server process supporting only one scene model; the downloader verifies size and SHA256 against the manifests so interrupted runs can simply restart, shared T5/tokenizer and Wan VAE pull automatically from the official base, and matrix-game verify rechecks an installed scene. Step 4, offline rendering proves the model produces output: matrix-game render --scene ancient-egypt --input lowpoly.mp4 --resources resources --preset realtime --prompt-mode fixed --output outputs/egypt, where the input is a low-poly proxy stream rather than real footage and the output is rendered.mp4 plus a configuration report with FPS and frame count preserved; the three presets matter - realtime is for A100, RTX 5090 switches to rtx5090, and quality is slower yet is exactly the default when --preset is omitted. Step 5, play and record locally without loading a model: bash scripts/build_game.sh then bash scripts/play.sh --scene ancient-egypt, giving the two shooter scenes a 48 FPS, 2x simulation-time demo mode with F9 recording and Escape menu, and MATRIX_GAME_DATA_DIR overriding the default data directory; racing uses build_racing.sh with 1x simulation time, and the browser demo does not enable the shooters' 2x mode either, advancing 1/--fps seconds per captured frame. Step 6, the browser demo splits server and client: mediamtx configs/mediamtx.yml in one terminal and CUDA_VISIBLE_DEVICES=0 bash scripts/serve.sh --scene ancient-egypt --resources resources --preset realtime --fps 40 in another, then open http://127.0.0.1:8025/, with --reference-only testing controls, HUD, audio and transport without loading a model; --fps 40 is a capture cadence target, not a throughput or latency guarantee. Step 7, the two RTX 5090 presets: rtx5090 needs no extra installation while rtx5090-sage requires building SageAttention 2.2.0 with the supplied CUDA-graph patch and CUDA 13.2 at git checkout eb615cf6cf4d221338033340ee2de1c37fbdba4a; both reuse the same scene checkpoints and shared resources, converting DiT block linear weights to FP8 at load with activations quantized during inference while embeddings and the output head stay BF16, and startup warms kernels and captures CUDA graphs so the first launch is slower than steady state. Step 8, acceptance in two forms: a keypress producing a picture in the browser demo (officially about under 150 ms, not independently reproduced) or an offline render turning a low-poly video into a finer output, with the three performance accounts written side by side (official 480p 60 FPS, 83 FPS and 18.5 GiB; the project page panel still at 0; and the README's about 38-39 FPS on an A100 at 864 x 480), remembering that model throughput, pipeline throughput, presentation frame rate and end-to-end latency are four different things. Step 9, six pitfalls: one process supports one session and one scene model; it binds to loopback by default and must not be exposed to the internet, since the official statement calls it a trusted single-user demo rather than a public cloud-gaming service; --fps 40 is not a throughput guarantee; Windows is unvalidated; disk must accommodate the Hub cache; and VRAM splits into an A100 80 GB reference tier and an RTX 5090 consumer tier with the 5080 and 5070 still pending.

Oct 16, 202610 min read