ThinkFacility
  1. Can I run it locally?
  2. GLM

GLM VRAM requirements: can I run GLM-5.3 or GLM-5.2 locally?

GLM-5.3 and GLM-5.2 are 754 billion parameters each, 467 GB at a 4-bit quant. Here's what that means for a Mac Studio, and the two Flash models that fit far smaller machines.

Check your machine

Won't fit 201 GB

Weights, cache and overhead add up to more than the card and the RAM together.

  • Weights 200 GB
  • Context cache 0.6 GB
  • Overhead 0.8 GB
  • Fast memory
  • With system RAM

What we found

GLM-5.3 and 5.2 are the same size, so one answer covers both. At 4-bit that's a 512 GB Mac Studio with its GPU memory limit raised, and the smallest file, UD-IQ1_S (217 GB), still comes to 221 GB with a 32K context.

GLM-5.3 Flash is where it gets interesting. Three quarters of its layers use linear attention, so a million tokens of context costs 14.9 GB of cache. Full GLM-5.3 would need 115 GB for the same million. Its smallest file, UD-IQ1_S (93.1 GB), fits a DGX Spark or a 128 GB Mac.

For a single 24 GB card, GLM-4.7 Flash is the GLM that fits: 20.9 GB with a 32K context. Like DeepSeek it caches a compressed latent instead of full keys and values, which is why its cache stays small.

One detail for the GLM-5 models: their sparse attention keeps an extra indexer key for every token, and we count it in the cache.

GLM-5.3 Flash

321 billion parameters · mixture of experts, 8 of 288 active · up to 1M context · 871 thousand downloads in 30 days

GLM-5.3 Flash needs about 201 GB at UD-Q4_K_XL with a 32K-token context. The file itself is 200 GB, and the cache for 32K tokens adds 0.6 GB. No single consumer card holds it. A Mac with 256 GB of unified memory does, and a PC can split it between a GPU and system RAM. It routes each token through 8 of 288 experts, so it runs faster than its size suggests.

Only 11 of its 45 layers keep a growing cache (the rest carry a fixed-size state), so the full 1M context costs 14.9 GB of cache.

QuantFileAt 8KAt 32KSmallest GPUSmallest Mac
UD-IQ1_S93.1 GB94.2 GB94.5 GB96 GB96 GB*
UD-Q2_K_XL109 GB110 GB110 GBnone128 GB*
UD-Q3_K_XL148 GB149 GB149 GBnone256 GB
UD-Q4_K_XL200 GB201 GB201 GBnone256 GB
UD-Q5_K_XL240 GB241 GB242 GBnone256 GB*
UD-Q6_K_XL292 GB293 GB293 GBnone512 GB
Q8_0341 GB342 GB342 GBnone512 GB
BF16642 GB643 GB643 GBnonenone

Smallest GPU and Mac are for the 32K total. * with the Mac's GPU memory limit raised.

Sources: GGUF files · config.json

GLM-5.3

754 billion parameters · mixture of experts, 8 of 256 active · up to 1M context · 606 thousand downloads in 30 days

At UD-Q4_K_XL, the GLM-5.3 file is 467 GB, and with 32K tokens of context and runtime overhead it comes to about 472 GB. No single consumer card holds it. A Mac with 512 GB of unified memory does once you raise the GPU memory limit, and a PC can split it between a GPU and system RAM. It routes each token through 8 of 256 experts, so it runs faster than its size suggests.

It caches a compressed latent per token rather than full keys and values, about 107 KB a token, so the cache is small next to the weights: 115 GB at 1M.

QuantFileAt 8KAt 32KSmallest GPUSmallest Mac
UD-IQ1_S217 GB218 GB221 GBnone256 GB*
UD-Q2_K_XL254 GB256 GB258 GBnone256 GB*
UD-Q3_K_XL343 GB345 GB347 GBnone512 GB
UD-Q4_K_XL467 GB469 GB472 GBnone512 GB*
UD-Q5_K_XL562 GB564 GB567 GBnonenone
UD-Q6_K_XL684 GB686 GB689 GBnonenone
Q8_0801 GB803 GB806 GBnonenone
BF161,508 GB1,510 GB1,512 GBnonenone

Smallest GPU and Mac are for the 32K total. * with the Mac's GPU memory limit raised.

Sources: GGUF files · config.json

GLM-5.2

754 billion parameters · mixture of experts, 8 of 256 active · up to 1M context · 344 thousand downloads in 30 days

GLM-5.2 needs about 470 GB at UD-Q4_K_M with a 32K-token context. The file itself is 466 GB, and the cache for 32K tokens adds 3.6 GB. No single consumer card holds it. A Mac with 512 GB of unified memory does once you raise the GPU memory limit, and a PC can split it between a GPU and system RAM. It routes each token through 8 of 256 experts, so it runs faster than its size suggests.

It caches a compressed latent per token rather than full keys and values, about 107 KB a token, so the cache is small next to the weights: 115 GB at 1M.

