---
title: "DSpine vs DFlash 2 on Qwen 27B: Which Is Faster?"
url: "https://goremy.ai/blog/articles/dspine-vs-dflash-2-qwen-27b-speed-test"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-17T19:00:09.006Z"
updated: "2026-11-17T19:00:09.006Z"
topic: Local AI
description: "Head-to-head test on one H100: DSpine vs DFlash 2 speeding up Qwen 3.8 27B. Tokens per second, VRAM use, and what a single-request test can't tell you."
---

# DSpine vs DFlash 2 on Qwen 27B: Which Is Faster?

> Head-to-head test on one H100: DSpine vs DFlash 2 speeding up Qwen 3.8 27B. Tokens per second, VRAM use, and what a single-request test can't tell you.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-17

## Is DSpine faster than DFlash 2 for Qwen 3.8 27B?

Yes, in the one head-to-head test we have. On a single NVIDIA H100 with the same model, same prompts and same memory settings, Tencent's DSpine generated about 150 tokens per second overall. DFlash 2 from the Z Lab team generated about 129. That makes DSpine roughly 14 to 16 percent faster. It also used more memory: just over 78 GB of VRAM against about 73 GB. The test sent one request at a time, so treat it as a first look, not a final verdict.

## TL;DR

- **DSpine beat DFlash 2** on every cut of the test: about 152 vs 133 tokens per second on short prompts, about 150 vs 128 on long ones, and about 150 vs 129 overall.
- **The speed costs memory.** DSpine used just over 78 GB of VRAM on an 80 GB H100, while DFlash 2 used about 73 GB.
- **Both are speculative decoding tools.** A small helper model guesses tokens ahead and the big model checks them, so answers stay the same, only faster.
- **The test was narrow.** One GPU, one request at a time, one big model, 32 requests in total. Busy servers with many simultaneous users may behave differently.
- **Both setups finished all 32 requests with no errors,** so this is a speed comparison, not a stability one.
- **Run your own prompts before you commit.** Your workload, not a benchmark, decides which one fits.

## What is speculative decoding, in plain words?

A large language model normally writes one token at a time. A token is a chunk of text, roughly a word or part of a word. Each token requires a full, slow pass through the big model, which is why a 27-billion-parameter model can feel sluggish.

Speculative decoding adds a small, fast helper model. The helper guesses several tokens ahead. The big model then checks all those guesses in a single pass, keeps the correct ones, and fixes the first wrong one. The final answer is the same as it would have been without the helper. It just arrives sooner.

The speedup depends on how many guesses get accepted each round. If the helper is right most of the time, the big model skips many slow passes. If the helper is wrong often, you gain little.

For context, the same creator's earlier test of DSpine on this model reportedly took it from about 33 tokens per second to about 156 on an H100. That is the kind of gain this technique is chasing.

## How do DSpine and DFlash 2 differ?

Both are small helper models built to speed up Qwen 3.8 27B, and both draft a whole block of tokens in one parallel pass rather than one at a time. The difference is in how they keep those parallel guesses consistent with each other.

| | DSpine (Tencent) | DFlash 2 (Z Lab) |
|---|---|---|
| Role | Small helper (drafter) for Qwen 3.8 27B | Small helper (drafter) for Qwen 3.8 27B |
| Helper size | About 2 billion parameters | Not stated in the test |
| Tokens drafted per round | 16 | 8 (its official setting) |
| How guesses stay consistent | Each position passes its current guess to the next across layers, then tokens are picked left to right using a ready-made lookup table | Neighbors blend inside the model with small convolutions, then a best path is chosen at the end |

On its own model card, Tencent reports that DSpine accepts about 7.2 tokens per round, against 5.7 for DFlash, on the GSM8K math benchmark. Those are Tencent's numbers. The hands-on test below was done to see whether the real-world speed matched the claim.

## How was the speed test run?

The setup was designed to be fair:

- **Hardware:** one NVIDIA H100 with 80 GB of VRAM, on an Ubuntu system.
- **Serving software:** SGLang, with both helpers served the same way.
- **Matching settings:** same model, same memory fraction, same context and request limits. DFlash 2 ran at its own recommended setting of eight draft tokens. DSpine drafted 16 at a time and needed a few extra flags.
- **Prompts:** 16 different prompts (eight short, eight needing longer answers or reasoning), each run twice, for 32 requests.
- **Temperature zero,** so results are repeatable.
- **Output:** tokens per second for every request, saved to a JSON file so the two runs could be compared side by side.

## What were the results?

