Tencent DSpine on a Mac: 1.26 GB Qwen3.8-27B Drafter, No Metal Result Yet

Tencent's DSpine drafter for Qwen3.8-27B does not have a documented Mac path today. DSpine is Tencent's family of speculative-decoding drafters, small models that propose tokens for one specific larger target. Tencent's official runtime for the 27B drafter is SGLang 0.5.22 in BF16 with FlashAttention 3, a CUDA setup. Upstream llama.cpp has an open draft pull request but nothing merged. The community GGUF drafter (a 1.26 GB Q4_K_M file) loads only in a third-party fork whose published build command targets CUDA. Every speed figure for this pairing was measured on NVIDIA or AMD hardware, none on Apple Silicon.

No speed test was run for this article. Every figure comes from the page linked beside it, and the byte sums are our arithmetic on the Hub API records listed under Sources.

Does DSpine for Qwen3.8-27B run on a Mac today?

Not in a way anyone has published. The status of each runtime below was read from the linked page on November 9, 2026:

The two MLX rows matter most for Mac owners. mlx-lm is Apple's MLX-based Python package for running language models on Apple Silicon. Tencent does ship an Apple Silicon path, via mlx-lm and an SGLang-MLX plugin. Its guide covers the Qwen3-8B draft and says only full-attention Qwen3 targets are supported.

Qwen3.8-27B is a hybrid model with recurrent layers, per the GGUF repository README. The dspine_mlx folder has had no commit since the Qwen3-8B one on October 26 (commit history). So the MLX path does not cover the 27B drafter as documented.

The verdict is "fork only", and it can flip. If PR #31941 merges, or mlx-lm adds DSpine, re-check before acting on this article. For the target model itself, the Qwen3.8-27B page ranks it by machine.

What did Tencent actually publish?

A draft model, not a new target. A drafter (or draft model) is a small network that guesses the next several tokens so the large target model can check them in one pass. tencent/Qwen3.8-27B-DSpine-b16 was created on November 7, 2026 under Apache 2.0. The model card describes a five-layer draft model for Qwen3.8-27B, block size 16, with an 8,192-token sliding window. The model.safetensors file is 4,051,831,880 bytes (Hub API record).

Two facts keep this in proportion:

• It is not the start of a family. The Qwen3-8B draft, tencent/Qwen3-8B-DSpine-b16, was created on October 16, 2026 (Hub API record). The 27B one is the second checkpoint.
• Adoption is early. On November 9 the 27B repository showed 134 likes and 1,464 downloads, two days after creation.

The method is described in arXiv 2609.36173. Its abstract covers Qwen3-4B and Qwen3-8B. It reports a seven-benchmark mean acceptance length of 4.82 against DFlash's 3.77 on Qwen3-8B at temperature zero. Acceptance length is the average number of drafted tokens the target model accepts per verification step, so a higher value means fewer slow target passes per generated token. The 27B results live only on the model card.

Where does the 1.26 GB GGUF come from?

Not from Tencent. GGUF is the single-file model format used by llama.cpp, and Q4_K_M is a 4-bit-class quantization of it. On November 8, a community account (aj9o9) published GGUF conversions of the drafter. The file list from the Hub API record:

• Q4_K_M: 1,257,892,896 bytes, the file the README recommends
• Q8_0: 2,201,447,456 bytes
• BF16: 4,061,850,656 bytes

The README is blunt: stock llama.cpp "refuses to load these files" and a dspine branch of a fork is required. The build command it gives is cmake -B build -DGGML_CUDA=ON. It does not show a Metal build. I did not build or run the fork, so whether it works on Metal is unverified.

The upstream story is moving. A search of ggml-org/llama.cpp for DSpine returned a single relevant result on November 9: PR #31941, "spec : add DSpine draft support", from a different contributor, still open and marked draft. Its description reports parity and lossless checks on CUDA, HIP and Vulkan. It does not mention Metal.

Do the published speed numbers apply to a Mac?

No. Three sets of numbers exist, and none was measured on a Mac with the 27B drafter.

Tencent's claims (vendor, SGLang 0.5.22, FlashAttention 3, concurrency 8). On the model card, HumanEval acceptance length at temperature zero is 5.71 for DSpine against 4.87 for the DFlash2 drafter. On the WorkBuddy Code agent benchmark at low reasoning effort, throughput goes from 253.35 tok/s without speculation to 590.27 tok/s with DFlash2 and 686.23 tok/s with DSpine. The card does not name the GPU. That is aggregate throughput over 8 concurrent requests, not the single-stream speed a Mac user sees.

Third-party CUDA (single RTX 3090, Q4_K_M target). The GGUF README claims about 125 tok/s on code and math, about 90 tok/s on mixed chat tasks, and about 28 tok/s without speculative decoding, or 3.2x overall. That is a community CUDA result on a 24 GB desktop GPU. It says nothing about unified-memory Macs.

The pull request's own caution. In the PR description, a DGX Spark with a Q8_0 target measured 29.5 tok/s with DSpine against 29.6 tok/s with DFlash2. The author notes the 27B draft step costs more and offsets its higher acceptance length. So even on CUDA the 27B gain over DFlash2 is not uniform. The GGUF README also says prose and chat are the weak cases and that code, math and tool calls gain the most.

