Mac Studio LLM Benchmarks:M5 Max 36 GB vs 64 GB, Measured
The buying questions are harder than the spec sheet: which memory configuration holds the models you actually run, whether the Ultra's 256 or 512 GB is worth stepping up to, and where a Mac loses to a DGX Spark, a Strix Halo box or a 192 GB Gorgon Halo machine. Every answer below comes out of our own measurement files, and the gaps in our data are marked as gaps.

Why Most Mac Studio LLM Advice Does Not Hold Up
Search for Mac Studio local LLM advice and you find two kinds of content. The first quotes vendor marketing: memory bandwidth figures and maximum parameter counts, none of it measured on a running system. The second measures one engine, usually with a 40-token prompt and a fixed context window, and generalizes from it. Neither answers the question a buyer has: which configuration do I order, and what will it actually do for my team?
We run a private AI fleet for compliance-heavy clients, so we had to answer that question with measurements rather than forum posts. In November 2026 we benchmarked two Mac Studio machines with the M5 Max chip, one with 36 GB of memory and a 32-core GPU and one with 64 GB and a 40-core GPU, using the same model (Qwen3.8 27B, Apache 2.0, in 4-bit), the same two prompts, the same 300-token generation, temperature 0, thinking off, every run twice. We measured four engines and combinations: llama.cpp with GGUF weights, MLX through mlx-lm, TensorFold, and TensorFold with the DFlash2 speculative drafter. The result files and the exact commands are stored in our benchmark repository, and the rules behind the harness are on our benchmark methodology page.
Three findings surprised us, and they reorganize the buying advice. First, the memory bandwidth numbers on the spec sheet translate almost exactly into decode speed: the 64 GB box is 31 percent faster in plain generation than the 36 GB box, and the rated bandwidth ratio is 1.33. Second, the engine matters more than most guides admit: MLX beats llama.cpp by 13 to 14 percent at generation before any tuning, and the TensorFold-plus-DFlash2 combination multiplies plain decoding by 4.2 to 4.5 times on code. Third, speculative decoding is where the headline numbers live: the same model, on the same hardware, moves from 30 tok/s to 133 tok/s on the 64 GB machine purely by adding a small drafter model and an engine that verifies its drafts.
One more thing to get out of the way: a fine-tune of the same model does not change speed. NousResearch's Arete 27B is a supervised fine-tune of Qwen3.8 27B with the same architecture, and it runs at the same speed on the same hardware. If a blog post claims a fine-tune made a Mac dramatically faster, the fine-tune was not the variable. We have not measured its drafter acceptance rates, and we say so rather than quote a number we do not have.
The Two M5 Max Configurations We Measured
| Machine | Chip | GPU cores | Memory | Rated memory bandwidth |
|---|---|---|---|---|
| Studio A (36 GB) | M5 Max | 32-core | 36 GB | about 460 GB/s (Apple specs) |
| Studio B (64 GB) | M5 Max | 40-core | 64 GB | 614 GB/s (Apple specs) |
Both machines ran macOS 27.2, low power mode off, no other model loaded, and the same versions of every engine. The two prompts were a Python coding task (parse an Apache access log line into a dict with a docstring and pytest unit tests) and a plain-language prose explanation for a small business owner. Generation ran 300 tokens at temperature 0 with thinking disabled, and each configuration ran twice; the runs agreed within 1 token per second.
Why these settings matter: a thinking-mode model burns a large share of its output tokens on invisible reasoning before the visible answer, so thinking-off numbers are the only honest comparison between engines. And because the drafter acceptance rate depends on how predictable the text is, we report code and prose separately everywhere. Averages hide exactly the thing a buyer needs to see.
Qwen3.8 27B on M5 Max: Four Engines, One Winner
| Engine and setup | 36 GB, code | 36 GB, prose | 64 GB, code | 64 GB, prose |
|---|---|---|---|---|
| llama.cpp 0.9.0, GGUF Q4_K_M, plain | 23.1 | 23.1 | 29.7 | 29.7 |
| mlx-lm 0.32.2, MLX 4-bit, plain | 26.2 | 26.2 | 33.8 | 33.8 |
| TensorFold 1.2.7, MLX 4-bit, plain | 22.4 | 22.4 | 30.7 | 30.7 |
| llama.cpp + DFlash2 drafter (Q8_0) | 58.7 | 37.0 | 72.6 | 45.6 |
| TensorFold + DFlash2 drafter | 97.2 | 64.8 | 133.3 | 87.4 |
Tokens per second of generation, 300 tokens, temperature 0, thinking off, two runs per cell agreeing within 1 tok/s. Time to first token was under 0.1 second on every configured setup.
Read the table in three steps. First, the plain-decoding rows: llama.cpp and TensorFold are within a few percent of each other, and MLX is 13 to 14 percent faster than llama.cpp at generation. If you run models on a Mac with defaults only, switching your GGUF stack to MLX is the cheapest speed you will ever buy. Second, adding the DFlash2 drafter under llama.cpp gives 2.5 times on code and 1.6 times on prose. Third, the drafter under TensorFold multiplies plain decoding by 4.2 to 4.5 times on code and 2.8 to 2.9 times on prose, 1.7 to 1.9 times the same drafter under llama.cpp. The engine is not a detail; it is a 30 percent difference stacked on top of a 2.5 times difference.
Why does the drafter help code so much more than prose? Speculative decoding proposes several tokens with a small model and verifies them in one pass with the large model. Code is repetitive and predictable, so the drafter's proposals get accepted about half the time on our coding prompt (231 of 464 draft tokens accepted). Prose accepted only about a quarter (191 of 748). Acceptance was identical on both machines at temperature 0, which is expected: acceptance is a property of the model pair, and speed scales from it.
Verified output was identical to plain output: in our runs the drafted and undrafted replies were the same length to the character. This matters for anyone worried that speculative decoding trades accuracy for speed. It does not, by construction: the large model rejects any proposal it would not have made itself.
The DFlash2 drafter is Apache 2.0, so commercial use is fine. That matters in this space: the drafter used in the best-known DGX Spark recipe for GLM-5.3-Flash was originally licensed non-commercial, though it was relicensed Apache 2.0 earlier this month, which we verified in the repository history before relying on it.
Several users at once: only the 64 GB box can
| Streams (64 GB, --parallel N) | Same coding prompt, total tok/s | Mixed prompts, total tok/s | Mixed, per stream |
|---|---|---|---|
| 1 | 129 | 129 | 129 |
| 2 | 197 | 137 | 68 |
| 4 | 273 | 202 | 51 |
| 8 | 353 | 256 | 32 |
TensorFold with --parallel N, 300 tokens per stream. On the same coding prompt, aggregate throughput keeps climbing with stream count; mixed workloads climb more slowly because prose drafts are accepted less often. The 36 GB machine refused a second parallel stream at an 8,192-token context: the engine keeps an 8 GB safety margin beside the weights, and 36 GB minus a 16 GB model minus 8 GB does not leave room for two context windows. That is not a flaw; it is arithmetic, and it is the single clearest difference between the two configurations.
We also tried the tuning knobs the engine exposes and found they changed nothing worth reporting. None of the tuning knobs moved the needle: a wider verification window landed within 3 percent of the default, so did toggling context copies, and so did a 4-bit drafter, all on the 64 GB machine. The two-Mac speed-up mode does not apply to this model. Defaults stay.
What Happens at 120,000 Tokens of Context
Short-prompt benchmarks flatter every machine, so our fleet methodology also runs a prefill ladder at 1k, 4k, 16k, 32k, 64k and 120,000 tokens, plus a needle-in-a-haystack gate, on the same machine class. On the M5 Max 40-core machine, running the Nemotron 3.5 Lightning model in MLX 4-bit through TensorFold, prefill ran from about 5,400 tok/s at short prompts down to about 3,460 tok/s at 120,000 tokens, which is roughly 35 seconds to read a 120k-token prompt before the first answer token. At 32,768 tokens the full read took 6.7 seconds. Single-user decode in the steady-state phase measured 241 tok/s, and the machine held 375 tok/s aggregate at 4 users.
The 32-core 36 GB machine ran the same battery at about 80 percent of those numbers (195 tok/s single user in steady state, 3,100 to 3,600 tok/s prefill across the ladder, 8.9 seconds to read a 32k prompt). Both passed the needle gates at 16k and 120k.
Compare that with the community claim that a Mac needs 44 to 50 seconds to read a 32k codebase while a DGX Spark does it in about 17 seconds. In our measurements, on the same engine and the same checkpoint class, the 64 GB Mac read 32k tokens in 6.7 seconds and 120k tokens in about 35 seconds. The circulating numbers come from different runtimes with different prompt-caching behavior; ours come from the same harness on both platforms. The honest summary: a current M5 Max does not read prompts 3 times slower than a GB10, but the Spark still holds a prefill edge, and its CUDA stack is the reason. Details in our best local LLM per machine comparison.
One gap we state openly: we have not yet measured the DFlash2 drafter's benefit at long context. The engine's own published figures show the gain shrinking as context grows, and our speculative runs above were short-prompt. Until we run that ladder, treat 133 tok/s as a short-context figure.
What 36 GB and 64 GB Actually Hold
| Model class | Rough weight size at 4-bit | 36 GB | 64 GB |
|---|---|---|---|
| Small models (9 to 14B) | 5 to 8 GB | Fits with long context to spare | Fits with very long context |
| Mid-size dense (27 to 31B) | 15 to 17 GB | Fits, single stream at 8k | Fits, 8 streams at 8k |
| Large MoE (gpt-oss-120b at 4-bit) | about 60 GB | Does not fit | Does not fit |
| Frontier open models (GLM 5.3 Flash class, ~190 to 200 GB at 4-bit) | 190+ GB | Does not fit | Does not fit |
The table is arithmetic, not aspiration. A 27B model in 4-bit weighs about 16 GB; the 36 GB machine also needs room for the KV cache (the running context), the operating system and an engine safety margin, which is why TensorFold refuses a second parallel stream there. The 64 GB machine fits the same model eight times over in concurrency terms and could hold the 31B Gemma 4 with a drafter.
Two models we measured deserve a mention. gpt-oss-120b does not fit either configuration at 4-bit and we did not measure it on either machine; anything you read about running it on a 36 or 64 GB Mac involves heavy offloading or lower precision we have not validated. Qwen3.8 27B is the sweet spot for both, and its ecosystem is the reason: an Apache 2.0 DFlash2 drafter, native TensorFold support, plus published GGUF and MLX weights. Our Qwen3.8 27B model page has the full recipe.
Memory bandwidth is the second half of the memory story, and it is why the two configurations are not the same machine with more headroom. Every generated token reads the whole model from memory, so decode speed tracks bandwidth. We measured 22.9 tok/s plain decode on the 36 GB box, which is about 380 GB/s of effective bandwidth, 83 percent of the rated 460; the 64 GB box reached 30.0 tok/s, about 496 GB/s effective, 81 percent of 614. Buy the higher-memory configuration and you are also buying the wider-bus GPU, which is where a third of the speed comes from before concurrency enters.
Should You Buy the M5 Ultra With 256 GB or 512 GB?
This is the most-searched Mac question in this category, and we answer it honestly: we have not measured an Ultra, and we will not quote speed numbers we did not produce. What we can do is put the memory arithmetic and our cluster measurements side by side, because the Ultra decision is really a decision between one very large quiet box and a small cluster.
What the memory holds. At 4-bit, the GLM 5.3 Flash class of frontier open models weighs roughly 190 to 200 GB, so a 256 GB Ultra holds one in a single silent desktop, and 512 GB holds the largest open weight releases with long context on top. Neither M5 Max configuration can load those models at all. If your question is "can I run the biggest open models locally on one desk, quietly, on macOS," the Ultra is the only Mac that answers yes, and Apple rates the M5 Ultra at 1.2 TB/s of memory bandwidth (Apple specs).
What our measurements say about the alternative. Our four-unit GB10 pod (DGX Spark and MSI units on a switched 200G fabric) ran DeepSeek V4.1 Flash at 74 tok/s single user, 214 tok/s aggregate at 8 users, and 328 tok/s at 16 users, with prefill around 6,000 to 7,000 tok/s on the Pico engine. The same class of GLM 5.3 Flash work ran at 47.8 tok/s on two GB10 units and 77.2 tok/s on four, reaching 173 tok/s aggregate at 8 users on the published Mia recipe (their repo, third-party numbers). Those clusters also run the CUDA stack (vLLM, SGLang, NVFP4) that most agent frameworks expect.
So the honest verdict splits by use. If the work is one person chatting with a very large model, or a macOS-first desk where silence and low power matter, and there is no appetite for cabling and administering a cluster, the Ultra is the machine that fits. If the work is agents reading long prompts, or serving several people at a per-user speed floor, our cluster data favors the GB10 pod (two or four units) over the Ultra shape: it reads prompts several times faster, and its concurrency scales in a way one unified-memory box does not. We have not measured an Ultra, so we cannot put a number on what it gives up in prefill or concurrency; we can only say the question is real and the cluster alternative is measured.
If 256 GB Ultra money is on the table, it is also worth pricing the 192 GB AMD option we measured: a Ryzen AI Max+ PRO 495 box that runs the GLM 5.3 Flash class at 2-bit quality in 28.7 tok/s (code) and 22.9 tok/s (prose) single user. That is a separate page with its own trade-offs, but it is the closest single-box rival to the Ultra's memory class and it is worth reading before you order.
Mac Studio vs DGX Spark vs Strix Halo vs Gorgon Halo
| Platform | Memory | Best measured strength | Main weakness we measured |
|---|---|---|---|
| Mac Studio M5 Max 64 GB | 64 GB, 614 GB/s | 133 tok/s single-user code on a 27B (best per-box single-user speed in our data) | Single box saturates by 8 streams; prefill behind discrete GPUs |
| Mac Studio M5 Max 36 GB | 36 GB, ~460 GB/s | 97 tok/s single-user code, silent, one cable | Single stream at 8k context; no concurrency |
| DGX Spark (GB10), one unit | 128 GB, 273 GB/s | CUDA stack, big-model headroom, 128 GB at 273 GB/s (NVIDIA specs) | Lower single-user decode than the Mac on the same model class |
| GB10 pod, 2 or 4 units | 256 to 512 GB pooled | Concurrency (214 to 328 tok/s at 8 to 16 users), prefill 6,000 to 7,000 tok/s | Cluster to cable, manage and power |
| Strix Halo (Ryzen AI Max+ PRO 395) | 128 GB | General-purpose x86 machine that also runs LLMs; 128 GB in a laptop or mini PC | Slower prefill; ROCm and Vulkan engine maturity |
| Gorgon Halo (Ryzen AI Max+ PRO 495) | 192 GB | Fits models that do not fit 128 GB (GLM 5.3 Flash at 2-bit, 28.7 tok/s) | Prefill around 2,200 tok/s at best; no GLM path on the native TensorFold AMD backend |
The prefill caveat deserves its own paragraph because it is the honest weak spot of every unified-memory box, Mac included. Our 192 GB Gorgon Halo box peaked at about 2,200 tok/s reading prompts. A discrete GPU or a GB10 reads prompts several times faster. Decode (answering) is where unified memory shines and where the Mac's bandwidth makes it the fastest per-box answer in our data for one user. If your workload is agents reading long codebases or documents before answering, the reading step is the bottleneck, and that is where the Mac loses to a cluster despite winning the decode race. Our head-to-head blog post has the full cross-platform tables, and the platform tier list condenses them.
On the AMD side, engine maturity is a real cost, not a hand-wave. On our 192 GB box we measured the halogen engine at 89.5 tok/s single-stream on Qwen3.8 Flash Next against 51 tok/s for TensorFold's HIP build, and both are behind the same box's potential; two-node USB4 recipes are the only GLM and DeepSeek paths on AMD today. On the Mac, by contrast, TensorFold's Metal engine is the fastest thing we measured on day one with a brew install. Software ecosystems differ by platform more than spec sheets suggest.
When to Choose This Over a DGX Spark (and When Not)
You want the best single-user local assistant on one silent desk: our 64 GB machine answered a 27B model at 133 tok/s on code with the TensorFold and DFlash2 recipe, faster than anything else per box in our measurements. You prefer macOS and its tooling with zero Linux administration, and your team is one person, or a few people taking turns. You value one power plug, no fabric, no cluster management, and a machine that is also your daily workstation.
Single user, models up to the 27 to 31B class, short to medium contexts. It delivered 97 tok/s on code with the same recipe. Do not buy it for concurrency: it refused a second parallel stream at 8k context, and that is arithmetic, not tuning.
You need frontier-class open models (the 190 to 200 GB class at 4-bit) on one quiet macOS box and accept single-user patterns. We have not measured an Ultra; the memory arithmetic above is what we can state, and the cluster alternative below is what we measured.
Your agents read long prompts all day (prefill is the unified-memory weakness), your team needs a per-user speed floor at 8 or 16 concurrent users (a 2 to 4 unit GB10 pod measured 214 to 328 tok/s aggregate there), or your software stack assumes CUDA plus the vLLM and SGLang tooling with NVFP4. Those are Spark strengths, and our DGX Spark deep dive covers them.
You need 128 or 192 GB inside a general-purpose x86 machine that also does everything else a PC does. The Halo boxes trade prefill speed and engine maturity for memory size and form factor. Our Strix Halo and Gorgon Halo pages carry those measurements.
One more honest note on the fine-tune question buyers ask: NousResearch's Arete 27B is a supervised fine-tune of Qwen3.8 27B with the same architecture, so it runs at the same speed with the same drafter, but we have not tested its drafter acceptance and do not claim a number for it (model card). Speed claims about fine-tunes being faster on Macs are not supported by anything we measured.
The Exact Recipe Behind the 133 tok/s Number
Install TensorFold with Homebrew, pull the Apache 2.0 model and drafter (16 GB and 3.6 GB), then serve with the drafter attached:
tensorfold serve TensorFold/Qwen3.8-27B-MLX-4bit --drafter z-lab/Qwen3.8-27B-DFlash2 --context 8192 --no-thinking
The server speaks the OpenAI chat API on localhost. On the 64 GB machine add --parallel 4 or 8 for several users. Models land in the Hugging Face cache, which we exclude from Time Machine because they can always be downloaded again. The GGUF alternative is the unsloth Q4_K_M file under llama.cpp with the DFlash2 drafter, which measured 72.6 tok/s on the 64 GB machine, about 45 percent behind the TensorFold path (GGUF repo, MLX 4-bit repo, drafter repo, TensorFold engine).
Each benchmark script and prompt text is stored in our benchmark repository, together with the raw result files behind this page. The same two prompts also run unchanged on the DGX Spark, on the AMD Halo boxes and on the Mac mini, which is what makes the cross-platform pages comparable. The full rules are on the methodology page.
Mac Studio Local LLM Questions, Answered From Our Measurements
Is a Mac Studio M5 Max good for running local LLMs?
For one user it is the fastest desktop we measured: 133 tok/s on a 27B model on code with the TensorFold and DFlash2 recipe on the 64 GB configuration, and 97 tok/s on the 36 GB one. It is a poor fit for many simultaneous users or long-prompt agent work, where clusters of GB10 units measured higher aggregate throughput and faster prompt reading.
What is the difference between the 36 GB and 64 GB Mac Studio for LLMs?
Three differences we measured. The 64 GB machine is 31 percent faster at plain decode (30.0 vs 22.9 tok/s) because its memory bandwidth is 614 GB/s against about 460. It serves up to 8 parallel streams (353 tok/s total on the same coding prompt) where the 36 GB machine is limited to one stream at an 8,192-token context. And it has headroom for larger models such as Gemma 4 31B that the 36 GB box fits only without concurrency.
Which engine is fastest on a Mac: llama.cpp, MLX or TensorFold?
TensorFold with the DFlash2 drafter, by a wide margin: 133 tok/s against 29.7 for plain llama.cpp on the same model and machine. Without a drafter, MLX beat llama.cpp by 13 to 14 percent at generation. The drafter under llama.cpp reached 72.6 tok/s, so part of the gap is the engine and part is how TensorFold verifies draft tokens.
Is speculative decoding safe to use for real work?
Yes. The drafter proposes tokens and the main model verifies them; anything it would not have generated is rejected, so output is identical. In our runs the drafted and undrafted replies matched to the character at temperature 0. The only cost is that the gain depends on how predictable the text is: about half of draft tokens were accepted on code, about a quarter on prose.
Do I need the M5 Ultra 256 GB or 512 GB to run the biggest open models?
To run the largest open models on one quiet macOS box, yes: the GLM 5.3 Flash class weighs roughly 190 to 200 GB at 4-bit, which only the Ultra configurations hold. But our measurements favor a two- or four-unit GB10 cluster for agent and team workloads: our four-unit pod measured 214 to 328 tok/s aggregate at 8 to 16 users and prefill around 6,000 to 7,000 tok/s. We have not measured an Ultra and quote no speed numbers for it.
Mac Studio or DGX Spark for a local coding assistant?
For one developer, the Mac Studio M5 Max 64 GB is faster per box in our data on both decode and, on the same engine and checkpoint class, prompt reading at 32k (6.7 seconds on our measured run). For an agent that reads very large codebases, or a team sharing one box, the Spark wins on prefill plus concurrency and carries the CUDA tooling most agent frameworks assume.
Can a Mac Studio run gpt-oss-120b?
Not in the 36 GB or 64 GB M5 Max configurations; at 4-bit the weights are around 60 GB and neither machine has the memory. We did not measure it on either machine and will not quote numbers we did not produce. The 256 GB and 512 GB Ultra configurations have the memory for it, but we have not measured those either.
How fast does a Mac Studio read a long prompt?
On our prefill ladder with Nemotron 3.5 Lightning in MLX 4-bit through TensorFold, the 64 GB machine read prompts at about 5,400 tok/s at short lengths, about 4,880 tok/s at 32k (6.7 seconds for the full read) and about 3,460 tok/s at 120,000 tokens (roughly 35 seconds). The 36 GB machine ran about 80 percent of those figures.
Does the DFlash2 drafter license allow commercial use?
Yes. The Qwen3.8 27B DFlash2 drafter is Apache 2.0. Note that the drafter in the well-known GLM-5.3-Flash DGX Spark recipe was originally non-commercial; we verified it was relicensed Apache 2.0 in early November 2026, before relying on it, and we recommend you check the license revision of any drafter before production use.
What about a Mac mini or a laptop instead of a Studio?
A Mac mini with an M4 chip and 16 GB runs small models only; we measured a set of them on exactly that machine and published the results in our Mac mini guide. The Studio's value is memory bandwidth and memory size, and those are what the mini gives up. For the small-model, always-on role, though, the mini is a sensible, quiet box.
More Hardware Deep Dives From Our Benchmark Lab
Every page below uses the same prompts, the same quality gate and the same methodology, so the numbers line up across machines.
Sources and Data Files
- Apple Mac Studio technical specifications (memory bandwidth and configuration figures, vendor)
- NVIDIA DGX Spark hardware documentation (128 GB, 273 GB/s, vendor)
- TensorFold engine, GitHub (Metal and HIP engines, recipes)
- TensorFold Qwen3.8 27B MLX 4-bit model
- z-lab Qwen3.8 27B DFlash2 drafter (Apache 2.0)
- unsloth Qwen3.8 27B GGUF
- NousResearch Arete-27B model card
- Mia AI Lab GLM-5.3-Flash DGX Sparks recipe (third-party cluster numbers)
- Pico DGX DS4 engine, GitHub (our 4-unit cluster figures from our own trial)
- AMD Ryzen AI Halo announcement (192 GB unified memory, vendor)
Our own measured result files (llama-bench tables, TensorFold timing logs plus prefill ladders, together with steady-state concurrency summaries for both M5 Max machines) are archived in the Petronella Technology Group, Inc. benchmark repository with the scripts that produced them, measured November 11 and 17, 2026.
Mac Studio LLM benchmarks measured by Petronella Technology Group, Inc. on machines we own. Third-party figures are labeled and linked. We did not measure an M5 Ultra and quote no speed numbers for it.