Qwen3.8-Flash-Next-Code-Turbo-Spark

Qwen3.8-Flash-Next Code Turbo 0914 for DGX Spark

60.3 tok/s fixed-512 single stream. Six simultaneous native-262K slots. 155/164 HumanEval and 152/164 HumanEval+ Mini. Vision and tools. One Spark.

Turbo 0914 is the full-weight, high-capacity Qwen3.8-Flash-Next release I built for one DGX Spark-class machine. It combines the quality-focused W4A16 AutoRound hybrid checkpoint, its FP8 PLE table, a narrowly scoped FP8-QSA KV overlay, and the exact N6 serving profile I qualified on GB10.

This repository is self-contained at the model layer: the checkpoint files are at the repository root and the FP8 PLE files are in ple-table-fp8/. The complete download is 123,844,347,823 bytes (115.34 GiB) before local cache metadata.

The result

Measured on one ASUS GX10 with NVIDIA GB10 and approximately 121 GiB of usable unified memory.

Read the speed numbers correctly

The numbers above come from different workloads, so I am publishing them separately.

• 60.261 tok/s is the median of a controlled, fixed-512-token, single-stream benchmark after warmup.
• 51.180 tok/s is the median across distinct Python, Rust, TypeScript, CUDA C++, and Go prompts, each forced to 512 generated tokens. It is the more conservative estimate for varied coding work.
• 79.2-79.3 tok/s comes from a 120-turn tool-using coding session whose turns are much shorter. It is real agentic throughput, not a substitute for the fixed-512 result.
• 140.970 tok/s is aggregate throughput with six simultaneous streams, not single-stream speed.

Short-output canaries are not treated as equivalent to the fixed-512 or five-language results.

Why 0914 exists

Turbo 0913 proved the checkpoint was fast and quality-safe. Turbo 0914 solves the harder capacity problem: giving six admitted conversations the model's entire native 262,144-token address space on a single 128 GB-class machine.

Only the twelve main QSA K/V caches move to E4M3 FP8. Activations, the QSA selector cache, compressor state, GDN recurrent state, gates, embeddings, normalization, hyper-connections, and model output math remain in their pinned representations. The allocator pads the smaller FP8 QSA page to the shared BF16 GDN page size, preserving the shared block layout. On GB10/SM121, the overlay uses a one-stage FP8 QSA split-K launch because the two-stage warmup exceeds the device's shared-memory limit.

That targeted change expands the KV arena from Turbo 0913's 12 GiB BF16 pool to 33 GiB, while retaining a measured host-memory floor and avoiding request-time swap growth. The weights themselves are unchanged from their pinned source revisions.

Native 262K, six times

The decisive test was not six small requests. It was six distinct, uncached requests running together, each using exactly:

262,128 input tokens + 16 output tokens = 262,144 tokens

That last number matters: N6 is a capacity proof, not a claim that six cold 262K prefills are interactive. Normal short-context TTFT is dramatically lower. Distributed retrieval also passed at 32K, 128K, and 260K with no cached prompt tokens.

Quality did not get traded away

All 164 first-pass HumanEval generations were preserved and scored with EvalPlus 0.3.1 against the official HumanEval+ Mini fixture. There were no generation retries and no API failures.

The full 120-turn coding-agent run completed in 397.9 seconds, made 119 valid tool calls with zero malformed calls, retained its late-recall fact, and ended at 12,965 context tokens.

Five-language single-stream screen

Thinking and tools were disabled. Each distinct prompt generated exactly 512 tokens and ended by length, so early tool calls or short answers could not inflate the result.

Median TTFT across the remaining four trials was 0.211 seconds. The first trial was 1.830 seconds and is retained in the receipt rather than silently removed.

Concurrency

This is the same fixed-512 protocol at C1, C2, C4, and C6. Every lane generated 512 tokens. Warmup was excluded; queueing, aborts, and preemptions remained at zero.

Download

Put the full repository on fast local NVMe:

hf download sayyidfareed/Qwen3.8-Flash-Next-Code-Turbo-Spark \
  --local-dir /models/qwen38-code-turbo-spark

The download contains the complete checkpoint, tokenizer, configuration, model index, FP8 PLE table, runtime overlay, launcher, and sanitized qualification receipts. No second model download is required.

Build the qualified runtime

The public runtime source is pinned to Saren-Arterius/qwen3.8-Flash-DGX-AutoRound at commit 1633d4bc11701c04d7cbd633994421466d1eff1d.

git clone https://github.com/Saren-Arterius/qwen3.8-Flash-DGX-AutoRound.git
cd qwen3.8-Flash-DGX-AutoRound
git checkout 1633d4bc11701c04d7cbd633994421466d1eff1d
docker build -t qwen38-code-turbo-base .

Then apply the 0914 overlay from this model repository:

cd /models/qwen38-code-turbo-spark
BASE_IMAGE=qwen38-code-turbo-base \
IMAGE=qwen38-code-turbo-0914 \
bash ./scripts/build-fp8-qsa-overlay.sh

The patch is anchored to the pinned runtime source and fails closed if those anchors drift. If you need to enforce the byte-exact base image used for the published measurements, add:

EXPECTED_BASE_IMAGE_ID=sha256:fbb662117354aabbba93cd392bd83e6b9223a93f1a96d445acb113300798dfeb

Serve

MODEL_ROOT=/models/qwen38-code-turbo-spark \
IMAGE=qwen38-code-turbo-0914 \
PORT=11002 \
bash ./scripts/serve-turbo-0914.sh

docker logs -f qwen38-code-turbo-0914

The launcher binds only to loopback and does not enable authentication. Put an authenticated private proxy in front of it before exposing it beyond the host.

curl http://127.0.0.1:11002/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "qwen3.8-flash-next-code-turbo-0914",
    "messages": [{
      "role": "user",
      "content": "Write a resumable PostgreSQL migration with rollback and observability."
    }],
    "temperature": 0,
    "max_tokens": 1024,
    "tool_choice": "none",
    "chat_template_kwargs": {"enable_thinking": false}
  }'

Exact serving profile

PLE startup prewarming may populate the operating system's file cache and is reported diagnostically. The accepted request-time boundary is stricter: zero net swap growth, zero aborts, zero preemptions, and at least a 2 GiB available host-memory floor.

Reproducibility

Machine-readable receipts and their checksums are in results/qualification-0914/.

Limits

• 60.261 tok/s is a controlled coding result, not a guarantee for every language, prompt, output length, or thermal state.
• N6 proves six independent native-context reservations. Six cold 262K prefills are intentionally reported as a slow capacity stress test.
• The 65,536-ID draft vocabulary is optimized for English and code; CJK-heavy output may see lower speculative acceptance.
• The PLE table requires fast local NVMe.
• This release claims 262,144 tokens per slot, not 500K or 1M context.
• Generated code still requires review and tests.

Credit

The unchanged W4A16 AutoRound hybrid checkpoint and FP8 PLE weights were published by Saren, with the public runtime in Saren-Arterius/qwen3.8-Flash-DGX-AutoRound. That work made a strong starting point. Turbo 0914's contribution is the FP8-QSA KV overlay, the 33 GiB N6 serving profile, and the end-to-end quality, vision, tool, agentic, concurrency, and exact native-context qualification.

Qwen created Qwen3.8-Flash-Next. Intel AutoRound, vLLM, GPTQ-Marlin, FlashInfer, and NVIDIA provide major parts of the inference stack.

The model weights are governed by the Qwen license in LICENSE. The original scripts and documentation in this repository are separately licensed under CODE_LICENSE.