DSpine

DSpine

Drafts several tokens at once for speculative decoding with Qwen3-8B, so a model server can check them in one pass. For inference engineers and speculative decoding researchers.

Made by tencent on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: DSpine is a drafter model for speculative decoding with Qwen3-8B. A drafter guesses several upcoming tokens, and the main model then checks them together. DSpine drafts every position in parallel, while each position still receives the predicted feature of the position before it at every draft layer.

Who it suits: Engineers who run their own Qwen3-8B server and want to try parallel drafting are the main fit. Researchers who compare drafters by acceptance length can use it too.

Industry | Who uses it | How they use it | Example
AI infrastructure | Inference engineers | Serve Qwen3-8B with a parallel drafter | Run the serve command from the card with their own model path
Research | Speculative decoding researchers | Compare drafters by acceptance length | Check DSpine against DFlash, Domino, DSpark and DFlash2
Platform teams | ML platform engineers | Test whether drafting helps their own serving | Reuse the server settings behind the paper's reported results

If you do not run your own model server, or you use a target other than Qwen3-8B, you can skip it.

Where to use it: It runs inside an SGLang server.

• SGLang, through its serve command with the DSPINE algorithm
• A server that supports the fa3 attention backend and CUDA graphs
• Windows, macOS or Linux, with Python for the download

Use case | Who | What they get back
Parallel drafting | Inference engineers | Draft tokens for Qwen3-8B that the main model checks in one pass
Benchmarking | Researchers | Acceptance lengths on math, code and chat sets to compare with other drafters
Server tuning | Platform teams | A tested set of server flags to start from

How to set it up: You need Python, SGLang, the Qwen3-8B target model and the DSpine files.

• Python with pip
• SGLang, since the serve command comes from it
• The Qwen3-8B target model
• Room for the DSpine weights, about 2.5 GB in BF16 or about 619 MB at 4-bit as an estimate

1. Install the Hugging Face hub package and download the DSpine files.
2. Clone the project's code repository, which the card names.
3. Install the project in editable mode from inside its folder.

pip install -U huggingface_hub
hf download tencent/Qwen3-8B-DSpine-b16

cd dspine
pip install -e .

How to use it: Start the SGLang server with Qwen3-8B as the target and your DSpine folder as the draft model. The card says these settings are the ones behind the paper's reported acceptance lengths and throughput.

sglang serve \
  --model-path Qwen/Qwen3-8B \
  --speculative-algorithm DSPINE \
  --speculative-draft-model-path <dspine-model-path> \
  --speculative-num-draft-tokens 16 \
  --dtype bfloat16 \
  --attention-backend fa3 \
  --page-size 1 \
  --mem-fraction-static 0.65 \
  --context-length 8192 \
  --max-running-requests 64 \
  --cuda-graph-bs-decode 1 2 4 8 16 32 64 \
  --trust-remote-code

Tool | What it does
--speculative-algorithm DSPINE | Chooses DSpine as the drafting method
--speculative-draft-model-path | Points at the folder that holds your DSpine files
--speculative-num-draft-tokens 16 | Sets the number of draft tokens to 16
--context-length 8192 | Sets the context length to 8192
--max-running-requests 64 | Caps how many requests run at once at 64

Example: You replace the placeholder with the folder that holds the downloaded DSpine files and run the command. The server starts Qwen3-8B with DSpine as its drafter and 16 draft tokens, using the settings behind the paper's results.

For newcomers and experts: Speculative decoding speeds up text generation. A small drafter guesses several tokens ahead, and the big model checks them in one go. A good first try is to download the DSpine files and read the serve settings above before you run anything.

What sets DSpine apart is how it drafts. It fills every draft position at once. Inside the drafter, each layer hands a position the feature predicted for the position before it, so the order of the text is followed through depth instead of across time. The card reports results for Qwen3-8B only, and its training code is still on the roadmap.

The target model gets a prompt
DSpine drafts all positions in parallel
Each layer passes features to the next position
The target model checks the drafts
Accepted tokens join the reply

Good to know: The card compares average acceptance length on Qwen3-8B. DSpine, DSpark and DFlash2 were all retrained on Open-PerfectBlend with the same configuration, while DFlash and Domino use their official checkpoints.

Title: Average acceptance length at temperature 0
DFlash: 5.92
Domino: 7.05
DSpark: 7.44
DFlash2: 7.55
DSpine: 7.83

Title: Average acceptance length at temperature 1
DFlash: 4.94
Domino: 5.59
DSpark: 6.65
DFlash2: 6.53
DSpine: 6.98

• Roadmap: training code for DSpine and a version for Qwen3.8-27B are still planned
• Remote code: the serve command passes trust-remote-code, so run it only with files you trust
• License: Apache 2.0
• Cost to run: none named
• Data it reaches: your prompts, the Qwen3-8B target model and the DSpine files. The card names no account or web service
• Not for: other target models for now, since only Qwen3-8B is covered and the Qwen3.8-27B version is a plan

On Hugging Face, 13 November 2026

• Parameters: 1.2B
• Weights: about 2.5 GB in BF16; about 619 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,280
• Likes: 30
• License: apache-2.0
• Tags: safetensors, qwen3

Links

• Model: https://huggingface.co/tencent/Qwen3-8B-DSpine-b16
• Files: https://huggingface.co/tencent/Qwen3-8B-DSpine-b16/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download tencent/Qwen3-8B-DSpine-b16

Then follow the usage in its model card. Nothing in this kit runs by itself.