On this page 17
- What 50 tok/s feels like
- Reading and writing: the two speeds
- Mac Studio M5 Ultra vs DGX Spark, RTX PRO 6000, RTX 5090, H200 and B200
- 22 models on one Mac Studio: what runs, and how fast
- llama.cpp vs MLX on the M5 Ultra
- Long context: where the Mac Studio loses ground
- Where the memory bandwidth goes
- What fits in 256GB, and what doesn’t
- Will your model fit? Napkin calculator
- Llama 70B, Qwen3-235B and other models nobody has measured yet
- Which one to buy: the Mac against the PCs
- Sharing one Mac Studio with a team
- Images, video and transcription
- Power, heat and noise
- M5 Ultra vs M3 Ultra: what the launch reviews measured
- Is the Mac Studio M5 Ultra worth it?
- Sources
We ran a 256GB M5 Ultra (the 80-core GPU) through our own benchmark harness: 22 models on llama.cpp, 16 of them again on Apple’s MLX, prompts from 1K to 64K tokens, cached follow-ups, one to eight users at once, and image and video jobs. The same model files and prompts went through a DGX Spark, an RTX PRO 6000, an RTX 5090, a Radeon AI PRO R9700, an H100, an H200, a B200 and a MacBook Pro, so every comparison is like for like. Everything below is ours unless the caption says otherwise. The launch reviews (MacStories, Alex Ziskind, NetworkChuck and Hardware Canucks, links at the end) fill the three gaps we couldn’t: the previous-generation M3 Ultra, GLM-5.3-Flash on MLX, and the Mac’s own power draw. Where we and a reviewer ran the same model on the same engine, the numbers agree within 10%.
What 50 tok/s feels like
“Tokens per second” is a number nobody has a feel for, so here’s a race. Hit start and each lane writes the same answer at its measured speed. A token is about three-quarters of an English word, so 100 tok/s is roughly 75 words a second. The dashed lane is you, reading silently at the average adult’s 238 words per minute, about 5 tokens a second. Anything above your lane is writing faster than you can read.
Then tick the box. Now every lane first has to read a 16,000-token prompt, which is what agent tools hand a model every single turn. Watch the laptop and the previous-generation lane.
Our runs, 16K-token prompt. The M3 Ultra lane is the launch reviews' short-prompt number.
With the box ticked, the M3 Ultra is still reading when the M5 Ultra has finished the whole answer, and the laptop is still reading when you’d have given up. You, meanwhile, would need about 50 minutes to read that prompt. Computers remain good at some things.
Reading and writing: the two speeds
Every “tok/s” figure online is one of two very different things, and mixing them up is how people end up disappointed.
- Reading (the industry says prefill or prompt processing) is the model crunching your input. One giant batch of matrix math, limited by raw compute. It decides how long you stare at a blank screen before the first word shows up. Spec sheets call that time to first token. We call it the wait.
- Writing (decode, token generation) is the answer coming out one token at a time. Every token drags the active weights back out of memory, so it’s limited by memory bandwidth, not compute.
The M5 Ultra improved both, but not equally. Apple put a Neural Accelerator, a dedicated matrix-math unit, in every GPU core, up to 80 of them. That’s a compute upgrade, so reading got 2.5 to 4× faster than the M3 Ultra. Memory bandwidth went from 819GB/s to 1.2TB/s on paper, or from 724 to 1,039GB/s measured, a 1.4× jump, and writing got almost exactly that much faster. It matches Apple’s own research on the base M5 chip: Neural Accelerators made time to first token 3.3 to 4× faster but writing only 1.2 to 1.3×.
Mac Studio M5 Ultra vs DGX Spark, RTX PRO 6000, RTX 5090, H200 and B200
Same files, same prompts, same llama.cpp build on all eight. Pick a model and read across.
Our runs, the same file on every machine, 4K-token prompt. Prices: US, October 2026, card or box only.
Three patterns, and the rest of this article is the detail behind them.
Where a model fits the card, the card wins. gpt-oss-120b fits the PRO 6000’s 96GB and the card writes it at 212 tok/s to the Mac’s 131, reads it twice as fast, and gets through a 32K prompt in 5.5 seconds to the Mac’s 16. The datacenter cards don’t add anything for one person: on the seven models all three hold, the B200 and the H200 land within a quarter of the PRO 6000 either way, and the PRO 6000 is the fastest of the three on the big mixture-of-experts models.
Where a model doesn’t fit the card, the Mac wins, and not by a little. DeepSeek V4 Flash and MiMo-V2.5 don’t fit in 96GB. llama.cpp still runs them with 60 to 90GB of experts parked in the PC’s RAM, and the Mac, holding the whole file in one pool, writes 1.8 and 5.3× faster and reads 5 to 11× faster. Even the H200 with 141GB spills on both and loses the reading.
The Spark is the Mac’s shape at a quarter of the bandwidth. On the big models it writes at less than half the Mac’s speed (gpt-oss-120b 57 to 131, Qwen3.5-122B 26 to 77), on dense ones under a third, and a $2,799 MacBook Pro writes the dense 27B model as fast as it does.
22 models on one Mac Studio: what runs, and how fast
Every model we ran on the M5 Ultra, writing speed at a 4K-token prompt, on both engines where both could load it. The gaps in the MLX column are models the mlx-lm release we ran couldn’t load yet.
What the ladder says:
- Active parameters set the pace, not total. The top of the chart is all mixture-of-experts models with 2 to 5B active, and gpt-oss-120b at 117B total writes three times faster than the dense 27B below it. The 300B-class models (DeepSeek V4 Flash, both MiMos) sit at 39 to 69 tok/s, the same band as the 27 to 31B dense models (40 to 54). On this machine a 300B MoE and a 30B dense model cost about the same per token.
- Flash-Next is slower than its 6B active suggests at 56 tok/s on llama.cpp. The oMLX build MacStories ran got 91 at a 4K context. Young model, young kernels; expect this one to move.
- The engines write within 15% of each other, with one exception. GLM-4.7-Flash writes 2.5× faster on MLX (85 to 34), and a DGX Spark on llama.cpp beats the Mac on llama.cpp with this one model, so the Metal path for it just isn’t fast yet. If a model’s number looks wrong on one engine, try the other before blaming the Mac.
- 8-bit costs you a third of the speed and buys no reading. Qwen3.8-27B wrote at 46.5 tok/s at 4-bit and 31.5 at 8-bit, and read the same prompt at the same speed. The file is twice as big, so each token drags twice as many bytes.
llama.cpp vs MLX on the M5 Ultra
Writing is a wash between the engines. Reading is not close.
The gap holds at every prompt size, so the wait before the first word roughly halves. With 64K tokens to read:
| Wait for the first word, 64K prompt | llama.cpp | MLX |
|---|---|---|
| gpt-oss-120b | 47 s | 19 s |
| Qwen3-Coder-30B-A3B | 88 s | 29 s |
| Qwen3.5-122B-A10B | 71 s | 31 s |
| Qwen3.8-27B | 91 s | 45 s |
| Gemma 4 31B | 135 s | 66 s |
| GLM-4.7-Flash | 184 s | 79 s |
If you run agents on a Mac, this is the number to choose your software by. Most front-ends let you pick the engine; LM Studio, for one, ships both.
Two catches. MLX gets new architectures later: the release we ran didn’t know DeepSeek V4 Flash or Qwen3.8-Flash-Next yet, while llama.cpp loaded both, and those are two of the three models you’d buy a 256GB Mac for. And MLX’s prompt cache missed on one model: NVIDIA’s Nemotron Nano 9B re-read the whole 64K prompt on every follow-up, 19 seconds a turn, where llama.cpp answered in a quarter of a second. Every other model cached fine on both.
Half of what this Mac can do is decided by which engine your app shipped with.
Long context: where the Mac Studio loses ground
Every machine writes slower as a conversation grows, because each new token has to read the context cache as well as the weights. They don’t all slow down by the same amount. Here is how much of its writing speed each machine kept when we went from a 1K-token prompt to a 64K one.
| Prompt size | NVIDIA H200 NVL | NVIDIA B200 | RTX PRO 6000 | NVIDIA DGX Spark | Mac Studio M5 Ultra |
|---|---|---|---|---|---|
| 1K tokens | 100 | 100 | 100 | 100 | 100 |
| 4K | 97 | 99 | 95 | 98 | 97 |
| 16K | 95 | 96 | 92 | 89 | 86 |
| 32K | 92 | 93 | 85 | 79 | 76 |
| 64K | 91 | 89 | 77 | 65 | 62 |
Our runs, whole model on the GPU, so only the machines that hold gpt-oss-120b appear.
The Mac is the lowest line on this chart, and MLX doesn’t rescue it: gpt-oss-120b went from 109 to 70 tok/s on MLX, a 36% loss. The datacenter cards barely notice the extra work. The next section has the reason, and it’s the same reason a B200 is no faster than a PRO 6000 for one person.
How much a model slows down is also about the model. Five we ran on the Mac:
| Our M5 Ultra, llama.cpp | Writes, 1K prompt | 16K | 64K | Wait for the first word at 64K |
|---|---|---|---|---|
| Qwen3-Coder-30B-A3B (3B active) | 157 tok/s | 114 | 57 | 88 s (29 s on MLX) |
| gpt-oss-120b (5.1B active) | 135 tok/s | 116 | 84 | 47 s (19 s on MLX) |
| MiMo-V2.5 (15B active) | 67 tok/s | 63 | 51 | 92 s |
| Qwen3.8-27B (dense) | 47 tok/s | 45 | 37 | 91 s (45 s on MLX) |
| DeepSeek V4 Flash (13B active) | 40 tok/s | 39 | 35 | 94 s |
The fastest model at 1K loses almost two thirds of its speed by 64K, and DeepSeek barely notices. Qwen3-Coder’s weights per token are about 2GB, and at 64K its context cache is around 6GB, so the cache sets the pace. DeepSeek drags 7GB of active weights through memory per token and its cache, thanks to its compressed attention design, is small next to that. Small-active models are the fastest on short prompts and the first to fade on long ones.
The wait before the first word is real: a minute and a half for most of these on llama.cpp. What saves you is prompt caching. Once the context has been read, follow-ups only process the new bit. After a 64K-token first turn on our M5 Ultra, the follow-up started writing within half a second on every model under llama.cpp. Every machine we tested does this: 0.2 to 0.4 seconds on the NVIDIA cards, 0.5 on a DGX Spark and 1.3 on the MacBook Pro. You pay for the long read once per session.
Where the memory bandwidth goes
Writing is supposed to be bandwidth-bound: a token can’t come out faster than its weights can be read. So here’s a check. Take the dense 27B model, whose 16.5GB file is read in full for every token, multiply the measured writing speed by 16.5GB, and compare with what the spec sheet promises.
The small boxes are honest. The Spark, the MacBook and the Radeon stream weights at over 80% of what their memory can do, which means nothing short of a bandwidth upgrade will make them write faster. A software update won’t save a Spark.
The big cards are the opposite. One user writing one token at a time, on llama.cpp, which is what you’d run on a desk, can’t keep 8TB/s busy: between tokens the card is waiting on kernel launches, synchronisation and the CPU, not on memory. That’s why an H200, a B200 and a PRO 6000 all write gpt-oss-120b at 180 to 210 tok/s for one person despite a 4× spread in bandwidth, and why they lose so little speed when the context cache grows: the extra bytes slot into time the card was wasting anyway.
The Mac Studio sits in the middle, using about two thirds of its paper bandwidth and three quarters of the measured figure. That’s the gap MLX kernel work keeps closing, and it’s why the numbers in this article should go up over the coming months. It’s also why the Mac pays for long context: with most of its bandwidth already spoken for, every extra gigabyte of cache per token comes straight off the writing speed.
For one person, a graphics card’s bandwidth matters until about 1.8TB/s. After that you’re paying for crowds.
What fits in 256GB, and what doesn’t
Toggle between 256GB and 512GB. The bars are each model’s weights at the stated quantization. Context, macOS and your 40 browser tabs come on top.
- Fits, with room for context
- Tight: short context, close other apps
- Doesn't fit at this quant
Weights only. Context (KV cache) comes on top, roughly 0.3 GB per 1,000 tokens for a typical big model. "~" marks sizes calculated from parameter count rather than a published download. Download sizes where published; the rest are params × bits ÷ 8 plus 10%.
The biggest file we ran was MiMo-V2.5’s 185GB, and the tight band is real
but usable. macOS doesn’t hand the GPU all of the memory: the default
limit is about 75% of RAM (raise it with sudo sysctl iogpu.wired_limit_mb=...,
which resets on reboot). With the limit at 240GB our M5 Ultra ran the 185GB
file with a 64K-token prompt beside it and wrote at 51 tok/s. The MacStories
review found the other edge: GLM-5.3-Flash at 177.6GB ran up to 64K of
context and ran out of memory at 128K, and a 6-bit Flash-Next build got
killed by macOS at 176.6GB of memory pressure. Plan for 20% headroom over the
raw model size, and leave the Mac alone while it works at the tight end.
Three things the map can’t show:
- The name can undersell the size. Flash-Next is sold as a 125B model, but it ships another 55B of parameters on top, mostly one big lookup table. The 4-bit download is 106 to 111GB, not the ~69GB the name suggests. Check the download size, not the headline.
- “Tight” means short contexts. Our 185GB MiMo run had room for a 64K context. Don’t expect 256K beside a file that size.
- Kimi K3 needs 1.56TB at native precision, and even a 1-bit quant wants 610GB. No single Mac runs it. It’s a four-Mac-cluster model, a phrase we never expected to type about home computers, and it has been done on four 512GB Mac Studios over Thunderbolt 5: an 817GB quant, writing at 14.7 tok/s.
And the 512GB model?
Same chip, same bandwidth, so it writes no faster. It just holds bigger models. It went on sale on October 28 at $22,299, which is $12,800 over the 256GB machine for the same speed, and it’s worth it only if a specific model you need breaks 256GB. If you can’t name that model, you don’t need it.
Will your model fit? Napkin calculator
For a model that’s not on the map, plug in its numbers. Model cards list total and active parameters (for a dense model they’re the same).
- Weights
- -
- Context (KV cache)
- -
- Safe budget
- -
- Writing speed, napkin estimate
- -
How the calculator works
- Weights = parameters × bits ÷ 8, plus 10% for the scales and embeddings that ride along. Against published 4-bit repo sizes that’s usually within 10%, and when it misses it runs low. “Dynamic” 2-bit and 3-bit quants come out 15-20% bigger than their name suggests.
- Context = 0.3GB per 1,000 tokens, which is what a Llama-70B-style model needs at 16-bit. Newer models with fancier attention (DeepSeek’s MLA, Qwen’s hybrid linear attention) need a lot less, so this is pessimistic.
- Safe budget: ~200GB of 256, ~440GB of 512, ~72GB of 96, for the macOS reasons above. “Tight” means you’d need to raise the GPU memory limit.
- Speed: every token streams the active weights from memory at ~85% of the M5 Ultra’s measured 1,039GB/s, plus a fixed cost per token (1-8 milliseconds for dense models, 4-12 for mixture-of-experts, which also route every token to its experts). The constants are tuned so the measured M5 Ultra models land inside the range, and all but GLM-5.3-Flash do. It says nothing about reading speed, which varies too much between models to napkin.
If it says 40-60 tok/s and you get 35, blame the napkin before your Mac.
Llama 70B, Qwen3-235B and other models nobody has measured yet
If you came here for Llama 3.3 70B, Qwen3-235B, MiniMax M2 or Qwen3-Coder-480B: sorry. As of early November, nobody has published a real M5 Ultra number for any of them, us included. What exists is M3 Ultra data, and since writing is bandwidth-bound and the measured M5-over-M3 gains land at 1.4-1.5×, that’s the multiplier. We checked the method on two models before we measured them (Nemotron 3 Nano, MiMo-V2.5) and both landed inside the predicted range. Rows marked napkin come from the calculator above.
| Model | Fits 256GB? | Measured on M3 Ultra | Our M5 Ultra estimate |
|---|---|---|---|
| Llama 3.3 70B (4-bit, dense) | Yes, easily | 9.6-15.5 tok/s | ~14-23 tok/s |
| Qwen3-235B-A22B (4-bit) | Yes (~130GB) | 20-27 tok/s | ~28-40 tok/s |
| MiniMax-M2 (4-bit) | Yes (121GB) | 40-46 tok/s | ~56-67 tok/s |
| Nemotron 3 Super (120B, 12B active) | Yes (~66GB) | not measured | ~50-85 tok/s, napkin |
| Qwen3-Coder-480B (4-bit) | No, needs ~3-bit | 25 tok/s | ~35-38 tok/s |
| DeepSeek R1 671B (4-bit) | No, 512GB only | 17-18 tok/s | ~25 tok/s |
| GLM-5.2 (4-bit) | No, 512GB only | 14-18 tok/s | ~20-26 tok/s |
| Llama 3.1 405B (4-bit, dense) | No, and you don’t want it | 2.9 tok/s | ~4 tok/s |
M3 Ultra figures: SiliconScore, the MLX benchmark thread, Dave2D and a Mac Studio owner’s log on Zhihu; short prompts unless noted. Sources at the end.
And if small models are all you run (a 14B Phi uses about 3% of this machine), a much cheaper Mac does the job.
Which one to buy: the Mac against the PCs
M5 Ultra vs RTX PRO 6000 Blackwell
This is the one the Mac has to beat, because it’s the other way to get a big model on one desk. 96GB holds anything at 4-bit up to about 85GB, plus Flash-Next, whose 29GB lookup table lives in system RAM on every machine. Here is every model we ran on both, and the line where the answer flips.
Above the line the card writes 1.5 to 1.8× faster, reads about twice as fast on the same llama.cpp (5,909 tok/s to 2,915 on gpt-oss-120b), and gets through a 64K-token prompt in 12.5 seconds to the Mac’s 47. Give the Mac MLX and the reading gap closes on mixture-of-experts models: gpt-oss-120b reads at 6,000 tok/s, level with the card, and the 64K prompt takes 19 seconds. A dense model is another story: Qwen3.8-27B reads at 2,754 on the card and 1,745 on the Mac at its best.
Below the line, the card is a spectator. With 60 to 90GB of experts in the PC’s RAM behind two memory channels, DeepSeek V4 Flash wrote at 22 tok/s to the Mac’s 39 and took 96 seconds over a 16K-token prompt to the Mac’s 22. MiMo-V2.5 wrote at 13 to the Mac’s 66, and took 157 seconds over the same prompt to the Mac’s 16. What that spill does, on every card we tried it on, and why, is its own article.
Then the bill. The card launched in 2025 at roughly $8,500. In October 2026 the cheapest listings at B&H, Newegg and Micro Center sit at $17,000-18,000. Add a PC that can feed it and you’re near $20,000, against $9,499 for the Mac. For that you get 96GB instead of 256GB. If your models fit in 96GB and you want the fastest single box, it’s the PRO 6000, at twice the price. If they don’t, or the power meter matters, it’s the Mac.
M5 Ultra vs DGX Spark
The Spark has the Mac’s shape: a small box, 128GB of unified memory, low power. It just has a quarter of the bandwidth (273GB/s), and that shows every time it writes: 57 tok/s to the Mac’s 131 on gpt-oss-120b, 14 to 47 on the dense 27B. Reading is closer, because reading is compute and the Spark has plenty: 835 tok/s to the Mac’s 1,098 on Qwen3.8-27B. And the Spark is already using 86% of its memory bandwidth, so no software update is coming that closes the writing gap.
NVIDIA’s answer to the single-Spark gap is two of them linked by a fat cable. In a head-to-head of that setup, DeepSeek V4 Flash was a tie at about 38 tok/s with both served the same way, the Mac pulled ahead to 53 once switched to MLX, and the two Sparks read a 32K prompt in 17 seconds to the Mac’s 50 (our own 32K wait on the Mac under llama.cpp: 45 seconds). Big inputs favor the Sparks, big outputs favor the Mac. Two Sparks are $13,900 as of October, after NVIDIA raised the 128GB model from $3,999 to $6,950. They read faster than the Mac and serve a team better, and need a cable, two power bricks and vLLM to do it. For one person, the single quiet box wins, and it’s cheaper.
M5 Ultra vs RTX 5090
On a model that fits in 32GB, the 5090 is the fastest thing here, and the Mac isn’t close:
| Same file, llama.cpp, 4K prompt | RTX 5090 writes | M5 Ultra writes | 5090 reads | M5 Ultra reads (MLX) |
|---|---|---|---|---|
| gpt-oss-20b (12GB) | 329 tok/s | 187 | 17,048 | 5,260 (10,484) |
| Qwen3.6-35B-A3B (20GB) | 239 | 136 | 8,261 | 4,799 (8,386) |
| Qwen3.8-27B, dense (16.5GB) | 78 | 46.5 | 3,314 | 1,098 (1,745) |
| Gemma 4 31B, dense (18GB) | 66 | 40.5 | 2,336 | 874 (1,410) |
The 5090 writes 60-75% faster and reads 1.7 to 3.2× faster on llama.cpp. MLX pulls the Mac level on reading the mixture-of-experts models and changes nothing about the writing. A wider LM Studio comparison against a Ryzen 9 9950X3D + RTX 5090 PC landed in the same place.
The catch is the 32GB. Load a 70B dense model that doesn’t fit and the 5090 falls apart: in that same comparison the M5 Ultra finished over 20× faster, and even an M5 Max MacBook Pro beat the 5090. Mixture-of-experts models are the exception: llama.cpp parks their experts in system RAM, and our 5090 still wrote gpt-oss-120b at 35 tok/s that way, but read it at 186 tok/s instead of thousands, so a 16K-token prompt took 77 seconds. The trick saves the writing, not the reading. A Mac has nothing to split, which is the whole reason the 256GB Mac exists as a product. And the price has moved against the 5090: it lists at $1,999, but the cheapest cards in stock in the US were $4,000-5,000 for most of 2026, and since NVIDIA cut off the chip supply in late October there have been none in stock at all. Half a Mac Studio for an eighth of the memory, when you can get one.
Sharing one Mac Studio with a team
Everything above is one person. Put eight on the same box and the ranking changes, because serving a crowd is compute work, and compute is what Apple silicon has least of per gigabyte per second.
The Mac got 1.9× one user’s output out of eight, and most of that by four users (65 tok/s at four, 73 at eight). The 5090 got 3×, the Spark 4×. A dense model serving several people on Apple silicon runs out of compute before it runs out of bandwidth.
Mixture-of-experts models scale better on the Mac, because each user’s token only does the math for a few billion active parameters, so the compute lasts longer: gpt-oss-120b went from 82 tok/s to 214 with eight users (2.6×, and still climbing), DeepSeek V4 Flash from 32 to 77. Even so, the PRO 6000 served eight people on gpt-oss-120b at 381 tok/s, and each of them waited 1.7 seconds for the first word to the Mac’s 3.1. A Mac Studio is a machine for one person, or a small team on an MoE model. For five to twenty people on anything, the answer is a PC, and the one we’d build is in the companion piece.
Images, video and transcription
We ran the same image and video jobs on every machine with stable-diffusion.cpp, which runs everywhere:
| Seconds per job | FLUX.2 klein 4B image | Z-Image Turbo image | LTX-2.3 video, 2-second clip |
|---|---|---|---|
| B200 | 1.6 | 4.1 | 19 |
| RTX PRO 6000, 600W | 1.9 | 4.7 | 15 |
| RTX 5090 | 1.9 | 4.6 | 20 |
| H200 NVL | 2.1 | 5.4 | 23 |
| DGX Spark | 12 | 30 | 48 |
| Mac Studio M5 Ultra | 15 | 34 | 160 |
| Radeon AI PRO R9700 | 15 | 24 | 47 |
| MacBook Pro M5 Pro | 26 | 63 | 533 |
A 5090 turns out a FLUX.2 klein image in 1.9 seconds, the PRO 6000 the same, and the B200 is barely quicker: a 4B image model doesn’t fill a big card either. The clip is where memory shows: the 5090 ran out of it decoding the frames and did them in tiles, 6 seconds against the PRO 6000’s 2, which is most of the gap between 20 and 15.
Then look at the Mac Studio row. It took 15 seconds per image, slower than a DGX Spark and only 1.7× quicker than our MacBook, which has a quarter of the GPU. The same chip made a FLUX.2 klein image in 1.8 seconds in a launch review with an MLX-based program. stable-diffusion.cpp’s Metal backend doesn’t scale up to an Ultra. The video clip is worse: 160 seconds, 102 of them spent decoding frames, where an MLX port made a 4-second clip on the same chip in 18. On a Mac, the program matters more than the chip for images and video. Check that the tool you’ll use runs on MLX before buying a Mac for it.
The same review transcribed two hours of audio with Whisper large-v3 turbo in 27 seconds, which is the kind of number that makes you go looking for old voice memos.
Power, heat and noise
We sampled each PC card’s power once a second while it answered a single user. This is what the driver reports for the card, so add the rest of the PC on top. The Mac Studio rows are the reviewers’ chip-power readings, since macOS reports no card to sample; our MacBook figure is the chip too, from macOS’s own power meter.
| One user, Qwen3.8-27B, 4K prompt | Idle | Answering | Writes | Tokens per second per watt |
|---|---|---|---|---|
| RTX 5090 | 48W | 569W | 78 tok/s | 0.14 |
| RTX PRO 6000 Max-Q | 36W | 297W | 72.5 | 0.24 |
| Radeon AI PRO R9700 | 33W | 296W | 31.6 | 0.11 |
| NVIDIA H100 PCIe | 83W | 290W | 55 | 0.19 |
| NVIDIA H200 NVL | 92W | 395W | 75.5 | 0.19 |
| NVIDIA B200 | 173W | 554W | 83 | 0.15 |
| MacBook Pro M5 Pro, chip (MLX) | 34W | 17.1 | 0.50 | |
| M5 Ultra, chip (reviewed) | 8-10W | ~45W | 54 | ~1.1 |
On gpt-oss-120b, the model these boxes are bought for, the PRO 6000 Max-Q managed 0.74 tok/s per watt, the H200 0.57 and the B200 0.41. The Max-Q is the 5090’s GB202 silicon held to 300W, and across the fifteen models both cards hold it gave up 5% of the writing speed and a fifth of the reading for less than half the power, the best trade in the table. The 5090 is a 500W-plus card whenever it has its model; the ~275W some reviews quote came from a 70B model spilling into system RAM, so the card spent most of the job waiting.
The Mac’s ~45W is chip power, not the box, so don’t read the last row as a 7× lead. Call it 3-4× once the rest of the machine is counted, and it holds up: a Mac Studio has nothing else drawing serious power, and even our MacBook’s chip, at 0.50, beats every card in the table before the rest of the PC is counted. A machine that runs agents all day pays that difference every day.
The rest of what the reviews measured on the Mac: idle around 8-10W; a 70B model in LM Studio close to 300W; everything pegged, over 400W, and 434W against 410W for two DGX Sparks with both flat out. The range follows the two speeds: writing for one person waits on memory and barely wakes the compute units, while reading and serving a crowd light up every GPU core, and Apple lists 480W as the maximum continuous power. Under full load the M5 Ultra gets clearly louder than the M3 Ultra, with the rear grille at 56°C. For single-user work it stays quiet.
M5 Ultra vs M3 Ultra: what the launch reviews measured
We didn’t have an M3 Ultra on the bench, so this section is the reviewers’.
Reading got 2.5 to 4× faster, writing about 1.5× (1.4 to 1.8 across the models measured). The big multiplier needs a prompt with some meat on it: on the same model the M5 Ultra read a 350-token chat message 1.6× faster and a 14,000-token prompt 4.2× faster, and the edge shrinks again once a conversation is already deep (64K tokens loaded, 32K more arriving: 80 seconds became 56). If you mostly chat, you’ll notice the upgrade less than the headline suggests. And these numbers move: one tester’s Flash-Next results nearly doubled overnight as people wrote kernels for the new hardware. Treat every number in this article as a floor with a date on it.
Is the Mac Studio M5 Ultra worth it?
On cost per token, no. Not even close. Running Flash-Next 24/7 at full load on a 256GB M5 Ultra works out to roughly €1.70-2.70 per million output tokens over three years, while the same model via Alibaba’s cloud API costs $0.47. And that assumes you keep it busy all day. A workstation that sits idle most of the time costs ten times as much per token.
Speed isn’t on local’s side at the very top end either. In that Kimi K3 test, the same app-building prompt went to the four-Mac cluster and to a cloud agent running frontier models. Cloud: 15 minutes. Local: 4 hours. (The cloud side sponsored that video and says so. The result is still the result.)
Against other hardware, though, the Mac’s price has aged well. Since it went on sale, the RTX PRO 6000 roughly doubled to $17,000-18,000, the DGX Spark went from $3,999 to $6,950, and a 5090 costs two to two and a half times its list price when a store has one at all. The $9,499 Mac Studio didn’t move. In November 2026 it is the cheapest way to put 256GB of fast memory under one model, and the only one of these four that holds DeepSeek V4 Flash at all.
So people buy these for other reasons:
- Privacy. Your files never leave the room.
- Always-on agents with no meter running. MacStories ran a team of DeepSeek V4 Flash agents 24/7 for 99 days this summer, on the previous-gen Mac Studio, to organize research for an iOS 27 review, for “a total cost of $0” (on top of the computer, of course). The same writer burned $20 of cloud credits on a fast hosted model “in literally 10 minutes”.
- Nobody can rate-limit you, or change or retire the model you depend on.
- And, honestly, because it’s cool.
What we’d actually buy
| You | Buy |
|---|---|
| One person, agents all day, models over 96GB | Mac Studio M5 Ultra, 256GB. Nothing else holds DeepSeek V4 Flash or MiMo-V2.5 on one desk at this price. Run it on MLX where your model is supported; it reads twice as fast. |
| One person, models under 32GB, want the fastest box | An RTX 5090 in a PC with 96GB of RAM. The RAM is for the MoE spill trick, which keeps gpt-oss-120b usable at 35 tok/s. |
| One person, models under 90GB, money no object | RTX PRO 6000 in a real PC. Fastest single box on this page, at twice the Mac’s price. |
| Curious, don’t know yet | M5 Max, 128GB. Half the Ultra’s bandwidth for a fraction of the price. Find out if you actually use local models before spending five figures. |
| A team of five to twenty | Two DGX Sparks if the models fit in 128GB each. If they don’t, the twelve-channel EPYC with one RTX PRO 6000 that we work out here. |
| A product with real traffic | Rent datacenter cards by the hour and stop reading buying guides. |
And within the Mac Studio line:
| Config | Buy it if |
|---|---|
| M5 Max, 128GB | You want models up to ~90GB. It writes at half to two-thirds of the Ultra’s speed. |
| M5 Ultra, 96GB | You want the fast reading and your models stay under ~70GB (gpt-oss-120b, Qwen3.8-27B). Flash-Next doesn’t fit. The 128GB M5 Max is often the better buy here. |
| M5 Ultra, 256GB | You run 100-300B MoE models for agent work. It’s the one we tested, and the reviewers too. |
| M5 Ultra, 512GB | A specific model you need (GLM-5.3, DeepSeek R1-class) breaks 256GB. $22,299 and up, same speed. |
Whichever you pick, expect a wait: Apple has been quoting up to 16-18 weeks on the 80-core configurations.
How we tested
- Engine: llama.cpp release b11146, the prebuilt binaries for each platform (CUDA for NVIDIA, Vulkan for the Radeon, Metal for the Macs). Whole model on the GPU unless the row says otherwise. On the Macs we also ran Apple’s MLX (mlx-lm 0.32.2 on the M5 Ultra) with mlx-community’s 4-bit builds of the same models.
- Files: the same GGUF for every machine. Qwen3.8-27B is Unsloth’s UD-Q4_K_M (16.5GB), gpt-oss-120b the MXFP4 build (63GB), Qwen3.8-Flash-Next Unsloth’s UD-Q4_K_XL (111GB), DeepSeek V4 Flash Unsloth’s UD-Q4_K_XL (155GB), MiMo-V2.5 Unsloth’s MXFP4_MOE (185GB), MiMo-V2.6-Flash the MXFP4 build (167GB). The rest are Q4_K_M-class builds from the model’s own or Unsloth’s repository.
- Prompts: a synthetic log-analysis task at 1K, 4K, 16K, 32K and 64K tokens, 256 tokens generated, fresh cache each time. Three runs per size, medians reported. A follow-up question in the same conversation measures the prompt cache. Crowds are 1, 2, 4 and 8 simultaneous users with a 1K prompt each, through the llama.cpp server.
- Power: what the GPU driver reports, sampled once a second. That’s the card, not the wall. No Spark power, because its driver only reports part of the module. On the MacBook, macOS’s own power meter for the chip. No Mac Studio power of our own; those figures are the reviewers’.
- Hardware: the PRO 6000 is the 300W Max-Q edition, except Flash-Next, DeepSeek V4 Flash, the MiMo models and the image and video jobs, which ran on the 600W Workstation Edition in a PC with a Core Ultra 9 285K and two channels of DDR5; the H200 is the 141GB NVL card; the H100 the 80GB PCIe card; the Mac Studio is the M5 Ultra with 256GB and the 80-core GPU, on macOS 27.2, with 240GB available to the GPU; the MacBook is the 16-inch M5 Pro with 48GB. Every PC’s CPU and memory is listed in the spill article.
- Fine print: our M5 Ultra numbers are from early November builds; the reviewers’ are from launch week. Both will go up as the software catches up. Our NVIDIA numbers are llama.cpp; a vLLM or TensorRT setup would make the cards faster still, especially for crowds. We’ll update this when we get a 512GB machine on the bench.
Sources
- Our own benchmarks (October-November 2026): llama.cpp on a Mac Studio M5 Ultra (256GB), a DGX Spark, an RTX PRO 6000 Blackwell in both editions, an RTX 5090, an H100, an H200, a B200, a Radeon AI PRO R9700 and a MacBook Pro M5 Pro, plus MLX on both Macs. Method in “How we tested” above.
- Prices (US, October-November 2026): the 512GB Mac Studio’s launch, NVIDIA’s DGX Spark repricing ($6,950 for 128GB, $4,999 for the new 64GB model), street-price tracking for the RTX 5090 and the Radeon AI PRO R9700, and our own check of B&H, Newegg and Micro Center listings for the RTX PRO 6000.
- MacStories: M5 Ultra Mac Studio review (Sept 21, 2026). Flash-Next and GLM-5.3-Flash on MLX, memory limits, the RTX 5090 spill, the 99-day agent team.
- Context Studios: Mac Studio M5 Ultra for local AI (Sept 24, 2026). Tabulates MacStories’ charts; configurator prices; cost-per-token math.
- Alex Ziskind: “M5 Ultra: Apple wasn’t messing around” (YouTube, Apple loaner). M5 vs M3 Ultra on gpt-oss-120b, DeepSeek V4 Flash and Qwen3.8-27B; measured bandwidth; reading speedup by prompt length; power.
- Alex Ziskind: “M5 Ultra vs 2 DGX Sparks” (YouTube). Two linked Sparks against the Mac; power draw and heat under full load.
- Alex Ziskind: “I gave local AI and the cloud the exact same job” (YouTube, sponsored by Abacus AI). Kimi K3 on four 512GB Mac Studios vs a cloud agent.
- NetworkChuck: “i got one…and it’s FAST!!!” (YouTube, Apple loaner) and his published results. Four chat models with a 32K prompt; transcription, image, video and vision workloads.
- Hardware Canucks: “Apple M5 Ultra vs The Fastest PC” (YouTube). LM Studio vs a 9950X3D + RTX 5090 PC; the 70B spill-over test; power.
- Pinggy: what fits on the 512GB M5 Ultra (Sept 1, 2026). Model sizes, wired-memory limit, quantization accuracy, M3 Ultra speeds.
- Apple Newsroom: Mac Studio with M5 Max and M5 Ultra (Aug 25, 2026), availability (Sept 22, 2026) and the tech specs (480W, M5 Max bandwidth).
- Apple Machine Learning Research: LLMs with MLX and the M5 Neural Accelerators. Why reading gains outpace writing gains.
- llama.cpp Apple Silicon benchmark thread. LLaMA 7B on the M5 Ultra and M5 Max, same build.
- MLX systematic benchmarks on M3 Ultra. Llama 405B on the M3 Ultra; how context length erodes speed.
- MacRumors: M3 Ultra runs DeepSeek R1 and SiliconScore’s M3 Ultra table (Llama 3.3 70B, Qwen3-235B). M3 Ultra comparison points.
- Zhihu: a Mac Studio owner’s running LLM benchmark log (in Chinese). M3 Ultra numbers for Nemotron, MiniMax-M2, Qwen3-235B and Qwen3-Coder-480B.
- Model cards: Qwen3.8-Flash-Next, Nemotron 3 Super, Nemotron 3 Nano, MiMo-V2.5, Ling-2.6-flash, plus OpenAI’s gpt-oss and MiniMax’s M2 cards (total and active parameters).
- For our own assumptions: OpenAI’s tokenizer rule of thumb (~0.75 words per token) and Brysbaert (2019), “How many words do we read per minute?” (238 wpm).