The only Apple Silicon measurement is Tencent's, and it is for Qwen3-8B. In the dspine_mlx guide, an M4 Pro with 64 GB running Qwen3-8B in bf16 averages 38.52 tok/s with DSpine against 15.37 tok/s for plain mlx-lm at temperature zero. That is a vendor claim on a different model, and it needs about 21 GB of unified memory for the target alone.

What do the numbers say once you line them up?

We divided each published pair of figures to see how much of the gain survives a change of setup. The ratios below are our arithmetic on the figures above, rounded to two decimals, and none of them is a Mac result.

Our reading: the large gain comes from having any speculative drafter at all, and the margin of DSpine over a competing drafter is small and setup-dependent. The 2.71x and 2.51x rows compare against no speculation, while the 1.16x and 1.00x rows compare against another drafter. On a Mac, the first question is therefore whether a drafter runs on Metal at all, and the second is which drafter wins. The acceptance-length ratio on the model card (5.71 over 4.87, about 1.17x) matches the 1.16x throughput ratio on the same card, which fits the card's claim but does not transfer to other hardware.

Would the 27B pair fit in your Mac's memory?

On paper, from 24 GB up. Target plus drafter, both Q4_K_M-class: the unsloth Qwen3.8-27B-UD-Q4_K_M.gguf is 16,464,440,224 bytes (Hub API record), the community drafter is 1,257,892,896 bytes, and the sum is 17,722,333,120 bytes. Unified memory is the single RAM pool that a Mac's CPU and GPU share, so the model weights, macOS and the KV cache all draw from the same figure.

Mac memory sizes are binary (a "16 GB" Mac holds 17,179,869,184 bytes). The sums here are weights only, before macOS, the KV cache and the recurrent-state copies the target keeps while it verifies a draft. The GGUF README puts that overhead at about 150 MB per copy, or about 1.2 GB more for a 16-token DSpine block than for an 8-token DFlash2 block.

The Q8_0 figure uses unsloth's Qwen3.8-27B-Q8_0.gguf at 29,047,086,048 bytes. On a 32 GB Mac that pairing leaves 4,054,759,424 bytes, too little to trust. The "Metal result" column is "none" on every row because no one has published one. For how much memory a model really needs once context is added, see how much VRAM LLMs need, the LLM memory calculator and the RAM guide for local LLMs.

Which Mac should you plan around?

This decision aid maps each memory tier to a next step. The tier verdicts follow the table above, and the linked posts rank models for those machines.

Memory is not what blocks a Mac owner here. The pair fits on a 32 GB machine, and the missing piece is a runtime that executes the DSpine layers on Metal.

What should a Mac owner do instead?

• Run Qwen3.8-27B without the DSpine drafter. The target already runs well on 24 GB and up, see run Qwen3.8-27B locally.
• Check which framework your speculative decoding runs on. Speculative decoding is a method where a small draft model proposes tokens and the large target model verifies them, keeping the target's output while cutting the number of slow passes. The pattern in speculative decoding on a Mac is that the same technique can lose on llama.cpp's Metal backend and win on MLX. A drafter that works on CUDA is no evidence for either.
• Treat vendor speedups as claims until a Metal run exists. JetBrains' Mellum 2.1 MTP head is the recent example of a card promising more than the one published Metal measurement showed.
• If you want DSpine on Apple Silicon now, the supported combination is Qwen3-8B with Tencent's dspine_mlx, not the 27B model.
• Watch the pull request. When PR #31941 merges and someone posts an M-series run with the settings and software version, this article should be rewritten.

FAQ

Can I run the Qwen3.8-27B DSpine drafter in Ollama or LM Studio?

I found no sign of support in either, but I did not verify it. The drafter needs a runtime that implements the DSpine layers. Upstream llama.cpp has not merged one, and Ollama and LM Studio build on engines that follow upstream.

Does the GGUF drafter work with Metal on an M-series Mac?

Unknown. The fork's README shows only a CUDA build command, and the open llama.cpp PR lists CUDA, HIP and Vulkan checks. Nobody has published a Metal run.

Is the 125 tok/s figure what I will get on a Mac?

No. It is a third-party claim from one RTX 3090 with a Q4_K_M target, on code and math prompts. Apple Silicon has different memory bandwidth and a different backend. The draft-verify step that makes DSpine fast on CUDA may cost more on Metal.

How much memory does the Qwen3.8-27B plus DSpine pair need?

The two Q4-class files add up to 17,722,333,120 bytes before KV cache and recurrent state, so a 16 GB Mac is out and a 24 GB Mac is tight. The table above shows the arithmetic per tier.

Sources

• Tencent Qwen3.8-27B-DSpine-b16 model card
• Hub API record, Tencent 27B drafter
• Hub API record, Tencent Qwen3-8B drafter
• Community GGUF repository README (aj9o9)
• Hub API record, community GGUF drafters
• Hub API record, unsloth Qwen3.8-27B GGUF
• llama.cpp pull request 31941, DSpine draft support
• GitHub issue search, ggml-org/llama.cpp for DSpine
• Tencent DSpine MLX guide
• arXiv 2609.36173, Draft in Parallel, Condition Through Depth