How Much VRAM Does GLM 5.3 Need?
The short answer, now that the weights are public: 254 GB at 2-bit, 467 GB at 4-bit, and 1.51 TB if you want the model as the lab trained it. Z.ai released GLM 5.3 on August 28, 2026 at 14:48 UTC, two weeks after the API launch, and it is a 753-billion-parameter Mixture-of-Experts model with a 1M context window.
The interesting number is not any of those. It is the one next to it. On Artificial Analysis's Intelligence Index, GLM 5.3 scores 60, exactly level with Kimi K3, a model with 2.8 trillion parameters. Same score, 3.7 times fewer parameters, and 3.4 times less memory to run at the same quantization.
That is what this page is about: the GLM 5.3 VRAM requirements at every quantization tier, checked against the files Z.ai actually published, and what the gap between 753B and 2.8T means for the hardware you would need to buy.
GLM 5.3 VRAM Requirements at a Glance
Every figure below comes from our VRAM calculator at 8,192 tokens of context with an FP16 KV cache on llama.cpp, sized from the published weights rather than the marketing parameter count. These are total memory needed, weights plus cache plus runtime overhead, converted to decimal GB. The calculator itself displays GiB, so it shows 435.1 where this table says 467 GB for the same configuration.
| Quantization | Memory needed | What it takes |
|---|---|---|
| FP16 / BF16 | 1,538 GB | a rack |
| Q8_0 | 818 GB | multi-node |
| Q6_K | 632 GB | multi-node |
| Q5_K_M | 546 GB | 2x 432 GB cards |
| Q4_K_M | 467 GB | 2x B300 288GB, 76% used |
| Q3_K_M | 323 GB | one 432 GB card |
| Q2_K | 254 GB | one 432 GB card, or offload |
Those are all-in-VRAM figures, which is a different question from what you can actually run. Keep reading, because the answer to the second question is a lot friendlier than the first.
The Checkpoint Z.ai Ships Is FP8, and the Config Says Otherwise
This one costs people a download if they miss it.
zai-org/GLM-5.3 is 755.62 GB across 141 shards, carrying 118,629 tensors. config.json in that same repo declares "dtype": "bfloat16". Those two facts cannot both describe the same file: 755 GB for 753B parameters is one byte per parameter, not two, and the extra tensor count is the FP8 scale factors sitting alongside each quantized weight.
The genuine BF16 weights are in a separate repository. zai-org/GLM-5.3-BF16 measures 1,506,659,919,872 bytes across 282 shards with 59,585 tensors, which divides cleanly by two bytes per parameter into 753.33 billion.
So the default repo is the FP8 build. If you want BF16, ask for it by name.
What It Actually Takes to Run GLM 5.3
Here is where the all-in-VRAM table above stops being the whole story.
Unsloth published their GLM 5.3 guide alongside the weights, and their ladder counts total memory, system RAM and VRAM together:
| Tier | Unsloth's figure | Our engine |
|---|---|---|
| 1-bit | 223 GB | not modelled |
| 2-bit | 245 GB | 254 GB |
| 3-bit | 290 to 360 GB | 323 GB |
| 4-bit | 372 to 475 GB | 467 GB |
| 6-bit | 570 GB | 632 GB |
| 8-bit | 810 GB | 818 GB |
Four of our five comparable figures land inside their stated range, and the 8-bit rows agree to within 1 percent. Those are the guide's planning figures. The files themselves shipped later the same day and the agreement got considerably tighter, which is the table further down.
Their recommended tier is the 2-bit dynamic quant, and their own words on what it needs are the sentence worth quoting:
can directly fit on a 256GB unified memory Mac and works well in a 1x24GB GPU and 256GB of RAM with MoE offloading
One 24 GB card and 256 GB of system RAM. That is an enthusiast workstation, not a datacenter, and it is the same trick that made a 2.8T model reachable when Kimi K3's 1-bit build landed. The mechanism is MoE offload: only a handful of experts are active per token, so the inactive ones can live in system RAM and be pulled across as needed. Our llama.cpp flags guide covers the -ncmoe and -cmoe switches that do it.
What you trade is speed. Offload moves the bottleneck from the card's memory bandwidth to the PCIe bus and your DDR, and no formula on this site models that path. What the measured runs on our tokens per second page show for models in this class is roughly 20 tok/s on offload setups, against several times that for anything sitting entirely in VRAM.
What You Can Actually Download Today
Checked at 19:35 UTC. The GGUF builds took most of launch afternoon to appear and they are all up now.
unsloth/GLM-5.3-GGUF carries five, and these are the shipped file sizes rather than anybody's estimate:
| Build | Shards | File size | Our weights estimate | Apart |
|---|---|---|---|---|
| UD-IQ1_S | 6 | 216.72 GB | not modelled | |
| UD-IQ1_M | 6 | 228.49 GB | not modelled | |
| UD-Q2_K_XL | 7 | 253.88 GB | 247.0 GB | 2.7% light |
| UD-Q3_K_XL | 9 | 342.97 GB | 315.7 GB | 8.0% light |
| UD-Q4_K_XL | 11 | 467.29 GB | 456.3 GB | 2.3% light |
Read that table carefully, because there is an easy mistake in it and we nearly published it. Our calculator's headline number is total memory needed: weights plus KV cache plus backend overhead. A GGUF file on disk is weights only. Compare our total against their file and Q2 lands 0.1 percent away and Q4 lands 0.02 percent away, which looks extraordinary and means nothing. Our overhead term happens to be about the size of the gap between our weight estimate and their real file.
Weights against weights, which is the honest comparison, we run 2 to 3 percent light on the two mainstream tiers. That is a good result for a formula reading a config against files built by a separate quantizer, and it is not a tenth of a percent.
The Q3 row is 8 percent out and that gap is real rather than a units problem. UD-Q3_K_XL is a Dynamic build: the XL suffix means the layers that matter most are held at higher precision than a uniform Q3 would use, so the file comes out fatter than the label implies. Two files at nominally the same bit depth are not the same file, and this is what that looks like in bytes.
Unsloth's own announcement puts the 2-bit build at 239 GB and says it retains about 81 percent accuracy, shrunk from 1.51 TB. The 239 GB figure refers to UD-IQ2_M, which is not in the repository: what shipped at 2-bit is UD-Q2_K_XL at 253.88 GB. If you are budgeting memory, budget for the file that exists.
NVFP4 is also up, from two publishers. incoai/GLM-5.3-NVFP4 and RadixArk/GLM-5.3-NVFP4 both measure 464,795,267,072 bytes, 464.8 GB, byte for byte the same conversion published twice. NVFP4 executes natively on Blackwell tensor cores. On anything older it is the wrong file to download.
So the routes that exist right now, by download size: the 1-bit builds at 217 to 228 GB, the 2-bit at 254 GB, which is the one that fits a 256 GB Mac or an offload rig, the 3-bit at 343 GB, the 4-bit at 467 GB, and NVFP4 at 465 GB for Blackwell hardware. Leave headroom above the file size for the cache and the runtime, which is what the table at the top of this page is counting and the file sizes are not.
If you have 256 GB of unified memory on Apple silicon, the Mac checker handles that case, because macOS hands the GPU a share of one pool rather than a fixed allocation and the share is not published as a formula.
753B for 2.8T Intelligence
Artificial Analysis evaluated GLM 5.3 on August 18, 2026, ten days before the weights existed, while it was reachable only through Z.ai's API. Index version 4.1.1.
| GLM 5.3 | Kimi K3 | Claude Opus 4.8 | |
|---|---|---|---|
| Intelligence Index | 60 | 60 | 61.4 |
| Total parameters | 753B | 2,800B | not published |
| Q4_K_M at 8K | 467 GB | 1,594 GB | not downloadable |
| As the lab ships it | 756 GB, FP8 | 1,561 GB, MXFP4 | not shipped |
Same score as Kimi K3 for 3.4 times less memory, and 1.4 points behind a model that took the number one spot on that index when it launched and cannot be run on your hardware at any price.
That is the whole argument for paying attention to this release. Parameter counts have been a poor proxy for capability for a while, and this is the cleanest demonstration yet: two open models, both sizes published, both measured by the same people on the same index, landing on the same number with a 2-trillion-parameter gap between them.
Z.ai's published table goes further than the index does. On the 16 rows in their model card, GLM 5.3 beats Claude Opus 4.8 on 13, including Terminal Bench 3.0 at 28.3 against 21.1, FrontierSWE at 78.1 against 66.5, and GDPval-AA v2 at 1769 against 1588. Opus 4.8 takes NL2Repo, SWE-Marathon and Toolathlon Verified. Those are Z.ai's figures, run with the harnesses and settings documented in their footnotes.
The Architecture, and Why the Context Window Is Cheap
Z.ai's first line about GLM 5.3 is that it uses the same base model as GLM 5.2, with every gain coming from post-training. The config bears that out exactly, which is why our calculator entry for it is geometrically identical to the 5.2 one:
- 78 layers, hidden size 6,144, 64 attention heads at head dim 192
- MLA compressed KV cache: a 512-wide latent plus a 64-wide rope key, so 576 per token per layer instead of the 12,288 a naive 64-head cache would want
- A sparse attention indexer at head dim 128, and
indexer_typesshows only 21 of the 78 layers store their own indexer keys. The other 57 share - 256 routed experts plus 1 shared, 8 routed per token, with the first 3 layers left dense
- 1,048,576 token native context, vocabulary 154,880, one MTP layer
The MLA compression is why the 1M window is not the problem you would expect. The weights are the wall here, not the cache.
What Changed Since GLM 5.2
Two things, and only one of them is in the architecture.
The licence is not MIT. GLM 5.2 shipped MIT. GLM 5.3 ships under license: other with license_name: glm-5.3, a custom licence carrying Z.ai's own terms. Commercial users check this first, so it is worth knowing before a 756 GB download starts.
The default repository is FP8, as covered above. GLM 5.2's default was not.
Speed, and a Figure That Disagrees With Itself
Artificial Analysis measures GLM 5.3 at 66.5 output tokens per second with a 1.62 second time to first token, on hosted API infrastructure rather than anything local.
Z.ai's own model card cites Artificial Analysis for a different number. In the ExploitGym footnote, where they rescale time budgets by throughput, they quote 115 tok/s for GLM 5.3, 40 for Kimi K3 and 47 for Qwen3.8 Max. That is 1.7 times what Artificial Analysis publishes on their own page for the model, and we cannot reconcile the two: it could be a different provider, a different measurement window, or the Flash model. Treat 66.5 as the citable figure and read the ExploitGym results knowing their clock was set by the other one.
The verbosity number matters more than either. Across the Intelligence Index, GLM 5.3 emitted 170 million output tokens against a 72 million median. Artificial Analysis calls it very verbose, and for anyone sizing a machine that is the figure with teeth: a model that emits 2.4 times the median tokens at 66.5 tok/s is not fast, whatever its throughput says. Note also that reasoning_effort defaults to max on this model unless you pass low or high explicitly.
Frequently Asked Questions
How much VRAM does GLM 5.3 need?
467 GB at Q4_K_M with 8K of context, and 254 GB at Q2_K, if the whole model sits in VRAM. With MoE offload the practical floor is much lower: Unsloth's 2-bit dynamic build runs on one 24 GB card backed by 256 GB of system RAM.
Can I run GLM 5.3 on a single GPU?
Not entirely in VRAM. No single card in our catalogue holds 467 GB. With offload, yes, and Unsloth names a 24 GB card plus 256 GB of RAM as a working configuration for the 2-bit build.
How many parameters does GLM 5.3 have?
753 billion total, measured from the BF16 checkpoint rather than taken from an announcement. Z.ai does not publish an active-parameter count, and the config shows 8 routed experts plus 1 shared per token out of 256.
Is GLM 5.3 better than GLM 5.3 Flash?
They are different models, not tiers of one. Flash is 320B with 18B active and scores 57 on the Intelligence Index; the full model is 753B and scores 60. Flash is far easier to run, which our GLM 5.3 Flash page covers.
Is GLM 5.3 MIT licensed?
No. GLM 5.2 was MIT. GLM 5.3 ships under a custom licence named glm-5.3 in the model card.
What context length does GLM 5.3 support?
1,048,576 tokens natively, and the MLA compressed cache keeps that far cheaper than the layer count suggests.
Which backends run GLM 5.3?
Z.ai lists SGLang, vLLM, TokenSpeed, Transformers, KTransformers and Unsloth, plus vLLM-Ascend, xLLM and SGLang for Ascend NPU deployments.