by Chris DePuy / August 20, 2026
A week ago the Qwen3.8-27B decode race on a single NVIDIA DGX Spark was a contest between DSpark and MTP. This week the leading recipes on the same hardware have switched to a different engine: DFlash2, the block-diffusion speculative decoder that first shipped with DeepSeek, is now beating DSpark head-to-head for Qwen3.8-27B on the GB10, and in the same week it has been ported to Apple Silicon via MLX. The result is worth treating as a confirmation that speculative decoding — not quantization — is becoming the portable performance layer for local inference.
The Target: Qwen3.8-27B on One GB10
Qwen3.8-27B is the 27-billion-parameter dense multimodal sibling in the Alibaba family released with native 262,144-token context, and it ships with multi-token prediction trained in. On the GB10’s SM121 GPU it is a memory-bandwidth-bound workload, which makes it an ideal candidate for a drafter that emits a block of draft tokens in a single pass rather than one token at a time. DFlash2 is that block-diffusion drafter; the DFlash2 draft model for Qwen3.8-27B is published on Hugging Face with launch recipes for both SGLang and vLLM.
DFlash2 vs. DSpark: The Head-to-Head on the GB10
The consistent finding across independent, reproducible recipes is that DFlash2 edges out the prior DSpark K7 baseline on the single Spark. A r0b0tlab recipe measured DFlash2 (block ~8) at 28.38 tok/s dedicated single-stream median versus DSpark K7 at 20.97 tok/s, and 23.47 tok/s versus 16.96 tok/s on a 1024-in/256-out ladder, a 35–38% gain. A Weschera recipe reports a 34.08 tok/s dedicated single-stream median with 49.5/53.7 mean/median on real prompts, scaling past 120 tok/s at higher concurrency on one Spark. SGLang’s MiaAI-Lab recipe shows DFlash2 winning short-chat conditions outright (29–67 tok/s streamed versus roughly 22) while tying DSpark block-7 on code. One contributor summarized it on their run as DFlash2 having overtaken the prior DSpark result on the same box, with the short-prompt median up about 32% and math roughly 70% better.
The pattern holds across the NVIDIA developer-forum threads that have consolidated the recipes, where real-world testing lands in the 40–50 tok/s range — a step above the day-one SGLang baseline. As with the earlier DSpark findings, the gains are lossless: the full model still verifies every drafted token, so output quality is unchanged.
Quality Holds While Speed Rises
The speed does not come at a quality cost. The r0b0tlab recipe documents quality parity on GSM8K, HumanEval, and IFEval between the DFlash2 and DSpark paths, and the Weschera DFlash2 recipe records 67/80 GSM8K, 39/40 HumanEval, and 38/40 IFEval on the accelerated configuration. That is the same quality profile the model produces without speculation, which is the expected property of a verifier-based decoder and the reason these drafter swaps are safe to adopt in production.
The Bigger Move: DFlash2 Leaves NVIDIA
The most interesting development this week is not the GB10 numbers. DFlash2 has also been ported natively to MLX for Apple Silicon, bringing both DSpark and DFlash block-diffusion decoding to M-series Macs with 2–4× lossless speedups, and runs of DFlash2 there report roughly 3× faster decoding for Qwen3.8-27B. One contributor demonstrated a 4-bit Qwen3.8-27B with DFlash2 on an M3 Ultra at about 97 tok/s in mlx-spark and added it to an Apple-Silicon comparison lineup. A second, independent DFlash MLX port reports near-100 tok/s for 4-bit Qwen 27B-class variants on high-end M-series chips. That means the same block-diffusion technique that took over the NVIDIA desk-side decode race is now cost-effective on a completely different silicon vendor within days.
Dual-Node Scaling
DFlash2 scales beyond a single box as well. Benchmarks on two DGX Sparks running Qwen3.8-27B at TP=2 with SGLang and DFlash2 reach about 87 tok/s for code generation, 41 tok/s for prose, and 49 tok/s for thinking-enabled chat, against 52–61/26/34–49 tok/s single-node — a meaningful lift for agentic workloads that need single-stream speed plus a longer context than one GB10’s 128GB of unified memory comfortably serves.
What This Means for Desk-Side Inference
I think the DFlash2 story is the clearest sign yet that the local-inference speed race has moved up a layer. Two weeks ago the leverage was quantization; the 0xBakeer work showed that on the same hardware, speculative decoding was a much bigger multiplier than 4-bit weights. This week the same lesson is playing out one level higher: the winning drafter is not tied to the model vendor or the GPU vendor. DFlash2 started as a DeepSeek optimization, NVIDIA’s own edge ecosystem picked it up, and within a week community ports put it on Apple silicon with the same class of lossless gains. For a buyer, that means the difference between an 8 tok/s and a 90 tok/s local deployment is increasingly a software and drafter selection problem, not a hardware purchase — and for the inference-engine and model-serving vendors, the speculator layer is becoming a genuine competitive surface. As firms such as 650 Group have been tracking in their AI infrastructure research, the deskside and edge inference market keeps resetting the question from “does it fit” to “how fast can software make it,” and the answer is changing week to week.