Benchmark report · 13 November 2026 · Singapore

Four Sparks, One Mac

GLM-5.3-Flash at maximum reasoning, from a 2K prompt to a million tokens. A tensor-parallel ring of four NVIDIA DGX Spark boxes against a single 512 GB Mac Studio M5 Ultra, run first on oMLX and then on TensorFold, on the same prompts.

4× DGX Spark ring (TensorFold) · ASUS Ascent GX10 · 4 × 128 GBMac Studio M5 Ultra (oMLX) · 512 GBMac Studio M5 Ultra (TensorFold) · 512 GB

What we found

The ring against the Mac on oMLX 13 November

1.8×Faster generation at 1M tokens71.3 vs 39.0 tok/s on code prompts, where every reply was still thinking (62.1 vs 36.4 on prose). Up to 256K the gap is 1.3–1.6×.
7.2 minFirst token at 1M tokens, against 10.0 min on the M5 Ultra on oMLXPrefilling a 1,039,949-token prompt: 434 s on the Spark ring, 601 s on the M5 Ultra.
1.8×Total throughput with 4 users at 8KSpark ring 97 tok/s across four users; the M5 Ultra on oMLX reaches 53 tok/s, up from 47 for one user.
1.31×Prefill speed at 128K2,879 vs 2,194 prompt tokens per second, as the client measures it.

The ring against the Mac on TensorFold 13 and 14 November

LevelGeneration speed for one userThe Mac on TensorFold is 11–15% ahead of the ring on prose up to 256K, 6% ahead at 512K and level at 768K and 1M. On code the ring is ahead at 7 of the 9 lengths, never by more than 7%.
11.4 minFirst token at 1M tokens, against 7.2 min on the Spark ringFrom 8K up the ring reads prompts 1.30–1.57× faster. On the same Mac, TensorFold reads 7–12% slower than oMLX, which took 10.0 min.
1.14–1.31×The ring's total throughput with 4 users at 8K97–109 tok/s across four users on the ring, 83–85 on the Mac on TensorFold. At 128K the ring delivers 1.75×, and the last of the four users waits about 1.8× as long on the Mac.
1.45–1.71×Faster generation than oMLX on the same MacTensorFold against oMLX for one user, from 2K to 1M on prose and code. With four users at 128K, oMLX still delivers more in total.

Every test block passed its checks on the first attempt: 84 of 84 on the Spark ring and 84 of 84 on the Mac on oMLX on 13 November, and 84 of 84 on the Mac on TensorFold on 14 November.

The short version

Both machines run the same open model, GLM-5.3-Flash, at its maximum reasoning setting, and both handled every prompt up to 1.04 million tokens. In the first comparison, on 13 November, the Mac ran oMLX. Against it the four-box Spark ring was faster on every single-request measure and on total throughput: 13–28% less waiting for the first token, 1.3 to 1.8 times the generation speed, and about 1.8 times the total throughput with four people sharing it. The one place the Mac on oMLX came out ahead: with several users at 8K, the first of them saw a token about half a second sooner. On prose the ring's generation speed barely moves between a 2K and a 1M-token prompt (64 → 62 tok/s), while the Mac's on oMLX falls from 47 to 36 tok/s.

On 14 November the same Mac ran the same suite on TensorFold 1.2.8, a newer, native Mac build of the engine the ring runs at version 0.6.0, with TensorFold's own 4-bit checkpoint. Generation for one user rose 1.45–1.71× over oMLX from 2K to 1M, which brings the Mac about level with the ring: on prose it is 11–15% ahead up to 256K and level at 768K and 1M, and on code it stays within 7% at every length. Prompt reading did not improve. TensorFold reads 7–12% slower than oMLX from 8K up, so the ring still reads prompts 1.30–1.57× faster than the Mac and reaches the first token at 1M in 7.2 minutes against 11.4. With four users the ring delivers 1.14–1.31× the Mac's total at 8K and 1.75× at 128K.

The Mac's case is different. It is one box that, on oMLX, holds a 1M-token prompt with about 265 GB of its 512 GB to spare, and there is no cluster to cable. The Spark ring needs four machines, four 200G cables and tensor-parallel software, and during this project one of its four boxes switched off at the 1M mark and took the ring down with it. Generation for one user is now a tie. Reading prompts and serving several users still belong to the ring. Simplicity still belongs to the Mac.

