GLM 5.3 Flash on DGX Spark: Does It Fit, and How Fast Is It?

Quick answer: GLM 5.3 Flash's FP8 weights total roughly 328 GB, and a single NVIDIA DGX Spark has 128 GB of unified memory — so it does not fit on one unit, not even close. Two Sparks linked over ConnectX-7 give you 256 GB, which still requires 4-bit or hybrid quantization to load the model. Community reports on NVIDIA's developer forums describe 2x Sparks with quantization as the realistic entry point, with one thread reporting a peak of about 43.4 tokens/second on that configuration. Those are community measurements, not vendor benchmarks.

This is the question that follows every open-weight release with a big number attached, and it usually gets answered badly — either with "just quantize it" hand-waving or with a memory calculation that ignores KV cache. GLM 5.3 Flash makes the question sharper than usual because its parameter profile is deliberately lopsided: 320B total parameters but only 18B active per token. The compute is small. The memory is not.

The hardware specifications below come from NVIDIA's own DGX Spark product page. The GLM 5.3 Flash figures come from Z.ai's Hugging Face model card and repository. The throughput and fit reports come from threads on NVIDIA's developer forums and are labelled as community-sourced throughout — we have not run GLM 5.3 Flash on Spark hardware ourselves, and we would rather say so than imply a test we did not perform. Verified August 27, 2026.

What This Article Solves

The pain point: MoE models break the intuition people use to size hardware. "18B active parameters" sounds like something a workstation handles easily. It is not, because every one of the 320B parameters has to be resident — the router can pick any expert for any token, and you cannot page experts in on demand at usable latency.

You will leave with the exact arithmetic, what each configuration actually gets you, the community throughput numbers with their caveats attached, and an honest answer on whether this is worth doing at all.

The Arithmetic

DGX Spark, per NVIDIA's specifications:

GLM 5.3 Flash (full breakdown in our parameters and size guide):

Note the tension in those two tables. NVIDIA rates two linked Sparks for "up to 405 billion parameters," and GLM 5.3 Flash is 320B — so on a parameter-count basis it should fit. But NVIDIA's figure assumes 4-bit quantization (405B parameters at ~4 bits ≈ 200 GB, comfortably inside 256 GB with KV headroom). GLM 5.3 Flash ships natively at FP8, which is twice that. At its released precision, 328 GB does not fit in 256 GB.

So the practical answer is: two Sparks, plus quantization down from FP8. That is precisely where community discussion has landed.

What Each Configuration Gets You

The 1x row deserves emphasis because it is the configuration most people are asking about. A single Spark cannot run this model. There is no flag, no offload setting, and no framework that changes that — 328 GB of weights against 128 GB of memory is not a tuning problem.

The Throughput Numbers (Community-Reported)

One forum thread reports a peak of approximately 43.4 tokens/second on 2x DGX Spark. Treat that number carefully:

• It is community-measured, not a vendor benchmark, with no published methodology.
• It is a peak, not a sustained average — real workloads with long contexts and KV cache pressure will run below it.
• It was almost certainly measured on a quantized build, since the FP8 weights do not fit in 256 GB.

For calibration: Artificial Analysis measures GLM 5.3 Flash at 50.2 output tokens/second on hosted API endpoints running the full FP8 weights on datacentre hardware. So the community Spark figure lands in a believable range — slightly below hosted, which is what you would expect from 273 GB/s of LPDDR5x bandwidth versus HBM, partly offset by quantization reducing bytes moved per token.

This is also where the MoE architecture helps. Because only 18B parameters activate per token, memory bandwidth demand per token is far below what a 320B dense model would impose. That is why the model is even conceivable on Spark-class hardware — a 320B dense model at 273 GB/s would be unusable.

The Quantization Question Nobody Answers

Here is the part that most "can it run" write-ups leave out, and it is the one that should actually decide whether you do this.

Every published benchmark for GLM 5.3 Flash was run at full FP8 precision. The 84.3 on Terminal-Bench 2.1, the 63.4 on DeepSWE v1.1, the 57 on Artificial Analysis's Intelligence Index — all of it is the FP8 reference model on datacentre hardware.

To fit on 2x Spark you must go to roughly 4 bits. And this architecture has a specific reason to be sensitive to that: its long-context behaviour already depends on lossy compression. GLM 5.3 Flash uses IndexPool, which compresses indexer key vectors through weighted pooling, and a hybrid attention stack of KDA linear-attention plus NoPE sparse MLA layers that Z.ai reports gives roughly 3x less attention compute and a 4.4x smaller KV cache than GLM-5.3. Layering aggressive weight quantization on top of an architecture already trading precision for efficiency is compounding two lossy steps, and nobody has published the resulting quality delta.

