You need to agree to share your contact information to access this model
This repository is publicly accessible, but you have to accept the conditions to access its files and content.
These are quantized derivatives of LTX-2.5 and are distributed under the LTX-2 Community License Agreement, a complete copy of which is included in this repository as LICENSE.md. By requesting access you confirm you have read and accepted it, including the use restrictions in Section 4 and Attachment A. IMPORTANT: under Section 2.1, entities with annual revenues of at least $10,000,000 must obtain a paid Commercial Use Agreement from Lightricks (ltxv-licensing@lightricks.com) before ANY use other than a Non-Commercial Purpose as defined in Section 2.2. This applies to these derivative weights exactly as it applies to the originals.
Log in or Sign Up to review the conditions and access this model content.
LTX-2.5 (distilled) — weight-only NVFP4
Weight-only NVFP4 quantization of Lightricks/LTX-2.5-Diffusers,
made so the model fits and generates on a single NVIDIA GB10 (DGX Spark, sm_121)
alongside other resident models.
The source is the diffusers-layout repo, so these are the same weights as
Lightricks/LTX-2.5 in a different
container: component subdirectories and sharded safetensors rather than the
single-file ComfyUI layout that the GGUF and ComfyUI-NVFP4 builds start from.
If you load LTX-2.5 through diffusers, this is the one to take; if you load it
through ComfyUI, it is not.
68.24 GB → 21.18 GB.
| component | bf16 | NVFP4 | |
|---|---|---|---|
transformer (distilled DiT) |
37.98 GB | 11.14 GB | 3.41× |
text_encoder (Gemma-4) |
23.92 GB | 8.25 GB | 2.90× |
connectors |
6.34 GB | 1.79 GB | 3.55× |
NOTICE OF MODIFICATION (LTX-2 Community License §3.3)
These files have been modified from the originals distributed by Lightricks.
Every 2-D .weight tensor above 2²⁰ elements that is not an embedding or a norm
has been replaced by three tensors — .weight_packed (E2M1, two values per byte),
.weight_scale (E4M3, one per 16 elements) and .weight_scale_2 (F32 per-tensor)
— using torch's to_nvfp4. Embeddings, norms, positional and register
parameters, and all tensors below the size threshold are carried through
unchanged at their original precision. Activations are not quantized. Each
shard carries {"quant": "nvfp4_weight_only"} in its safetensors metadata.
No fine-tuning, distillation, or retraining was performed. Only the transformer,
text_encoder and connectors components are included; every other component
(vae, audio_vae, scheduler, tokenizer, vocoder, …) must come from the upstream
repository unmodified.
Why weight-only and not W4A4
Quantizing activations to 4 bits produced visibly grainy, distorted video in our testing (0.20 relative error through a stacked FFN). Weight-only delivers the same ~4× capacity win — which is the entire reason the model fits — without touching the activation path. If you need W4A4, calibrate and evaluate it yourself; do not assume this checkpoint's quality carries over.
Measured on GB10
Image-to-video, 768×768, 97 frames (4.04 s @ 24 fps), the distilled 8-sigma schedule fully unguided, seed 42:
| stage | time |
|---|---|
| weight load | 154.9 – 168.6 s |
| denoise + decode | 63.4 / 64.5 / 67.3 s (three runs) |
| total | 222 – 233 s |
The 67.3 s run had an unrelated 3D pipeline resident at 37.8 GB throughout.
Report load and generation separately. Load is bandwidth-bound and dominates on a chip that is capacity-rich and bandwidth-poor (~273 GB/s); denoise is compute-bound. A single end-to-end total mostly measures cold weight streaming, which is why published Spark numbers for the same model rarely agree.
Usage
Requires diffusers 0.40+ and transformers 5.15+ (LTX2 classes and the Gemma-4
text encoder). These are packed weights: standard from_pretrained will not
load them. Use the loader and quantizer from
spark-nvfp4-bench, which
swaps each nn.Linear for a packed-NVFP4 module before assigning tensors.
The shipped *.index.json files describe the tensors that are actually here —
weight_packed / weight_scale / weight_scale_2 for every quantized layer,
and a total_size of the packed footprint — so an index-driven loader resolves
correctly and a preflight download sizing is honest.
Note that the distilled DiT runs a fixed 8-sigma schedule fully unguided; passing
num_inference_steps hands it a generic linear schedule and quietly costs quality.
Reproducing
Nothing here is unreproducible — quantize_ltx_nvfp4.py in the repo above takes
the upstream component directory and emits these files. Peak memory is one shard
(~10 GB), not the whole model.
One warning if you adapt it: upstream transformer/ contains two shard sets
that are different models (a 4-shard and an 8-shard, ~38 GB each, sharing one
config.json), and only the 4-shard set is referenced by weight_map. A
quantizer or loader that globs *.safetensors will silently interleave two
distinct 22B checkpoints without raising anything. Drive off the index.
License
LTX-2 Community License Agreement — full text in LICENSE.md, which you must
pass on to anyone you redistribute these files to (§3.2). Use is subject to the
restrictions in Section 4 and Attachment A. See the gated-access notice above
regarding the $10M revenue threshold in §2.1 and the transfer conditions in §3.5.
Not affiliated with or endorsed by Lightricks.
- Downloads last month
- -
Model tree for KevinDowling/LTX-2.5-Diffusers-NVFP4
Base model
Lightricks/LTX-2.5