Updated 14 November 2026. This summary first said the ring was faster on every single-request measure and ended “Speed belongs to the ring.” Both statements hold for the Mac on oMLX only. On TensorFold the Mac matches the ring's generation speed for one user, so the last lines above now say which kinds of speed still belong to the ring.

Two machines, three setups

4× DGX Spark ring (TensorFold)

Measured 13 November 2026 · run h2h-max-20261113

200G200G200G200G box 1head · API box 2box 3box 4 tensor parallel ×4 · ring all-gather over ConnectX-7
Boxes4 × ASUS Ascent GX10, NVIDIA's DGX Spark design
ChipNVIDIA GB10 in each box: a 20-core Arm CPU (10 Cortex-X925 + 10 Cortex-A725) and a Blackwell GPU
Memory128 GB unified per box, 121.6 GiB usable; about 486 GiB usable across the ring
InterconnectConnectX-7, a closed ring of direct 200 Gb/s cables with no switch, RoCE v2
SoftwareUbuntu 24.04.5, kernel 7.0.0-1019-nvidia, NVIDIA driver 580.178.04
EngineTensorFold 0.6.0 in Docker (NGC PyTorch 26.07), tensor parallel across all four boxes, with the recipe's 12 engine patches
WeightsGLM-5.3-Flash with routed experts in EXL3 at 4 bits per weight; the dense layers are re-quantized to 4-bit at load. 164 GiB on disk
Speculative decodingDFlash2 block-diffusion draft model (up to 7 drafted tokens) plus prompt-lookup copy drafts; the model's own MTP head is not used
KV cacheFP8 (e4m3), one shared pool of 5,834,752 tokens
Context window1,048,576 tokens per request
Requests at once8
GPU clocksLocked at 2,200 MHz

Mac Studio M5 Ultra (oMLX)

Measured 13 November 2026 · run h2h-max-20261113

