This article was originally published on runaihome.com
TL;DR: GLM 5.2 is the best open-weight coding model of mid-2026 and it ships under a permissive MIT license — but the smallest quant that's actually worth running is a 241GB 2-bit GGUF. No single consumer machine you can buy today fits it with headroom. Run it locally only if you already own 256GB+ of RAM; everyone else should use the API and keep their GPU for Qwen3.6 and Gemma 4.
| GLM 5.2 (2-bit local) | GLM 5.2 (API) | What runs on one 24GB GPU | |
|---|---|---|---|
| Best for | Owners of a 256GB+ RAM box | Anyone who wants the quality now | Daily local coding/chat |
| Price / Cost | ~$13k+ in hardware to do it well | ~$5.80 per 1M tokens (blended) | Used RTX 3090, ~$1,070 |
| The catch | 3–9 tok/s, MoE offload pain | Data leaves your machine | Not GLM 5.2 — smaller models |
Honest take: GLM 5.2's open weights are a gift to cloud providers and a tease to home labbers. The license is free; the 241GB of memory is not. Use the API for GLM 5.2 itself, and keep your local rig for models that actually fit.
Z.ai (Zhipu) launched GLM 5.2 on June 13, 2026, with the MIT-licensed open weights landing on Hugging Face mid-month. The headline is real: on SWE-bench Pro it scored 62.1, beating GPT-5.5 (58.6) and its own predecessor GLM 5.1 (58.4), at roughly one-sixth the API cost. For a model you can legally download, fine-tune, and self-host with no usage restrictions, that's the strongest open coding result of the year.
The catch is the one nobody puts in the headline. GLM 5.2 is a 744B-parameter Mixture-of-Experts model. Even after the most aggressive quantization that keeps the model coherent, you're looking at 241GB just for the weights. That number rules out almost every home lab, and it's the reason this article is a buying-decision guide, not a setup tutorial.
What GLM 5.2 actually is
GLM 5.2 keeps the same ~40B active-parameter count as GLM 5.1 but expands the total parameter pool to 744B across its expert layers (some sources cite ~753B; Z.ai's own materials round to 744B). The MoE design means only ~40B parameters fire per token, so inference compute is modest — roughly in the league of a 40B dense model. But MoE doesn't shrink memory: every one of those 744B parameters has to be resident, because any expert can be selected at any token.
That's the trap that catches people coming from dense-model intuition. A 32B dense model at Q4 needs ~20GB and runs at ~60 tok/s on an RTX 4090. A 744B MoE model needs all 744B parameters in memory even though it only computes 40B per token. The active-parameter count tells you about speed; the total parameter count tells you about whether it fits at all. For the difference between these two numbers and why it confuses buyers, see our breakdown in Why Local LLMs Got Good in 2026.
Other specs that matter:
- Context window: 1 million tokens (output up to 131,072), roughly 5× GLM 5.1's ~200K ceiling.
- License: MIT — genuinely permissive, including commercial use and redistribution.
- Day-one tooling: vLLM and SGLang support, plus Unsloth Dynamic GGUF quants on Hugging Face.
The VRAM reality: every quant, what it needs
Here's the memory map, built from Unsloth's Dynamic GGUF release for GLM 5.2. "Memory" below means total available memory — VRAM plus system RAM — because MoE offloading lets you spill expert weights to RAM at a speed cost.
| Quant | File size | Min memory to run | Realistic hardware | Quality retained |
|---|---|---|---|---|
| UD-IQ1 (1-bit dynamic) | ~217GB | ~180GB | 1×24GB GPU + 192GB RAM (tight) | ~76% |
| UD-IQ2_XXS (2-bit dynamic) | ~241GB | ~256GB | 1×24GB GPU + 256GB RAM | ~82% |
| UD-Q4_K_XL (4-bit dynamic) | ~376–476GB | ~512GB | Multi-GPU server / 512GB RAM | ~lossless |
| Q8_0 (8-bit) | ~805GB | ~805GB | 8×H100 class | near-lossless |
| BF16 (full) | ~1.51TB | ~1.5TB+ | 16×H200 class | reference |
The numbers that matter for a home lab are the top two rows. Unsloth's 1-bit dynamic quant gets you in at ~217GB and around 76% of full accuracy. The 2-bit dynamic quant at ~241GB holds ~82% accuracy and is the lowest quant most people consider usable. Anything below 1-bit collapses into incoherence.
Note the gap between the quant file size and the minimum memory to run: you need a little headroom for the KV cache and context. And the KV cache for a 1M-token context is not small — long-context use pushes memory well past the weight size, which is why nobody is running GLM 5.2 at a million tokens on a workstation.
Can any single machine I can buy today run it?
This is where the "effectively cloud-only" verdict comes from.
The 192GB Mac problem. The natural assumption is "buy a maxed-out Mac Studio." But the 2-bit dynamic quant is 241GB, and a 192GB Mac Studio simply can't hold it — you're 49GB short before counting context. The 1-bit quant (~217GB) also overflows 192GB. You'd need a 256GB-or-larger unified-memory machine.
And here's the kicker we flagged in our MiniMax M3 hardware guide: Apple pulled its high-RAM Mac Studio configurations through early 2026 (the 512GB option in March, the 256GB option in May), leaving the M3 Ultra shipping in lower-RAM trims. If you can still find a 256GB M3 Ultra on the used or clearance market, it will hold the 2-bit quant and generate at roughly 3–9 tokens/sec. That's slower than most people read, and it's the only single-box consumer path that exists at all.
The GPU + RAM offload path. The other route is a 24GB GPU (a used RTX 3090 at ~$1,070 in June 2026, or a 4090) paired with 256GB of system RAM, using llama.cpp's MoE offloading to keep active experts on the GPU and spill the rest to RAM. This works — Unsloth documents the 24GB-GPU-plus-256GB-RAM configuration explicitly for the 2-bit quant — but you're bottlenecked by system RAM bandwidth, so expect the same 3–9 tok/s range. With DDR5 and SSD prices roughly doubled in 2026 from the HBM shortage, 256GB of DDR5 is no longer cheap, and the all-in cost of a machine that does this well lands north of $13,000 once you add a multi-GPU setup to get past offload speeds.
To put 3–9 tok/s in perspective: a used RTX 3090 runs a 7B model at ~95 tok/s and a 14B model at ~52 tok/s. GLM 5.2 at 2-bit on the same class of hardware is 10–30× slower because almost all of it lives in system RAM, not VRAM. You are trading an enormous amount of speed for the ability to say it's running locally.
The math: local vs API
Let's do the comparison the playbook demands — with real numbers, not vibes.
API cost: GLM 5.2 runs ~$1.40 per million input tokens and ~$4.40 per million output, a blended ~$5.80 per million tokens. GPT-5.5, for comparable-or-worse coding results, is $5.00 input / $30.00 output — about $35 per million blended. GLM 5.2's API is roughly one-sixth the cost for better SWE-bench Pro performance.
Local cost: To run the 2-bit quant at a tolerable speed (not 3 tok/s), you're building a multi-GPU box. Twelve used RTX 3090s to hold ~241GB in VRAM is ~$12,800 in cards alone, before the platform, PSUs, and a chassis that takes them. That machine then draws well over a kilowatt under load. The single-GPU-plus-256GB-RAM build is cheaper (~$2,500–$3,500) but gives you the 3–9 tok/s offload experience.
At $5.80 per million tokens, you'd have to burn through more than 2 billion tokens before a $12k local build breaks even on the API — and that's ignoring electricity, depreciation, and the fact that the API gives you full BF16 quality while your local box gives you 82%. For coding work, where you care about correctness, that quality gap is not academic.
The one scenario that flips this: data sovereignty. If your code or data legally cannot leave your machines — and note that the GLM 5.2 API is hosted in China, which several outlets flagged as a compliance concern
Top comments (0)