| Measure | DFlash 2 | DSpine | DSpine advantage |
|---|---|---|---|
| Short prompts | about 133 tok/s | about 152 tok/s | about 14% |
| Long prompts | about 128 tok/s | about 150 tok/s | about 16% |
| Overall | about 129 tok/s | about 150 tok/s | about 16% |
| Range per request | about 91 to 168 | about 88 to 227 | wider spread |
| VRAM used | about 73 GB | just over 78 GB | about 5 GB more |
| Errors | none | none | tie |

Two details are worth noticing. First, DSpine's best individual request reached 227 tokens per second, well above DFlash 2's best of 168. But its slowest request (88) was slightly slower than DFlash 2's slowest (91). The average favors DSpine, but speed varied from request to request.

Second, in both runs 10 of the long answers hit the token limit. In the DFlash 2 run, six of those used the entire budget on thinking, so the answers were cut off. The tester kept those numbers because thinking tokens are still tokens the model has to generate, and that is what real use looks like.

## Is a 16% speedup big?

It depends on what you do with it. If you are chatting with a model by yourself, 129 versus 150 tokens per second is a difference you may notice on long answers but not on short ones. Both are far above the roughly 33 tokens per second the same model reportedly managed without a helper.

The gap matters more when volume is high. A 16% gain means a batch job finishes sooner, or the same GPU does more work in a day. For someone paying by the hour to rent a GPU, that translates into a lower bill for the same output.

The extra 5 GB of memory matters too. On an 80 GB card, DSpine left under 2 GB free in this configuration, while DFlash 2 left about 7 GB. That headroom is what you would use for longer contexts or more simultaneous users, so the faster option may leave less room to grow.

## What are the limits of this test?

The creator was clear that this is a first look, and it should be read that way.

- **One request at a time.** Real servers handle many users at once. Speculative decoding gains can shrink or change when a GPU is already busy, and this test did not measure that.
- **One GPU, one model.** Results on other hardware or with other Qwen sizes may differ.
- **32 requests.** Enough to see a consistent pattern, not enough to rule out quirks of this prompt set.
- **Speed only.** The test confirms both finished without errors. It does not grade answer quality, though speculative decoding is designed to keep outputs the same as the big model alone.
- **Settings were each tool's own.** DFlash 2 used its official eight-token setting. A different setting might narrow or widen the gap.

## What does this mean for you?

**If you run models on your own hardware** (a developer, an IT team, a data scientist with a rented GPU), DSpine looks worth testing first for Qwen 3.8 27B, especially if you have memory to spare. If you are tight on VRAM, DFlash 2's smaller footprint may win in practice.

**If you manage a team or budget** and are deciding between self-hosting and paying per token for a hosted service, this shows that speed gains from free helper models are real and sizeable. Ask whoever runs your AI infrastructure whether speculative decoding is switched on.

**If you only use AI through apps,** nothing changes today. But techniques like this are part of why responses get faster and cheaper over time.

What to do before choosing:

1. Collect 15 to 20 real prompts from your own work, short and long.
2. Run both helpers with the same settings and record tokens per second.
3. Repeat with several requests in parallel, matching how many people will actually use it.
4. Check free VRAM after loading each setup.
5. Spot-check a handful of outputs for quality.

## Could you build a tracker for your own benchmark runs?

If you do run comparisons like this, the results tend to end up in scattered JSON files and spreadsheets. With [Remy](https://goremy.ai), you can describe a small internal app in plain English: one that takes uploaded run files, stores each configuration's tokens per second and VRAM use in a database, and shows a side-by-side chart with notes on what changed. Remy builds and deploys it as a full-stack web app you own, so your team can log new tests as hardware, models or settings change, instead of starting a new spreadsheet each time.

## Frequently Asked Questions

### Does speculative decoding change the model's answers?

No. The big model checks every guess from the helper, keeps the correct ones and fixes the first wrong one. The final output matches what the big model would have written alone, only produced faster.

### Why does DSpine use more VRAM than DFlash 2?

In this test, DSpine used just over 78 GB against about 73 GB for DFlash 2. The creator noted that DSpine needed a few extra flags and consumed more memory. The source does not break down exactly where the extra memory goes.

### Can I trust the 7.2 vs 5.7 accepted-tokens figures?

Those come from Tencent's own model card, measured on the GSM8K math benchmark, so they are the vendor's numbers. The hands-on test is an independent check, and its 14 to 16 percent speed advantage points the same direction, though it measured tokens per second rather than accepted tokens.

### Will DSpine be faster on my GPU or with many users?

Unknown. This test used one H100 and one request at a time. Other GPUs and busy servers can change the picture, so run your own test with realistic traffic before deciding.