M5 Ultra512 GB unified memory one box · no interconnect · Metal via MLX
BoxMac Studio (Mac17,15)
ChipApple M5 Ultra: 36 CPU cores, 80-core GPU
Memory512 GB unified
InterconnectNone needed
SoftwaremacOS 27.2, MLX 0.32.2
EngineoMLX 0.7.0rc1, built from source (main a4048eef plus the recipe's patch and PR #4086)
WeightsGLM-5.3-Flash oQ4e: mixed precision, mostly 4-bit with some layers at 5–8 bits, plus a grafted 4-bit MTP layer. 173 GiB on disk
Speculative decodingThe model's own MTP head at a fixed depth of 2, plus prompt-lookup drafts
KV cacheNot quantized; paged in 4,096-token blocks with a 50 GB SSD prefix tier
Context window1,048,576 tokens native; tested to 1,039,967
Requests at once8
GPU clocksStock. The recipe's GPU memory-limit setting is not applied (it needs an administrator password)

Mac Studio M5 Ultra (TensorFold)

Measured 14 November 2026 · run tf-max-20261114

M5 Ultra512 GB unified memory same box · no interconnect · TensorFold on Metal
BoxThe same Mac Studio (Mac17,15)
ChipApple M5 Ultra: 36 CPU cores, 80-core GPU
Memory512 GB unified
InterconnectNone needed
EngineTensorFold 1.2.8, the native macOS build (prebuilt release binary, Metal)
WeightsTensorFold/GLM-5.3-Flash-MLX-4bit-MTP at d2b17f52: uniform 4-bit (affine, groups of 64) with the MTP head. 169 GiB on disk (181.7 GB)
Speculative decodingThe model's own MTP head, drafting only when TensorFold prices a draft as worth its time, plus copy drafts: about one drafted token for every three passes on prose prompts up to 128K
KV cacheOne pool for the whole million-token window, reserved at load and shared by the four request slots
Context window1,048,576 tokens
Requests at once4
Prompt cache4 GiB
Memory in use219–222 GB throughout the run, by the Mac's own sensors (binary gigabytes)
GPU clocksStock. The GPU memory-limit setting iogpu.wired_limit_mb was 491,520 for the run

What is the same, and what is not

  • Same in all three setups: the model (GLM-5.3-Flash), the chat template's reasoning switch, the prompt text and lengths, the sampling settings, the output caps, the repeats, the checks, and the measuring script, which runs on each machine's own localhost.
  • Same on 13 November only: the ring and the Mac on oMLX ran under one run id, so they received every prompt byte for byte, with the same seeds, and both had 8 request slots. The script derives each prompt's 16-character session tag and each request's seed from the run id, so the 14 November run's tags and seeds differ; the text after the tag is the same. TensorFold on the Mac was served with 4 request slots (--parallel 4). Its measuring script is the same apart from an entry for the new server and a fallback that reads TensorFold's Mac request counter under its different name (tensorfold:requests_started_total).
  • Different by design: the quantization (EXL3 4-bit experts with 4-bit dense layers on the ring, 164 GiB; oQ4e on the Mac on oMLX, 4-bit experts with the layers every token runs at 5–8 bits, 173 GiB; a uniform 4-bit MLX checkpoint on the Mac on TensorFold, 169 GiB), the speculative decoder (a separate DFlash2 draft model on the ring; the model's own MTP head on both Mac setups, drafting on every pass on oMLX and only when a draft is priced as worth its time on TensorFold), the KV cache (FP8 on the ring, unquantized and paged on oMLX, one pool reserved at load on TensorFold) and the engines (TensorFold 0.6.0 on CUDA, oMLX on MLX and Metal, TensorFold 1.2.8 on Metal). Each setup runs the community recipe it was set up with, so this compares complete setups, not chips.
  • Tuning: the ring's configuration is the product of weeks of tuning, including a recipe pull request and two local commits that are not yet public. The Mac on oMLX runs a published recipe that was set up the day before the test. Before the run, the Mac matched its recipe's published prefill figures and its 62 tok/s prose decode control. The Mac on TensorFold runs a community recipe written for TensorFold 1.2.5 on a 256 GB Mac, set up on the morning of its run.
  • Draft acceptance: the ring's drafts were accepted 56–65% of the time on prose and 67–70% on code. On the Mac, at prompts up to 128K, oMLX kept 46–48% of its drafts on prose and 59–63% on code, and TensorFold kept 54–55% on prose and 63–65% on code. Each engine drafts a different number of tokens per pass, so the three shares are not like for like. Corrected 14 November 2026: this item said the Mac's server does not report its MTP acceptance, so it was not recorded. oMLX's log does record its MTP cycles, and the oMLX figures above come from it.
  • Clocks and sampling: the ring's GPUs are locked at 2,200 MHz, below their maximum boost clock, so if anything the lock works against the ring. The Mac runs at stock clocks in both setups; its GPU memory-limit setting was left unset on 13 November and set to 491,520 on 14 November. Temperature 1.0 and top-p 0.95 are the model's own default settings.

Software and sources

Every version and commit below was read from the machines themselves.

Spark ring

Mac Studio M5 Ultra on oMLX

Mac Studio M5 Ultra on TensorFold

All three

How the test worked

Each request is a single user message: a unique 16-character session tag first (so no machine can reuse a cached prefix from an earlier request), then an exact number of tokens from one of two fixed texts, then an instruction. The same script ran on both machines against 127.0.0.1, streaming every reply and timing it on the client side, with each server's own timings recorded alongside.

Prose textEight public-domain novels from Project Gutenberg, Dracula first, 1,628,133 tokens
Code textCPython 3.13.1 standard library (Lib/, 319 files), without tests, encodings or generated tables, 1,204,882 tokens
Prose instruction“Instruction: using the books above only as inspiration for tone, write a long, original short story of at least 3,000 words, with new characters, a new setting and plenty of dialogue. Write it as one continuous piece of prose from the first sentence: no title, no headings, no summary, no commentary before or after, and do not stop early.”
Code instruction“Instruction: using the Python code above only as a style reference, write one long, complete, original Python module of at least 800 lines: an in-memory key-value database with transactions, TTL expiry, snapshots to disk, a small query language and a command-line interface, with type hints, docstrings and a unittest test suite at the end. Output only the code, in a single ```python block, with no explanation before or after, and do not stop early.”
Prompt lengths2K, 8K, 32K, 64K, 128K, 256K, 512K, 768K and 1.04M tokens, cut at exact token boundaries with the model's own tokenizer
Samplingtemperature 1.0, top-p 0.95, top-k off, min-p 0, a fixed seed per test, reasoning effort max
Output cap8,192 tokens per reply (single requests), 2,048 (concurrency)
Repeats2 per prompt length and text; concurrency 1–4 users at 8K, 32K and 128K, 2 repeats each
Time to first tokenrequest sent → first streamed token (thinking or answer)
Prefill speedprompt tokens ÷ time to first token
Generation speed(tokens − 1) ÷ time from the first to the last token

Every block was checked before it counted. The server had to report no running or queued requests before it started; a watcher polled the server's own request count during the block; afterwards its request counter had to have moved by exactly our requests. A reply also had to show no more than 64 cached prompt tokens (the shared template header), the expected prompt size, a clean end of stream and no repetition loop. Each block got up to three attempts, each with a fresh session tag. In the 13 November run no block needed a retry: 168 blocks, 168 valid.

Other scheduled jobs that use the ring were paused for the run, and the counters confirm nothing else touched either machine while a block ran.

The 14 November run (tf-max-20261114) repeated the max-reasoning suite on the Mac on TensorFold with the same prompt texts and lengths, sampling settings, output caps, repeats and checks, from 10:54:37 to 16:21:21 SGT. It had 84 blocks, 84 valid, and no retries, and its counters again confirm that nothing else touched the Mac while a block ran. It ran under its own run id, so its session tags and seeds differ from the 13 November run's, and TensorFold served 4 requests at once, enough for the four-user tests to run as one batch. The measuring script is the same apart from an entry for the new server and a fallback that reads TensorFold's Mac request counter under that build's name.

Results

Three series: the ring and the Mac on oMLX from 13 November, and the same Mac on TensorFold from 14 November. The 13 November figures were not re-measured.

Time to first tokenSeconds from sending the request to the first streamed token, prose prompts, both axes logarithmic. On all three setups, code prompts land within 1% from 32K up and within about 5% below that. The two Mac lines run close: from 8K up the first token arrives 7–14% later on TensorFold than on oMLX.
Show the numbers
Prefill speedPrompt tokens processed per second before the first token, prose prompts. The ring peaks at 2,900 tok/s on the 64K prompt, the Mac on oMLX at 2,255 tok/s and the Mac on TensorFold at 2,078 tok/s, both on the 32K prompt. All three slow down on the longest prompts.
Show the numbers
Generation speedTokens per second while the reply streams, at max reasoning, so most of it is thinking. On prose the ring holds 59–64 tok/s at every length, while the Mac on oMLX slows from 47 to 36 and the Mac on TensorFold from 71 to 62. On code all three slow as the prompt grows: the ring from 85 to 71 (−16%), the Mac on oMLX from 52 to 39 (−24%) and the Mac on TensorFold from 80 to 67 (−17%). Code is the cleaner comparison: at 768K and 1M, 7 of the 8 prose replies on the ring and the Mac on oMLX finished thinking and started writing the story, against 1 of 4 on the Mac on TensorFold, so those prose points mix thinking and story in different shares, while every code reply was still thinking.
Prose prompts
Code prompts
Show the numbers
Several people at once: total throughputAll users' output tokens divided by the time from the first token any user sees to the last one, prose prompts, 2,048-token replies, all users sending at the same moment. That window includes the time later users wait for their prompts to prefill, which is why long prompts pull the total down. Counting only the stretch when all four users decode at once, at 8K the ring sustains 112 and 128 tok/s, the Mac on TensorFold 116 and 115, and the Mac on oMLX 61 and 68 (prose, then code). With two to four users on the Mac, TensorFold delivers the higher total at 8K and 32K, and oMLX at 128K.
Show the numbers
Several people at once: how long the last user waitsSeconds until the last of the users sees a first token. TensorFold, on the ring and on the Mac, reads the queued prompts one at a time and starts each user as soon as their own prompt is read. oMLX reads all the waiting prompts as one batch, so users 2, 3 and 4 get their first token at the same moment. Either way the last user waits for every prompt to be read, and the ring's faster prefill shortens that wait. Corrected 14 November 2026: this caption said both machines prefill the queued prompts one after another, so waits add up. That is wrong for oMLX, whose per-user first-token times show it reads the waiting prompts as one batch.
Low versus max reasoningMedian generation speed over the 2K–256K prompts, from an overnight run at low reasoning (1,024-token replies) and this run at max (8,192). Code slows at max effort and prose barely moves, probably because thinking text is harder for the draft models to predict than code. The ring was rebooted between the two runs, after which it benchmarked 2–6% faster, so its code slowdown is if anything understated. The Mac on TensorFold has no low-reasoning run, so this chart shows the ring and the Mac on oMLX only.
Low reasoningMax reasoning4× DGX Spark ring (TensorFold)Mac Studio M5 Ultra (oMLX)
Show the numbers

Added 14 November 2026, 23:36 SGT · run tf-max-20261114

The Mac on TensorFold

TensorFold, the engine the ring runs, also has a native Mac build. On 14 November the same Mac Studio M5 Ultra ran the whole max-reasoning suite again on TensorFold 1.2.8, and all 84 blocks were valid on the first attempt. This section compares that run with the 13 November figures for the ring and for the Mac on oMLX, which were not re-measured.

Scorecard: the Mac on TensorFold against the ring

MeasureSpark ringMac on TensorFoldAhead
Generation, prose, 2K–256K60.7–63.8 tok/s68.2–70.6 tok/sMac, by 11–15%
Generation, prose, 512K59.5 tok/s63.2 tok/sMac, by 6%
Generation, prose, 768K / 1M62.4 / 62.1 tok/s62.3 / 62.0 tok/sLevel
Generation, code, 2K–1M71.3–84.7 tok/s66.7–83.0 tok/sRing at 7 of the 9 lengths, never by more than 7%
First token, 128K prose prompt45.5 s65.5 sRing; the Mac takes 1.44× as long
First token, 1M prose prompt7.2 min11.4 minRing; the Mac takes 1.57× as long
Total, 4 users at 8K97 / 109 tok/s85 / 83 tok/sRing, 1.14× / 1.31×
Total, 4 users at 32K66 / 72 tok/s46 / 46 tok/sRing, 1.41× / 1.57×
Total, 4 users at 128K28 / 30 tok/s16 / 17 tok/sRing, 1.75× / 1.75×
Last user's first token, 4 users at 32K72 / 73 s130 / 132 sRing; the Mac's last user waits 1.80× / 1.80× as long

One user unless stated, with 8,192-token replies; several users get 2,048-token replies. Where two figures share a cell, they are prose / code. Ring figures from 13 November, Mac figures from 14 November.

Generating the answer

Generation is where the Mac on oMLX lost, and it is where TensorFold changes the result. At a 2K prompt the Mac on TensorFold writes 71 tok/s on prose and 80 on code, against oMLX's 47 and 52. Its lead over oMLX is 1.45–1.56× up to 256K and 1.6–1.7× at 768K and 1M, because it slows less as the prompt grows: from 2K to 1M on code it gives up 17% of its speed, close to the ring's 16%, while oMLX gives up 24%. At 1M it still writes 67 tok/s on code, against 39 on oMLX and 71 on the ring.

Against the ring the Mac is now about level for one user: 11–15% ahead on prose up to 256K, 6% ahead at 512K and level at 768K and 1M, and within 7% on code at every length, behind at seven of the nine. At 768K and 1M most of TensorFold's prose replies were still thinking while most of the ring's and oMLX's had moved on to the story, so code is the safer comparison at the long end. At maximum reasoning this is the speed a user feels: an 8,192-token reply to a 2K prompt takes about two minutes on TensorFold, as on the ring, and about three on oMLX.

Reading the prompt

Before it can answer, the model has to read the whole prompt, and here TensorFold is the slower Mac engine. From 8K to 128K it reads 2,000–2,080 prompt tokens per second where oMLX reads 2,190–2,260, and at 1M it reads 1,524 against 1,731. From 8K up its first token arrives 7–14% later than oMLX's: after 65 seconds instead of 60 at 128K, and after 11.4 minutes instead of 10.0 at 1M. The ring reads 1.30–1.57× faster than the Mac on TensorFold over the same range and reaches its first token at 1M in 7.2 minutes. On 13 November this report called prompt reading the part of the gap set by the hardware. A second engine on the same Mac landed within 12% of the first, which fits.

What a user waits for is the whole reply. For an 8,192-token reply TensorFold finishes sooner than oMLX at every length up to 512K: on prose, 2.0 minutes against 3.0 at 2K, 3.1 against 3.9 at 128K and 7.1 against 7.8 at 512K. Past that the slower read nearly cancels the faster write. On code TensorFold finishes 3% sooner at 768K and less than 1% sooner at 1M, where both take about 13.5 minutes.

Sharing the machine

With four users sending 8K prompts at once, the Mac on TensorFold delivered 83–85 tok/s in total against oMLX's 53–59, and the ring 97–109. At 32K it was 46 against 36–38, with the ring at 66–72. Once all four are generating on 8K prompts, the Mac on TensorFold produces 115–116 tok/s combined, against the ring's 112 on prose and 128 on code and oMLX's 61–68. Long prompts reverse the order on the Mac: with four 128K prompts TensorFold's total fell to 16–17 tok/s, below oMLX's 20–21 and the ring's 28–30, and the batch took 9.2–9.5 minutes against 7.6–8.0 on oMLX.

The reason is how each engine works through the queue. oMLX reads all the waiting prompts as one batch, so the second, third and fourth users see their first token at the same moment. TensorFold, on the ring and on the Mac, reads them one at a time and starts each user as soon as their own prompt is read.

Four users, prose promptsUser 1User 2User 3User 4
32K, Mac on oMLX15 s118 s119 s119 s
32K, Mac on TensorFold16 s63 s100 s130 s
128K, Mac on oMLX61 s302 s303 s304 s
128K, Mac on TensorFold66 s257 s405 s521 s

Seconds from the moment all four requests are sent until each user's first token, users in the order their first token arrived, mean of two repeats.

At 32K one at a time is the kinder policy: on the Mac on TensorFold the second and third users start after 63 and 100 seconds instead of 118 and 119, and only the fourth waits longer, 130 seconds against 119. At 128K it backfires on the Mac. On both engines the users already generating share the machine with the prompts still being read. oMLX keeps its first user moving at 17–18 tok/s, so that answer finishes well before the reading does, and each waiting prompt takes about 80 seconds to read instead of 60. On TensorFold each read takes 1.7 to 2.9 times as long as it would alone, and the first user's answer crawls at 4.5 to 6.5 tok/s. The fourth user waits 8.5–8.7 minutes for a first token on TensorFold, 5 minutes on oMLX and 4.8–4.9 minutes on the ring.

Why it is faster on the same Mac

Both Mac engines speed up generation by drafting: a small head guesses the next tokens, the full model checks the guesses in one pass, and every guess that holds is a token that needs no pass of its own. Both draft with GLM-5.3-Flash's own MTP head, so the draft model is not what separates them. They bet differently. oMLX drafts two tokens ahead on every pass. TensorFold, by its own release notes, prices each draft against the time it would add, and on prose it drafts about one token for every three passes. Per token, those two strategies come out close. What separates the engines is how many bytes of weights a token costs and how fast those bytes move.

Both checkpoints keep the routed experts, 171.2 GB in all, at 4 bits, and a token uses 8 of the 288 experts in each expert layer, about 4.8 GB. They differ in the layers every token runs in full: the attention, the shared experts, the output head, and the smaller routers and dense feed-forward layers. TensorFold's checkpoint stores those at 4 bits, 4.8 GB in all; oMLX's oQ4e keeps them at 5 to 8 bits, a choice aimed at answer quality, and they come to 8.6 GB. The ring makes the same trade as TensorFold's checkpoint: its dense layers are re-quantized to 4 bits at load. So one token reads 9.6 GB of weights on TensorFold and 13.3 GB on oMLX before any drafting, and with each engine's drafting counted, oMLX reads 15–28% more weight bytes per token at prompts up to 128K. TensorFold also moves those bytes faster, at 650–720 GB per second against oMLX's 540–560.

Per token and per pass Mac on oMLX Mac on TensorFold
Weights one token reads, before drafting13.3 GB9.6 GB
… in the layers every token runs8.6 GB at 5–8 bits4.8 GB at 4 bits
… in routed experts (8 of 288 per layer)4.8 GB at 4 bits4.8 GB at 4 bits
Drafted tokens, prose2 on every passAbout 1 per 3 passes
Drafts kept, prose46–48%54–55%
Time per pass, prose41–42 ms17 ms
Tokens per pass, prose1.9–2.01.2
Weights moved per second, prose and code540–560 GB/s650–720 GB/s

Weight sizes come from the checkpoint file headers, in decimal gigabytes, counting 8 of 288 routed experts per token. Pass and draft counts come from each server's own log, at prompts from 2K to 128K, and a pass's time is the client's generation time over that count. oMLX's occasional prompt-lookup copy drafts, in under 0.5% of its passes at these lengths, are not counted; TensorFold's log counts its MTP and copy drafts together. Bytes per second are a pass's weight bytes over its time.

By our estimate, at prompts up to 128K about half of the gain comes from the lighter checkpoint and the rest from the engine. Treat that split as an estimate. It assumes pass time follows the weight bytes read and ignores the prompt cache, which is why it stops at 128K. It also means this was not a pure engine test, and what TensorFold's checkpoint gives up in answer quality by dropping those bits was not measured.

Memory and power

TensorFold reserves its whole million-token cache when it loads, so the Mac's memory in use sat at 219–222 GB from the first test to the last. oMLX idles leaner, at 203 GB, and grows with the prompt, to 245 GB at 1M and 395 GB with four 128K users, close to the 400 GB ceiling set for it. By the Mac's own sensors, TensorFold drew between the same power as oMLX and a fifth more while generating, which works out to 22–40% less energy per token. The Mac's hottest reading was 85.6 °C, against 83 °C on oMLX. Power here is the Mac's own sensor reading, not a wall meter, and memory is in binary gigabytes, the unit the Mac's 512 GB is counted in.

How long it took

The suite is 84 test blocks and 156 requests, which read 18.3 million prompt tokens and write about 540,000. TensorFold ran it unattended in 5 h 27 min, from 10:54:37 to 16:21:21 SGT, against 5 h 58 min for oMLX on 13 November. The checkpoint loaded in 28 seconds.

Max reasoning thinks for a long time

At maximum effort GLM-5.3-Flash reasons at length before it writes. Most replies spent the whole 8,192-token budget thinking, around 32,000 characters of reasoning, and never reached the answer. In the 13 November runs only 12 of the 72 single-request replies began their answer inside the cap (12 prose). On the 1M story prompts both machines did reach the story, after 7.5 minutes on the ring and 10.2 on the Mac on oMLX. On 14 November, 3 of the 36 replies from the Mac on TensorFold began their answer, all on prose. For the rest, this report measures how fast each machine produces tokens; the time until a finished answer is beyond its 8,192-token cap. With replies this long, generation speed matters more than prefill for most prompts: 8,192 tokens take about 128 seconds on the ring, 176 on the Mac on oMLX and 116 on the Mac on TensorFold at a 2K prompt.

Where the Mac loses time

This section analyses the 13 November comparison, the ring against the Mac on oMLX, and its figures stand.

Updated 14 November 2026. This section was written before the TensorFold run, and two of its open points are now settled. First, the bytes per pass, which it could only infer, have been read from the checkpoint file headers. Both Mac checkpoints keep the routed experts (171.2 GB) at 4 bits, but oQ4e keeps the layers every token runs, mainly the attention, the shared experts and the output head, at 5–8 bits: 8.6 GB, against 4.8 GB at 4 bits in TensorFold's checkpoint. One token reads 13.3 GB of weights on oMLX and 9.6 GB on TensorFold before any drafting. Second, the rerun shows what software could change. A different engine and checkpoint on the same Mac closed the generation gap to the ring, while prompt reading stayed within 12% of oMLX's, which fits the view below that prefill is the hardware-limited part. The TensorFold columns in the table come from TensorFold's own log. More in Why it is faster on the same Mac.

Single-user generation is limited mostly by memory bandwidth, and on paper the Mac has more of it: 1.23 TB/s against 4 × 273 GB/s = 1.09 TB/s for the ring, with no network between its parts. Its oQ4e weights are heavier, though: about 4.5 bits per expert weight once MLX's scales are counted, against EXL3's 4.0, plus hundreds of tensors kept at 5–8 bits.

Each machine's generation speed splits into two factors: the time one pass through the model takes, and the tokens each pass yields once the drafts are checked. The ring's server reports its passes (rounds) directly; oMLX logs its MTP cycles per request, and TensorFold's Mac build its rounds. Multiplying the two ratios reproduces every measured speed ratio.

Ring Mac on oMLX Mac on TensorFold
Promptms per passtokens per passms per passtokens per passms per passtokens per pass
prose 2K29.41.8741.21.9216.81.19
prose 128K29.71.8342.41.9617.01.16
prose 1M34.32.1358.12.0826.51.64
code 2K35.22.9942.12.1720.81.66
code 128K34.52.7742.92.2520.91.61
code 1M38.72.7658.52.2929.21.95

Most of that looks like software: the drafter, the cache format, the kernels and the batching can all change in oMLX and MLX. Bytes per pass were not measured, so that is an inference. (Since measured; see the update above.) Prefill is limited by compute, where four Blackwell GPUs bring more than one M5 Ultra; from 32K up the Mac on oMLX still reads prompts at 72–79% of the ring's pace.

After the main runs, three settings were tried on the Mac on oMLX. Each test used 2,048-token replies on prose and code at 2K and 128K, two repeats each, and the last two also ran a 512K code prompt. None of them made the Mac faster.

MTP drafts three tokens ahead instead of two (mtp_fixed_depth 3)Generation 5–12% slower.
The recipe's GPU memory-limit setting (iogpu.wired_limit_mb 491,520)No change beyond run-to-run noise: generation −1.5% to +2.8% and time to first token within 3%, from 2K to 512K.
oMLX's compressed KV cache (TurboQuant, 8-bit and 4-bit)Not available for this model. oMLX logs that TurboQuant does not support GLM-5.3-Flash's combined latent and indexer cache, keeps the native cache and runs at baseline speed.

Because the compressed cache never switched on, its runs count as extra repeats: the 8-bit run used the default memory limit and the 4-bit run the recipe's, and the comparisons above include them.

Keeping the ring honest

The ring's own benchmark ran before each session. After four weeks of uptime it was within 3% of its Nov 10 baseline. After the reboot that followed the overnight failure it benchmarked faster than before it: prefill by 2–3%, single-user decode by 3% and four- and eight-user decode by 6%. That is one before-and-after pair, so treat it as a hint, not a law of uptime. The max-reasoning comparison on this page ran on the freshly rebooted ring.

GPU readings during the run stayed normal: the ring's clocks held at the 2,200 MHz lock (2,174–2,185 MHz on average while busy) with a hottest reading of 89 °C, and the Mac peaked at 83 °C. Power was not measured at the wall, so this report makes no efficiency claim between the ring and the Mac. Updated 14 November 2026: the section on the Mac on TensorFold compares energy per token between the two Mac engines, by the Mac's own sensors (Memory and power).

What broke along the way

The first attempt ran overnight at low reasoning. It went wrong in instructive ways.

  1. Both runs start. On the ring, a scheduled agent job that had not been paused keeps sending requests from about 02:45 until the failure. The request counters catch it, and every 768K attempt and all but one at 512K are thrown out.
  2. Eleven minutes into a 1,040,000-token prefill, box 3 switches off. Both of its cables go dark at the same instant and the ring aborts.
  3. All four boxes are powered back on. Box 3 was found switched off, and its logs end without a crash, a temperature spike or a memory warning; its readings were normal right up to the end (78–87 °C, at most 61 W of GPU power). The cause is unknown.
  4. All four boxes now reboot themselves 10 seconds after a kernel crash, arm a 30-second hardware watchdog and stream their kernel log to another ring box over the cables. None of that helps against a power cut, but a freeze would now cost minutes instead of hours.
  5. This max-reasoning run starts on the Mac; the ring follows at 10:09, once the paused job's last session has finished. The ring completes four 1M-token prompts and every other test without a single rejected block.

The overnight run also exposed a bug in the measuring script. oMLX reports queued requests inside its active count, and the script added the two, so it flagged the Mac's own queued requests as outside traffic. Overnight it flagged most of the Mac's multi-user blocks this way. The request counters were clean, the rule is fixed, and this run uses the fixed version.

Read these before quoting a number