Skip to content

What Each Quant Rung of a 33B Image Model Actually Costs

MiniMax H3 Image is 33.1B parameters and the circulating claim is that Q2_K puts it in 6.4 GB, so an 8 GB card can run it. The published GGUF files and their LPIPS-versus-VRAM table say something more precise: Unsloth’s 7.75 GB Q2_K build peaks at 9.4 GiB at 1024×1024, the rung names do not order quality, and the 32B text encoder is the bill nobody quotes.

AI-assisted draft. Reviewed and edited by the Phosphene team before publication.

On this page
A stack of flat grey storage slabs of decreasing thickness on a dark steel table, each one casting a longer shadow than the last, under a single hard light
Same model, fourteen file sizes, and one question: which rung still holds the picture together.

The claim that circulated this week was tidy. MiniMax H3 Image is 33.1B parameters, a community quantization took it down to 6.4 GB at Q2_K and 10.78 GB at Q4, and therefore 8 to 12 GB graphics cards are in play for a model that needed 66 GB of bf16 weights three weeks ago.

I went and looked at the files, because "fits in 6.4 GB" and "runs on 8 GB" are two different sentences and only one of them is checkable from a download. The GGUF repos are public and one of them ships a measurement table with LPIPS and peak VRAM beside every rung. Both say the same thing: the model is more usable than the headline suggests and less usable than the headline promises, and the gap between those two readings is two numbers nobody puts in the tweet.

The files are bigger than the claim, and that is not the real problem

Two independent Q2_K builds are published. realrebelai/MiniMax-H3-Image_GGUFs ships one at 6.88 GB and Unsloth's is 7.75 GB. Same nominal rung, 13 percent apart, which is what happens when two people prune and quantize the same DiT separately. The 6.4 GB figure is roughly right for the smallest variant and roughly useless as a planning number, because the file size was never the constraint.

Peak VRAM is. Unsloth measured it at 1024×1024 beside a quality score, and the measurement belongs to their build. Their Q2_K file is 7.75 GB and peaks at 9.4 GiB. No published peak exists for the 6.88 GB file, so the defensible statement is narrower than the headline: Unsloth's smallest rung does not fit in 8 GB, it fits in 10, and the other build is unmeasured rather than proven lighter in memory.

That gap between file and footprint is the first thing to internalise, and it is remarkably stable once the units are right. Sizes are reported in decimal GB and peaks in GiB, so 7.75 GB is 7.22 GiB and the Q2_K gap is 2.18 GiB, not the 1.65 a careless subtraction gives you. Across the whole ladder it lands between 2.12 and 2.48 GiB and averages 2.22:

  • Q2_K: 7.22 GiB of file, 9.4 GiB peak, 2.18 GiB of overhead
  • Q3_K_M: 9.70, 11.9, 2.20
  • UD-Q4_K_XL: 12.68, 14.8, 2.12
  • Q8_0: 20.52, 23.0, 2.48

That is activations plus the per-step heads, and at a fixed 1024×1024 it does not care how wide the weights are. Multiply the file size in GB by 0.93, add 2.2 GiB, and you have the footprint to within about a third of a gigabyte.

Bits per weight is how you check a rung name without downloading it

The pruned bf16 DiT in Comfy-Org/MiniMax-H3-Image is 40.23 GB. At two bytes per weight that is 20.1B parameters, not 33.1B, which tells you how much the "pruned" in every filename is doing: a third of the network is gone before quantization starts.

Divide any rung's size by 20.1B and you get its real bits per weight:

  • Q2_K, 7.75 GB: 3.08 bits
  • Q3_K_M, 10.42 GB: 4.14 bits
  • Q4_K_M, 12.72 GB: 5.06 bits
  • UD-Q4_K_XL, 13.61 GB: 5.41 bits
  • Q6_K, 16.60 GB: 6.60 bits
  • Q8_0, 22.03 GB: 8.76 bits

Q8_0 landing at 8.76 is the check that the arithmetic is sound. The format's ceiling is 8.5 bits per weight plus block scales, so a number just above 8.5 means the parameter estimate is right and the labels are honest. Every rung above is roughly one bit per step, and Q2_K is not a 2-bit file in any useful sense, it is a 3-bit file with the name of a 2-bit one.

The quality table, which is the actual product

