Everything here is free and stays free — the format spec, the nodes, the workflows, the cartridges, the LoRAs. If it saved you a night of debugging (it contains several hundred of mine), tips keep the 5090 warm:

• ☕ Buy me a coffee on Ko-fi

• 💛 Sponsor on GitHub

• 🔁 Liberapay (recurring)

• ⚡ Or right here: the Civitai tip button on this page sends Buzz directly.

LTX-2.5 22B, cut down to fit your card

LTX-2.5 makes picture and sound in one pass, which is the whole reason to want it. It is also 42 GB of bf16 weights, with a text encoder beside it that is another 26 GB. This is the set of weights that make it run on a card that does not have that.

Fourteen builds, every one cut from Lightricks' bf16 originals and never from another quant. Pick your version above by how much VRAM you have.

Read this first: there are two loaders

Half these files need a custom node and half do not, and picking the wrong loader gives you an error that does not explain itself.

• .gguf - load with ComfyUI-GGUF (city96), node Unet Loader (GGUF). The familiar Q-ladder.

• comfy-*.safetensors - load with the stock Load Diffusion Model node on ComfyUI 0.32 or newer. No custom node at all. These use ComfyUI's own quantisation system, the same machinery behind Lightricks' official int8-convrot build.

Every filename with -comfy- in it is the second kind. That is the whole rule.

Which file do I want

12 GB card - take Q3_K_M at 10.60 GB and shorten your clips. It fits at reduced frame counts and looks like the rest of the ladder. Q2_K at 7.91 GB is the fallback when you need the frames more than the picture - it renders the scene correctly but softly, with faces losing their detail and a haze over the whole frame. Reach for it second, not first.

16 GB card - Q3_K_M at 10.60 GB is the sweet spot. comfy-w4a8 at 12.52 GB if you would rather not install a custom node. comfy-mix4x8-13.8GB if you can spare the room: it is the most quality per byte in this tier, for reasons measured below.

24 GB card - Q5_K_M at 15.90 GB or Q6_K at 17.75 GB, or comfy-mix4x8-17GB at 17.01 GB with no custom node.

32 GB card - Q8_0 at 22.73 GB, or comfy-int8 at 21.50 GB with no custom node. At this size you are buying certainty, not visible quality.

The Gemma-4 text encoder at 10.60 GB is in the 16 GB version and you want it whichever transformer you pick - at bf16 that encoder is 26.3 GB, which on a small card means it owns the whole machine for the one step that just builds an embedding.

The 16 GB recipe

• LTX25-distilled-DiT-Q3_K_M.gguf at 10.6 GB, or comfy-w4a8 at 12.5 GB for the no-custom-node route

• gemma4-12b-ltx25-comfy-w4a8.safetensors for the text encoder

• the stock bf16 VAEs, ltx-2.5-video-vae-bf16 and ltx-2.5-audio-vae-bf16 - 1.5 GB and 0.4 GB, and quantising them is not worth what it costs

• tiled VAE decode: tile_size 512, temporal_size 32

• the distilled schedule: 9 steps then 4, video_cfg and audio_cfg at 1.0

• first pass at 0.2 to 0.5 megapixels - 608x352 or 960x544 - then upscale. The two-pass sigma schedule is tuned for that band, and rendering pass one at full resolution is the most common way to get mush out of this model

Two formats in one file, and how the layers were picked

Two of these builds carry two quantisation formats at once - some layers 4-bit, some 8-bit, inside one file. ComfyUI supports this natively: it reads the format from a small blob attached to each individual layer, so a file may declare a different one on every Linear and the stock loader takes it without complaint.

Which layers earn the extra four bits was measured, not guessed. All 1440 quantised layers were reconstructed at both precisions and compared against the original bf16 weights, then promoted in order of error removed per byte spent until the size budget ran out.

The efficiency is the point. mix4x8-13.8GB spends 1.29 GB of the 8.98 GB that separates all-4-bit from all-8-bit - about a seventh of the cost - and recovers 39.5% of the reconstruction error that going all the way to int8 would remove. mix4x8-17GB spends half the cost for 82% of the benefit. Neither sits near the straight line between the two ends, which is the only reason a mix is worth building.

One finding worth stealing if you build your own: ranking layers by relative error does not work. Across all 1440 layers the 4-bit relative error falls between 0.0721 and 0.0737 - a two percent spread - so by that measure every layer looks equally worth promoting and the ranking is noise. Weighting each layer by its actual weight magnitude is what separates them, and once you do, 363 of the first 386 promotions land in the audio tower rather than the video one.

What they actually look like

Every build was rendered from the same scene, same seed, same size - 544x960 first pass, 2x to 1088x1920, 385 frames - so the weights are the only variable. Frames compared at 1:1, plus two independent audio-capable reviewers on the extremes.

• Q3_K_M and up are genuinely hard to separate. Hair holds strand detail, faces keep structure, background foliage and fence mesh survive. If you are choosing between Q4_K_S and Q6_K on quality grounds, you are choosing on a difference you will struggle to see.

