LTX-2.5 on a Smaller Graphics Card: How to Pick the Right Shrunk Video Model File

Unsloth published 22 versions of the open video-and-sound model, 20 of them compressed, each with a quality score. The table holds two surprises: the bigger file is not always closer to the original, and some of the differences are smaller than the measurement's own wobble.

There are now 22 copies of the same open video model in one folder, ranging from 8.46 GB to 42 GB. Twenty are shrunk; the two biggest are full-size references. They all make the same kind of clip: moving pictures with sound, from a text prompt or a starting image. They differ only in how much of the original model's detail they kept. And in at least one pair, the smaller file sits closer to the original than the bigger one, on both of the measures the publisher used.

That folder is unsloth/LTX-2.5-GGUF, posted on October 13 by Unsloth, a team known for shrinking AI models so they run on ordinary hardware. The model inside is LTX-2.5 from Lightricks, one of the few open video models that generates picture and sound together. Shrunk versions of LTX-2.5 from other people have been around since mid-August. What is new here is a table: every file was tested against the full-size model and given a score.

Most people pick these files the way they pick a camera card. Get the biggest one that fits. That habit works most of the time. This table shows when it does not, and it also shows something rarer: the publisher's own warning about how much of the table to believe.

What "shrinking" a video model means

A model like LTX-2.5 is, underneath, billions of stored numbers. The full-size file keeps each number at high precision, which is why it weighs 42 GB. A shrunk file stores each number with fewer digits. Think of it like saving a photograph as a smaller JPEG: most of the picture survives, fine detail goes first, and push it too far and you get mush.

The file names encode how hard each copy was squeezed. You do not need to decode them. Two rules cover it. The number after the Q is roughly how many digits each stored value keeps (2 is brutal, 8 is gentle). And files starting with "UD-" use Unsloth's mixed method, which spends extra detail on the parts of the model that suffer most when squeezed.

There are also two versions of the model in the folder. The fast version, which Unsloth labels distilled, makes a clip in two short passes (eight steps, then three). The full version takes thirty passes and follows your prompt more closely. Each comes in ten shrunk sizes plus one full-size file, which is how you get to 22.

How Unsloth scored the files

For each file, Unsloth rendered the same prompt with the same random seed and the same settings, then compared the frames to what the full-size model produced. The main score is LPIPS, a picture-similarity measure designed to track how different two images look to a person. Zero means identical. Higher means further away. A second score, PSNR, measures pixel-by-pixel closeness, where higher is better.

Here is the pair that should change how you choose. For the fast version:

• The 12.0 GB file UD-Q3_K_XL scored 0.310.
• The 13.58 GB file Q4_K_M scored 0.352.

The smaller file was closer. Its pixel score was better too, 19.1 against 18.1. For the full version, the gap is wider: the same 12 GB file scored 0.246 against 0.330 for the larger one, with the pixel score again favouring the smaller file. The mixed method earns its keep. A plain "Q4" is not automatically better than a "UD-Q3".

Unsloth's own recommendation is the 14 GB UD-Q4_K_XL for most cards and the 9.5 GB UD-Q2_K_XL for small ones, plus Q8_0 (22.78 GB) if you want the result closest to the original. On the full version, UD-Q4_K_XL scored 0.183, which is a clear step closer than the plain 13.58 GB file at 0.330.

The warning hidden in the card

This is the line most people will scroll past, and it is the most honest sentence on the page. Unsloth notes that simply running the full-size model with a speed-up setting (compiled) versus without it (uncompiled) "already differs by 0.265." Same model, same file, same prompt, and the score still moves by 0.265 because of how the software was run.

The card does not call this a noise floor. That reading is mine, but I think it is the right one: treat 0.265 as the measurement's own wobble. A difference between two files that is smaller than that may not be visible in practice at all.

Read the table with that in mind and it splits in two. On the fast version, almost every mid-size file scores between about 0.27 and 0.35. Those differences are real numbers, but they sit close to the wobble, so the table cannot really tell those files apart for you. On the full version, the bigger mixed files fall well below the wobble (0.162 to 0.183 for the 14 and 16 GB mixed files), so there the table does separate good from mediocre.

The practical upshot is simple. If you mostly use the fast version, pick by what fits on your card and test with your own eyes. If you use the full version, the table is a much better guide and the mixed files are worth their size.

Put this into practice

Here is the setup in ComfyUI, the free node-based app most people use to run open image and video models locally. The steps come from the Unsloth model card.

