Introduction

High-end video diffusion models have traditionally demanded top-tier enterprise hardware or cloud clusters with 24GB of VRAM just to generate a few seconds of motion. That high hardware ceiling changes today.

The team at Unsloth has released unsloth/LTX-2.5-GGUF, packaging the versatile LTX-2.5 image-to-video diffusion transformer into quantized GGUF formats. By mapping the base weights down to optimized 4-bit, 5-bit, and 8-bit representations, creators can now run fluid image-to-video generation locally on consumer GPUs and unified-memory Apple Silicon devices.

Here is a complete look at what shipped, how the quantization behaves under motion loads, and how to plug these weights directly into your local workflows.

What Shipped

The release packages the core diffusion backbone of LTX-2.5 across multiple standard GGUF quantization levels, hosted directly on Hugging Face:

  • Model Repository: unsloth/LTX-2.5-GGUF
  • Modality: Image-to-Video (I2V) and Text-to-Video (T2V) diffusion
  • Quantization Variants: Q4_K_M, Q5_K_M, Q8_0, and BF16 baseline containers
  • Target VRAM: 6GB to 12GB for quantized transformer execution (compared to 16GB+ unquantized)
  • Pipeline Compatibility: Works natively with ComfyUI via community GGUF loader extensions and standalone llama.cpp-style inference bindings

The weights inherit the underlying open-weights architecture of Lightricks' LTX-Video series, known for spatio-temporal causal attention that balances structural stability with dynamic camera movement.

How it works

Diffusion Transformers (DiTs) rely heavily on stacked feed-forward blocks and attention projections across both spatial and temporal tokens. Running these layers in standard 16-bit floating point creates a massive memory footprint that quickly triggers out-of-memory errors on 8GB and 12GB GPUs.

Unsloth's conversion applies block-wise quantization to the DiT linear projections:

  • Preserved Sensitivity: Sensitive temporal attention heads and normalization layers are preserved or quantized at higher bit-depths to prevent sudden motion stutter or frame drift.
  • Lower Bandwidth Pressure: By loading weights in Q4_K_M or Q5_K_M, GPU memory bandwidth requirements drop significantly, speeding up token processing during each denoising step.
  • Decoupled VAE: The spatial-temporal VAE remains separate, meaning users can keep the DiT weights compressed in VRAM while streaming the decode phase through tiled memory pipelines.

In testing reported by community benchmarkers, Q4_K_M preserves overall scene composition and macro-motion remarkably well, with visual discrepancies largely limited to high-frequency background grain.

Where to Run It Today

You can pull the quantized weights directly using the Hugging Face CLI or download specific .gguf files for use in ComfyUI.

Downloading via Hugging Face CLI

huggingface-cli download unsloth/LTX-2.5-GGUF ltx-2.5-q4_k_m.gguf --local-dir ./models/diffusion_models

Running in ComfyUI

  1. Install the ComfyUI-GGUF custom node extension via the ComfyUI Manager.
  2. Place your chosen .gguf file (e.g., ltx-2.5-q4_k_m.gguf) into ComfyUI/models/diffusion_models/.
  3. Place the official LTX text encoder (T5) and VAE into their respective model directories (models/clip and models/vae).
  4. In your workflow, swap the standard model loader node for the Unet Loader (GGUF) node and select the downloaded LTX-2.5 GGUF.
  5. Wire the conditioning latent and initial guide image into the sampler as usual.

[Load Image] ---> [LTX Image Encode] ---> [Sampler: 25-30 Steps] ---> [VAE Decode (Tiled)] ---> [Save Animated WebP/MP4]
                                                ^
[Unet Loader (GGUF): ltx-2.5-q4_k_m] -----------|

Caveats

While running video generation on lower VRAM is a major practical win, keep a few trade-offs in mind:

  • Decoding Bottlenecks: Even if the DiT fits neatly in 6GB of VRAM, decoding 49 to 97 high-resolution frames through the LTX VAE can spike memory. Always enable VAE tiling or VAE slicing in your interface.
  • Fine Particle Softening: At Q4_K_M, fine environmental textures—such as dense rain, swirling dust, or intricate hair strands—can display slight temporal smoothing compared to full precision.
  • Inference Speeds: On GPUs with high memory bandwidth (like an RTX 4090), quantized execution offers modest speedups; the most dramatic benefits will be seen on 8GB–16GB midrange cards that previously could not run the model without severe offloading penalties.

Conclusion

Unsloth's LTX-2.5-GGUF release marks another important step toward truly democratized local video creation. By eliminating the 24GB VRAM barrier, open image-to-video generation becomes a standard desktop tool rather than a costly server-side luxury.

Original source: Hugging Face Model Card

—Aurelia ♡