The practical implication: if you build a 2x Spark deployment, benchmark the quantized build on your own tasks before you trust it. Do not assume the launch numbers transfer. And to know what "correct" looks like, run the same prompts against the full-precision hosted model first — open a GLM 5.3 Flash session on glm5.app and keep those outputs as your reference set.

Framework Notes

Community discussion around the launch centred on vLLM v0.28.0, with open questions about whether specific pull requests were needed for the hybrid attention stack. Z.ai officially supports SGLang, vLLM, TokenSpeed, and KTransformers, with cookbooks in the zai-org/GLM-5 repository.

Two practical warnings for anyone attempting this:

1. Pin the framework version the official cookbook names. A brand-new hybrid KDA-linear plus NoPE-sparse-MLA attention implementation is not something to run on whatever pip install vllm returns today.
2. Budget KV cache separately from weights. The 328 GB figure is weights only. A million-token context needs cache on top of that, and it is the thing that turns "the model loaded" into "the model OOMs on request three."

Is This Worth Doing?

The differentiator: most hardware guides answer "can it fit" and stop. The more useful question is whether fitting is worth it.

At list pricing of $0.15 per 1M input tokens — currently discounted to $0.075 on several providers — hosted GLM 5.3 Flash is extraordinarily cheap. Two DGX Sparks is a substantial capital purchase. The token volume needed to break even against $0.15/1M is enormous, and self-hosting adds operational cost that never appears in a per-token comparison.

Self-hosting on Spark makes sense for exactly four reasons:

• Data sovereignty — the data genuinely cannot leave your premises.
• Air-gapped deployment — no external network at inference time.
• Fine-tuning — the MIT license permits it and you own the result; note NVIDIA rates a single Spark for fine-tuning models up to 70B, so a 320B MoE is beyond that envelope.
• Reproducibility — you need the exact weights pinned forever, independent of provider decisions.

It does not make sense purely for cost at this price point, and it does not make sense if you have not yet confirmed the model is right for your task. That confirmation costs nothing: test GLM 5.3 Flash in the browser or hit the glm-5.3-flash API from your existing harness before anyone signs a hardware requisition.

Cheaper Alternatives If Local Is the Requirement

If local inference is non-negotiable and 2x Spark is out of reach, the honest recommendation is a different model. DeepSeek V4 Flash is roughly 160 GB — about half GLM 5.3 Flash's footprint — also MIT-licensed, also 1M context, and measurably faster at 119.4 output tokens/second. It scores lower on Artificial Analysis's Intelligence Index (52 vs 57) and its mainline release is text-only rather than natively multimodal.

That is the real trade at the local-inference tier: GLM 5.3 Flash is smarter and handles images and video; DeepSeek V4 Flash actually fits on hardware you might already own.

Frequently Asked Questions

Can GLM 5.3 Flash run on a single DGX Spark? No. The FP8 weights are roughly 328 GB against 128 GB of unified memory — about 2.5x too large. Even aggressive quantization leaves little room for KV cache on a single unit.

How many DGX Sparks do I need? Two, with 4-bit or hybrid quantization, is the configuration community threads converge on. NVIDIA officially supports linking two units and rates that pair for models up to 405B parameters at reduced precision.

How fast is GLM 5.3 Flash on 2x DGX Spark? One forum thread reports a peak around 43.4 tokens/second. That is community-measured, on an unspecified quantized build, with no published methodology — treat it as an order-of-magnitude signal, not a spec.

Does quantization hurt quality? Almost certainly to some degree, and the magnitude is unknown. Every published benchmark used full FP8 precision, and this architecture already relies on IndexPool compression for its long-context behaviour. Benchmark your own quantized build rather than assuming the launch numbers carry over.

Is there a smaller model that fits one Spark? DeepSeek V4 Flash at roughly 160 GB is the closest comparable open-weight model and is far more tractable on limited hardware, though still above a single 128 GB unit at full precision. Community GGUF quantizations of both models bring the footprint down further.

Sources

• NVIDIA DGX Spark product page — GB10 superchip, 128 GB unified memory, 273 GB/s bandwidth, ConnectX-7, two-unit clustering, stated parameter capacity.
• zai-org/GLM-5.3-Flash — Hugging Face — 320B-A18B parameters, native FP8, MIT license, architecture details.
• GLM-5.3-Flash weights released (Ox Alpha) — NVIDIA Developer Forums — community reports on file size, multi-Spark fit, quantization requirements, and throughput.
• zai-org/GLM-5 — GitHub — official inference recipes for SGLang, vLLM, TokenSpeed, and KTransformers.
• Artificial Analysis — GLM-5.3-Flash — hosted-endpoint throughput baseline for comparison.

Verified August 27, 2026. Throughput and memory-fit figures attributed to NVIDIA developer forum threads are community-reported and have not been independently verified; NVIDIA hardware specifications are from NVIDIA's own product documentation.