1. Update ComfyUI so it includes LTX-2.5 support, then install the ComfyUI-GGUF custom node. This is what lets ComfyUI read the shrunk files.
2. Download one model file into your ComfyUI unet folder. The card's example command is hf download unsloth/LTX-2.5-GGUF distilled/ltx-2.5-22b-distilled-UD-Q4_K_XL.gguf.
3. Download the companion parts from the official Lightricks/LTX-2.5 repository. The shrunk file only replaces the main model; the text-reading part, the video and audio decoders and the upscaler still come from Lightricks:

text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors   -> text_encoders/
vae/ltx-2.5-video-vae-bf16.safetensors                         -> vae/
vae/ltx-2.5-audio-vae-bf16.safetensors                         -> vae/
latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors -> latent_upscale_models/

4. Open ComfyUI's built-in Text to Video (LTX-2.5) template. Find the node called Load Diffusion Model and replace it with Unet Loader (GGUF), pointed at your file.

Which file should you start with? Unsloth's own advice gives you three starting points, and nothing more precise is published:

• Most cards: UD-Q4_K_XL, 14 GB. Unsloth calls it "clearly better than Q4_K_M" and about level with a file 1.6 GB larger.
• Small cards: UD-Q2_K_XL, 9.5 GB, which the card says is "far cleaner than Q2_K" for about 1 GB more.
• Closest to the original: Q8_0, 22.78 GB.

The 12 GB UD-Q3_K_XL is not on that list, which is exactly why it is worth a test if 14 GB is a squeeze.

If you would rather not touch nodes, Unsloth Studio, Unsloth's own app, does this for you. Per the card: "Pick LTX-2.5 on the Video page and choose one of these GGUF files."

Then run your own test, because the published scores come from Unsloth's clips, not yours. This takes an evening:

• Pick two candidate files that fit your card, for example the 12 GB and 14 GB mixed files.
• Write one prompt that looks like your real work. If you make product shots, use a product. If you make talking heads, use a face with dialogue.
• Fix the seed, so both files start from the same random noise. Keep every other setting identical.
• Render both and play them side by side, or stack them with a Difference blend in your editor, which shows black wherever the two match.
• Listen separately. The scores measure frames only. Unsloth's sample render included audio, but the card gives no score for sound.

If you cannot see or hear the difference on your own material, take the smaller file and spend the saved memory on resolution or length.

Where it breaks

The file size is not your memory budget. The companion text-reading model is a separate file (a Gemma model of the 12-billion-parameter class, judging by its filename), and the decoders and upscaler need room too. A 12 GB main file does not mean the whole job fits on a 12 GB card. The card's low-memory tip, which moves work to your computer's main memory, is written for its Python route rather than for ComfyUI.

One test, one set of clips. The scores come from Unsloth's renders. The sample settings listed are 1280x704, 121 frames at 24 frames per second, about five seconds. Your prompts, lengths and resolutions may behave differently.

Sound is unmeasured. The model's selling point is picture and sound together, and only the picture was scored. If audio matters to you, your ears are the only test.

The scores sit near their own noise floor. The fast-version table mostly falls inside the 0.265 wobble the card itself reports. Do not choose between two fast-version files on a 0.01 difference.

It is not an official release. The card says plainly that these are derived copies and "not an official Lightricks release." If something looks wrong, test the full-size model before blaming Lightricks.

The licence has a ceiling. LTX-2.5 is free for commercial use for organisations under $10 million in annual revenue, under the LTX-2.x Community License. Above that, you need a paid agreement with Lightricks. The shrunk files carry the same terms.

The habit worth keeping

The useful lesson here outlives this model. Every few weeks, someone publishes a smaller copy of a popular model with a confident name and a size that fits your card. Very few of them tell you what was lost. Unsloth did, and then told you how far to trust its own numbers.

Next time you download a shrunk model of any kind, look for that table. If there is none, make your own: same prompt, same seed, two files, side by side. The answer will not always be "bigger is better," and the only way to know is to look.

---

Medium metadata

Title: LTX-2.5 on a Smaller Graphics Card: How to Pick the Right Shrunk Video Model File

Subtitle: Unsloth published 20 compressed versions of the open video-and-sound model with a quality score for each. A 12 GB file beats a 13.58 GB one, and the card's own noise warning tells you when the scores stop meaning anything.

Tags: AI Video, Generative AI, ComfyUI, Video Production, Open Source

Estimated read time: 8 minutes