• The comfy-native 4-bit builds - w4a4, w4a8, nvfp4 - hold up against the mid GGUFs at equal or smaller size and need no custom node. nvfp4 is the best-looking of the three.

• Q2_K is visibly degraded. A haze sits over the frame, contrast is flat, small light sources smear. It is here because a 12 GB card has nothing else, not because it is good.

A warning about comparing these yourself. Between arms the model reinterprets the scene - a lamp is orange in one and violet in another, the framing sits higher or lower. That is seed-level variance amplified by quantisation, not a quality difference. And encoded bitrate is not a stand-in for detail retained: measured across this ladder it ranked Q2_K above Q5_K_M, which the frames flatly contradict. It measures high-frequency content, and noise counts as content.

What is deliberately not here

Four builds were made and then cut, which is worth saying plainly because you will find some of them elsewhere.

• Q3_K_S is broken, not merely worse. In a three-shot render a man turned into a dog-like animal mid-sentence while his voice carried on. Two independent reviewers caught it unprompted at the same timestamp. Q3_K_M is 0.9 GB larger and fine.

• The whole FP8 family is dominated by int8, on both axes. Accuracy across 24 identical real layers: int8_tensorwise 0.00942 relative error, mxfp8 0.02656, float8_e4m3fn 0.02682, float8_e5m2 0.05289 - all at the same 21.5 GB except mxfp8, which is 0.6 GB bigger. Speed on an RTX 5090 at 4096 tokens: int8 0.264 ms, float8_e4m3fn 0.415 ms, so it is 1.58x slower as well as three times less accurate. And float8_e5m2 does not run at all - PyTorch refuses to multiply two e5m2 matrices. There is no card and no workload for which those three are the better choice, so they are not in the listing.

• No IQ ladder. Not an omission - llama-quantize refuses IQ types for this class of file outright.

• The VAEs are not quantised and should not be. 1.5 GB and 0.4 GB - the saving disappears into a 16 GB budget and decode is exactly where artefacts show.

Smaller than the other LTX-2.5 GGUFs

Against the closest comparable set on Hugging Face these come out a flat 0.9 GB smaller at every level, and against the other published ladder the gap is wider still below Q5 - between 2.3 and 4.2 GB. No quality argument is involved in the first case: the roughly 2600 tensors that are never quantised - norms, biases, the scale-shift tables, the two input projections - are written F16 here and F32 there. Same weights, half the bytes.

How these were made

The tooling is public at github.com/jlucasmcrell/ltx25-quant-lab, because two things about converting this model are not obvious and each costs an afternoon.

GGUF quietly loses the config. ComfyUI does not infer LTX-2.5's transformer config from tensor shapes - it reads it from the safetensors metadata block, which GGUF does not have. A straight conversion produces a file that loads, samples, and then decodes audio through a connector sized 3840 instead of this checkpoint's 2048. Nothing errors. You get video with wrong sound. The fix is to carry the metadata across as GGUF key-values, which survive llama-quantize untouched.

K-quants are legal here. 4041 of 4349 tensors have a last dimension divisible by 256. Of the rest, all but two are bias vectors that stay F16 anyway - the two real exceptions are the input projections, whose 128-wide axis falls back to F16, which is what you want for those layers regardless.

The comfy-native builds mirror Lightricks. The set of 1440 Linears to quantise is taken from Lightricks' own int8-convrot release rather than guessed. adaLN, the timestep embedders, every norm and bias and the scale-shift tables stay bf16. Those steering layers are about 6% of the file, and rounding them is how a quantised DiT dies.

Honest limits

• comfy-w4a4 and comfy-nvfp4 were built and tested on Blackwell. The kernel paths declare SM 7.5+ and SM 8.0+, but neither has been run here on an Ada or Ampere 16 GB card, which is most of the audience this set is aimed at. If you are on a 4080 or 4070 Ti Super and one falls back to something slow, that is a real possibility and worth reporting. NVFP4 is Blackwell-only by construction. The GGUF ladder has no such question over it.

• The dev (non-distilled) transformer is present at fewer sizes than the distilled one. Distilled is what most people run.

• These are quantisations, not fine-tunes. Anything the base model does badly, these do badly and smaller.

Where the pieces live

• These files on Hugging Face - LTX-2.5-Quantized, the same builds with the full measurement write-up, if you would rather pull them with huggingface-cli than click.

• A workflow that already uses them - Dual Engine: MiniMax-H3 + LTX-2.5, on Hugging Face and GitHub. One graph, one script, one switch: render a scene as a continuous take with H3 or as an edited scene with native cuts using LTX-2.5. Point its two LTX loaders at any build here.

• The GGUF loader the .gguf half needs - ComfyUI-GGUF by city96. The comfy-* files need nothing.

• How these were cut, if you want to make your own - ltx25-quant-lab: the converter that survives the metadata trap, the ComfyUI-native quantiser, the mixed-precision solver and the load-check.

• The originals - Lightricks/LTX-2.5. Every file here is cut from those bf16 weights, never from another quant.

License

LTX-2.x Community License Agreement, inherited from Lightricks/LTX-2.5. The license text travels inside every .safetensors file's metadata.