Unsloth published LPIPS against the bf16 DiT at 1024×1024, lower is better, with 95 percent intervals, plus PSNR and the peak footprint:

  • Q2_K: LPIPS 0.438, PSNR 13.9 dB, 9.4 GiB
  • UD-Q2_K_XL: 0.347, 16.1 dB, 10.2 GiB
  • Q3_K_S: 0.347, 16.1 dB, 10.3 GiB
  • Q3_K_M: 0.271, 17.5 dB, 11.9 GiB
  • UD-Q3_K_XL: 0.242, 18.1 dB, 12.7 GiB
  • Q4_K_S: 0.225, 18.5 dB, 12.9 GiB
  • Q4_K_M: 0.195, 19.2 dB, 14.0 GiB
  • UD-Q4_K_XL: 0.172, 20.4 dB, 14.8 GiB
  • Q5_K_M: 0.157, 21.4 dB, 15.8 GiB
  • UD-Q6_K_XL: 0.130, 23.2 dB, 18.8 GiB
  • Q8_0: 0.083, 26.8 dB, 23.0 GiB

Two things fall out of this that a model ranking would hide.

The first is that neighbouring rungs are inside each other's error bars. UD-Q3_K_XL is 0.242 with an interval of 0.164 to 0.324, and it costs 0.9 GiB more than Q3_K_M at 0.271 with an interval of 0.199 to 0.339. Those overlap. Stepping a rung up buys you something real on average and nothing this evaluation can resolve, because the intervals come from 8 prompts times 2 seeds at 1024 and their width is the resolution of the instrument. The gaps that survive are the wide ones, and they still need the rung named rather than the number. Q2 to Q3 holds everywhere. Q3 to Q4 holds. Q4 to Q8 holds for Q4_K_M (0.136 to 0.246) and Q4_K_S (0.150 to 0.308), but not for UD-Q4_K_XL, whose 0.110 to 0.235 overlaps Q8_0's 0.039 to 0.129. Burn a weekend tuning between two rungs inside the same interval and you are tuning something the table cannot see.

The second is the shape of the curve. Q2_K to Q8_0 is 5.3 times the LPIPS and 12.9 dB of PSNR, which is the difference between a plausible picture and a wrong one. Somewhere between 0.44 and 0.17 the model stops being a worse version of itself and starts being a different model that has read about the prompt.

The dynamic quants are the interesting line. UD-Q2_K_XL scores 0.347 in 8.68 GB. Q3_K_S scores 0.347 in 8.77 GB. Identical quality, and the "lower" rung is the smaller file. Unsloth's own note points this out: the dynamic Q2 beats the plain Q2 clearly, and matches the nominal Q3 at a lower size. Rung names are a naming convention, not a quality order. If you only remember one line from this table, remember that one.

The 32B text encoder is the bill that arrives separately

None of the numbers above include the model that reads your prompt. H3 Image pairs with the Qwen3-VL-32B conditioning encoder, and the GGUF of it in unsloth/MiniMax-H3-GGUF is 18.2 GB at Q4_K_M. Comfy-Org's repack ships the same encoder at two precisions, 27.14 GB at int8 and 15.69 GB at nvfp4, which is the only real way to buy memory back without leaving the model family. The third file in their text_encoders/ folder, a 7.34 GB Qwen3.5 9B, is not an encoder for this model: their own README lists it as a prompt enhancer for the Generate Text node. Two different jobs, one folder, an easy way to download the wrong one.

And the encoder is a rung too. Unsloth's sensitivity note is the most useful sentence in the whole repository: quantizing the text encoder to Q4_K_M instead of bf16 moves a 1024×1024 image by LPIPS 0.17 on its own, with the DiT held constant. That is the scale of the entire DiT column, where Q8_0 sits at 0.083 against bf16 and UD-Q4_K_XL at 0.172. The table does not report the distance between two quantized outputs, so the two numbers cannot simply be added, but they live on the same axis and they are the same size. You can spend an evening climbing DiT rungs and lose the whole gain in the component you never thought to check.

This is why "8 GB works" is true in a way that "8 GB fits" is not. The pipeline loads the encoder, runs it, frees it, then brings in the DiT, so peak memory is the max of the phases rather than the sum, and the published peaks are DiT sampling plus VAE decode only. That is how a small card holds an 18 GB encoder for a few seconds with system RAM as the staging area.

