§1What is matched, and what is not
This is a comparison of two real deployments I already published in full—deep dive 35 for the RTX 5090 and deep dive 37 for the M4 Max. It is not a controlled benchmark, and pretending otherwise would be the exact sin those two notes were written against. So the alignment table comes first:
| Dimension | RTX 5090 | M4 Max | Comparable? |
|---|---|---|---|
| Target model | Qwen 3.8 27B · stock | Qwen 3.8 27B · community 4-bit derivatives | Family yes · weights no |
| Weight precision | NVFP4 (4-bit) | MLX affine 4-bit | Roughly |
| Drafter | DFlash 2 (SGLang lane) | DFlash 2 (MLX lane) | Same family |
| Runtime | vLLM / SGLang | oMLX | No |
| KV cache | FP8 | Runtime default | No |
| Bench context | 32,768 configured | 131,072 configured · ~2,150-token prompt | No |
| Concurrency | 1 | 1 | Yes |
| Decode metric | Matched-run throughput | completion ÷ (wall − TTFT), 3-run means | Approximately |
Two rows deserve emphasis. The Mac’s weights are community derivatives, and dive 37 measured that the finetuning itself costs drafter acceptance—so the Mac numbers carry a handicap the 5090’s stock checkpoint does not. And even the acceptance metrics differ by runtime: SGLang reports mean accepted length (2.95 tokens per cycle at best), oMLX reports an acceptance rate (66–82%). They describe the same mechanism and cannot be laid in one column honestly.
§2Decode: a 5× gap that speculation shrinks to 3
| Lane | RTX 5090 tok/s | M4 Max tok/s | Gap |
|---|---|---|---|
| No speculation (baseline) | 84.5 | 16.7 | 5.1× |
| Native MTP | 100.8 (+19%) | 22.9 (+24%) | 4.4× |
| DFlash 2 · greedy / card lane | 139.7 (+65%) | 35.5 (+113%) | 3.9× |
| Best drafted lane each | 139.7 | 47.2 (+183%, thinking on) | 3.0× |
Three readings:
- Native MTP pays almost identically on both machines—+19% on CUDA, +24% on Apple Silicon. The mechanism’s modest ceiling appears to be a property of the model’s draft head, not of the hardware.
- Speculation pays more where decode is slower. The 5090 gets 1.65× from DFlash 2; the Mac gets 2.1–2.8×. Similar share of drafts accepted, but each accepted draft refunds a far more expensive token on the slower machine—so the gap narrows from 5× to about 3×.
- One caution on the last row: the Mac’s 47.2 is a thinking lane. Dive 35 measured 5090 thinking configs at 240–285 decode tok/s and then showed why that number misleads—thinking rates are not answer speed. I compare drafted working lanes and leave the thinking-rate trophy row out on both sides.
§3Prefill: where the machines actually live apart
Decode gaps make the headlines; prefill decides what the machine is for. The 5090’s tuned prefill runs at 9,081 tok/s. The Mac’s logged prefill phase on the same model family works out to roughly 196 tok/s—about 46× slower. That single number redraws the whole map:
- A ~2,150-token prompt costs the Mac ~11 s before the first output token. The 5090 absorbs an 88,000-token prompt in 16.3 s and a 178,000-token prompt in 53.4 s (implied ~5,400 and ~3,300 tok/s at those depths).
- So the Mac at two thousand tokens pays roughly what the 5090 pays at a hundred thousand. Long inputs—repository dumps, document sets, deep agent transcripts—are GPU territory, not because the Mac cannot hold them (it configures 131k comfortably), but because it cannot read them at an acceptable price.
- The equalizer is the prefix cache, and it behaves identically: a warm repeat cut TTFT by 90.2% on the 5090 (2.891 s → 0.283 s on a ~16k prefix) and by 90.0% on the Mac (12.34 s → 1.23 s). On both machines, the second read of the same context is nearly free—which is why stable system prompts and append-only conversations matter more on the Mac than any other setting.
Quote one number for “how much faster is the GPU” and you are already wrong. It is ~46× reading, ~5× writing, ~3× writing with a drafter, and ~1× re-reading what is cached.
§4Memory: opposite constraints, opposite failure modes
- The 5090 is compute-rich and memory-cramped. At 32K context the serving stacks sat at 26.5–30.5 GiB of the 32 GB card. Dive 35’s hardest lessons were memory lessons: the physical KV pool—not the advertised context—sets the real ceiling, and one config change (a bigger prefill chunk) silently shrank that pool by 25,000 tokens.
- The M4 Max is memory-rich and compute-modest. Both 27B builds sit resident together in 32.6 GB of 128 GB, KV pages lazily at ~0.25 MB per token, and 131k context is configured with room to spare. Its failure mode is never “does not fit”—it is “fits, and takes a minute to read.”
That asymmetry is the honest answer to “which should I buy.” The question is not which machine is faster; it is which constraint your work keeps hitting: window size, or reading speed.
§5What runs where, in practice
| Job shape | Machine | Why |
|---|---|---|
| Long inputs: repos, document sets, agent transcripts | RTX 5090 | Prefill is the bottleneck and it is 46× ahead |
| Sustained agent duty behind an endpoint | RTX 5090 | Always-on, tunneled, tested at depth in dive 38 |
| Private second opinions on short material | M4 Max | Short prompts hide the prefill gap; decode is usable at 35–47 tok/s |
| Offline, travel, and outage fallback | M4 Max | The whole stack lives on the laptop |
| Stable-context chat that grows by appending | Either | Both prefix caches refund ~90% of the read |
| Very large windows held in memory for cheap re-reads | M4 Max | 128 GB holds what the 32 GB card must page around |
Honest limitations, so this table is not over-read: every number is concurrency 1; the weight builds differ (§1); power, thermals, noise, and cost-per-token remain unmeasured on both sides—still owed from the lab plan; and each machine’s figures are its own runtime’s best tuned configuration, so this compares two well-tuned deployments, not two chips.
The exact receipts
FIELD COMPARISON · SOURCES · 26 AUG 2026
- Machine A
- RTX 5090 32 GB · Qwen 3.8 27B NVFP4 · vLLM / SGLang · measured in deep dive 35
- Machine B
- M4 Max 128 GB · Qwen 3.8 27B 4-bit derivatives · oMLX · measured in deep dive 37
- Shared
- Same target family · same DFlash 2 drafter family · concurrency 1 · 4-bit weights
- Headline gaps
- Prefill ~46× · baseline decode 5.1× · best drafted lanes 3.0× · warm cache ~1×
- Not compared
- Thinking-lane rates (misleading per dive 35) · acceptance metrics (different definitions) · power and noise (unmeasured)
- Decision
- Keep both — route by phase, not by loyalty
The compact rule
- There is no single “Mac vs GPU” multiplier—phases have multipliers: ~46× prefill, ~5× decode, ~3× drafted, ~1× cached.
- Native MTP gains are model-bound (+19–24% on both machines); external-drafter gains are hardware-bound (1.65× vs up to 2.8×).
- Speculation is the slow machine’s best friend: each accepted draft refunds a more expensive token.
- The GPU’s constraint is memory; the Mac’s constraint is reading speed. Buy against the constraint your work actually hits.
- Prefix caching is the great equalizer—90% TTFT refunds on both—so architecture your prompts for reuse.
- Never lay two runtimes’ metrics in one column without checking their definitions first.