QuantFileAt 8KAt 32KSmallest GPUSmallest Mac
UD-IQ1_S217 GB218 GB221 GBnone256 GB*
UD-Q2_K_XL254 GB256 GB258 GBnone256 GB*
UD-Q3_K_XL343 GB345 GB347 GBnone512 GB
UD-Q4_K_M466 GB468 GB470 GBnone512 GB*
UD-Q5_K_XL562 GB564 GB567 GBnonenone
UD-Q6_K_XL684 GB686 GB689 GBnonenone
Q8_0801 GB803 GB806 GBnonenone
BF161,508 GB1,510 GB1,512 GBnonenone

Smallest GPU and Mac are for the 32K total. * with the Mac's GPU memory limit raised.

Sources: GGUF files · config.json

GLM-4.7 Flash

29.9 billion parameters · mixture of experts, 4 of 64 active · up to 198K context · 141 thousand downloads in 30 days

At Q4_K_M, the GLM-4.7 Flash file is 18.3 GB, and with 32K tokens of context and runtime overhead it comes to about 20.9 GB. The smallest card that holds it whole is a 24 GB card (RTX 3090, RTX 4090). It routes each token through 4 of 64 experts, so it runs faster than its size suggests.

It caches a compressed latent per token rather than full keys and values, about 53 KB a token, so the cache is small next to the weights: 11.0 GB at 198K.

QuantFileAt 8KAt 32KSmallest GPUSmallest Mac
UD-TQ1_08.3 GB9.6 GB10.9 GB12 GB16 GB
UD-Q2_K_XL11.9 GB13.1 GB14.5 GB16 GB24 GB
UD-Q3_K_XL13.8 GB15.0 GB16.4 GB16 GB24 GB
Q4_K_M18.3 GB19.6 GB20.9 GB24 GB24 GB*
Q5_K_M21.4 GB22.7 GB24.0 GB24 GB32 GB*
Q6_K24.7 GB26.0 GB27.3 GB32 GB32 GB*
Q8_031.8 GB33.1 GB34.4 GB48 GB48 GB
BF1659.9 GB61.2 GB62.5 GB96 GB64 GB*

Smallest GPU and Mac are for the 32K total. * with the Mac's GPU memory limit raised.

Sources: GGUF files · config.json

GLM-4.6V Flash

9.4 billion parameters · up to 128K context · 20 thousand downloads in 30 days

GLM-4.6V Flash needs about 8.3 GB at Q4_K_M with a 32K-token context. The file itself is 6.2 GB, and the cache for 32K tokens adds 1.3 GB. That fits a 8 GB card (RTX 4060, RTX 3070). On a Mac, 16 GB of unified memory is enough.

Every token of context adds 40 KB of cache, so the full 128K would put 5.4 GB on top of the weights.

QuantFileAt 8KAt 32KSmallest GPUSmallest Mac
UD-IQ1_S3.2 GB4.4 GB5.4 GB8 GB16 GB
UD-Q2_K_XL4.2 GB5.4 GB6.4 GB8 GB16 GB
UD-Q3_K_XL5.1 GB6.3 GB7.3 GB8 GB16 GB
Q4_K_M6.2 GB7.3 GB8.3 GB8 GB16 GB
Q5_K_M7.1 GB8.2 GB9.2 GB12 GB16 GB
Q6_K8.3 GB9.4 GB10.4 GB12 GB16 GB
Q8_010.0 GB11.1 GB12.2 GB12 GB16 GB*
BF1618.8 GB20.0 GB21.0 GB24 GB24 GB*

Smallest GPU and Mac are for the 32K total. * with the Mac's GPU memory limit raised.

Sources: GGUF files · config.json

How the numbers are worked out

Total memory is three parts added together. Weights are the exact size of the GGUF file on Hugging Face, all parts summed when a quant is split. The context cache (the KV cache) comes from each model's own config.json:

cache = layers × kv_heads × head_dim × 2 (K and V) × 2 bytes × tokens

Sliding-window layers stop at their window plus llama.cpp's 512-token batch. Linear-attention and Mamba layers keep a fixed state instead, which we add once. Latent-attention models (DeepSeek, Kimi, GLM-5) cache kv_lora_rank + rope dimensions per layer, the way llama.cpp does. Overhead is our allowance: 0.5 GB for the GPU context plus the output buffer, 512 × vocabulary × 4 bytes.

A "24 GB" card holds 24 GiB, which is 25.8 GB in the decimal units file sizes use, and we count it that way. Macs get the share Metal allows by default, two thirds of unified memory up to 32 GB and three quarters above (llama.cpp discussion 2182); CPU-only machines and the DGX Spark keep 4 GB back for the operating system. All of it assumes llama.cpp's defaults: an f16 cache and one conversation at a time. Quantizing the cache to q8_0 halves it.

Files are Unsloth's GGUF uploads, the most downloaded quantizations on Hugging Face, and the list refreshes daily from Hugging Face's API. A model joins when its repo passes 20,000 downloads in 30 days. Last checked September 25, 2026.