The cost of that arrangement is larger than I expected, and it is not the DiT. Measured on a 24 GB L4 with UD-Q4_K_XL at 1024×1024, six steps:

  • plain sd-cli: 1.12 to 1.18 s per step, which is 6.7 to 7.1 s of sampling, and about 105 to 111 s per image once the Q4 encoder runs
  • --max-vram 12: 3.91 s per step, 25.1 s for DiT plus VAE, 88.1 s per image with the encoder
  • Unsloth Studio: 1.74 s per step, 12.1 s for the DiT, 71.4 s with the encoder
  • RTX PRO 6000 Blackwell, 96 GB: 0.40 s per step, 3.9 s per image with the encoder

So the sampler is seven seconds of a 105-second image, and capping the card at 12 GB triples the sampler while still finishing the job faster end to end, because the encoder was never going to sit beside the DiT on that card. The README says it plainly: on the L4 most of the end-to-end time is the 32B encoder, which does not fit next to the DiT and runs largely from host RAM. Output is byte identical either way. Anyone quoting step time as if it were image time is quoting a sixth of the job.

The ladder, by card

Read these as the best rung that fits without spilling, all at 1024×1024, DiT plus about 2.2 GiB of overhead:

  • 8 GB: nothing fits. Unsloth's Q2_K wants 9.4 GiB, roughly 1.4 GiB more than the card, so it needs --max-vram or --offload-to-cpu and patience. The 6.88 GB build has no published peak, so it is unmeasured rather than confirmed to fit.
  • 12 GB: Q3_K_M at 11.9 GiB fits with almost nothing to spare. UD-Q2_K_XL at 10.2 GiB is the safer pick. UD-Q3_K_XL at 12.7 GiB will spill.
  • 16 GB: UD-Q4_K_XL at 14.8 GiB, the rung Unsloth recommends. Q5_K_M at 15.8 is the last comfortable step; UD-Q5_K_XL at 16.8 is over the line.
  • 24 GB: Q8_0 at 23.0 GiB, but only through plain sd-cli, where it ran at 1.24 s per step on the L4. Through Unsloth Studio it does not fit beside the compute buffers and partly runs from host RAM at about 14 s per step, so on Studio the 24 GB answer is UD-Q4_K_XL.

Then remember that the table is 1024×1024 and the model's party trick is 4096×4096, plus edits that hold up to sixteen reference images. No 4K peak is published, so a 4K number has to be measured on your own card rather than inferred from this one. What transfers is the direction: the 2.2 GiB of overhead is a 1024×1024 figure and activations scale with token count, not with parameter count, so the distance between file size and footprint grows as the resolution does and the file size becomes a worse predictor the further you get from 1024.

Test the rung you will actually ship

The right experiment is cheap and specific. Pick your delivery size, render the same seed at Q2_K, UD-Q3_K_XL and UD-Q4_K_XL, and look at them next to each other at 100 percent. LPIPS is an average over a population of images, and your images are not that population: a flat product shot survives Q2 in ways that a face with fine hair does not.

Then check the one thing the table cannot tell you, which is whether the rung changed your prompt's obedience. LPIPS compares an image against the bf16 render, so it will register a moved object as a difference, but the score does not tell you whether the object went where you asked; nothing in the published table measures instruction following at all. That needs its own test. Take an explicit positive instruction, such as object count or placement, at the same prompt and seed across rungs. H3's documented interface rejects negative prompts and uses no classifier-free guidance, so a negative-prompt comparison is not a valid diagnostic here.

For the two-step variant of this model and what distillation costs instead of quantization, see the H3 Image draft loop. For the edit task on a 24 GB card and the licence that governs it, the P-H3 breakdown is the honest starting point. And if you are still deciding whether local is worth it at all, the bandwidth argument applies to this model as much as to the one measured there.

The headline number answers a different question from the benchmark. The smaller published Q2_K file is 6.88 GB, but its peak memory is unmeasured here. Unsloth’s measured 7.75 GB Q2_K build reaches 9.4 GiB at 1024×1024 for DiT sampling plus VAE decode, excluding the separately run text encoder, and its LPIPS is 5.3 times the top rung’s. That is still a remarkable thing to fit on a consumer card. It is just not free, and the cost is written in three columns that the tweet only showed one of.

Sources

Share this guide
X LinkedIn