Qwen3.8-Flash-Next — NVIDIA FP4-Local + HermiHg MTP draft head (for veloGB10)

Original models: nvidia/Qwen3.8-Flash-Next-FP4-Local by NVIDIA (governed by the NVIDIA Open Model Agreement; its base model Qwen/Qwen3.8-Flash-Next is governed by the Qwen Community License 1.0), plus one file from HermiHg/Qwen3.8-Flash-Next-Optimized-MTP-Heads-exl3 by HermiHg (Apache-2.0). See License below. NVIDIA's original model card follows this card verbatim.

What this repository is: NVIDIA's Qwen3.8-Flash-Next-FP4-Local pack — every file byte-identical to NVIDIA's published revision b9ce18a6887e18c089fdea8509a33e63429a3300 (all 33 files checked: the 23 large files against their published sha256, the 10 small ones against their git object ids) — plus one added file, mtp-2.6bpw.safetensors, byte-identical to HermiHg's published file (revision 836df288557a5f2e06ba8de6fefc73851653c981, sha256 998f5de2d1fc65617111f9092017062eda67f09b3acc74adae38932e22cb55ad, 843,864,440 bytes). Nothing was converted, re-quantized or re-packed: about 96 GB of NVIDIA weights (MXFP8 dense layers, NVFP4 experts, the n-gram table and the vision tower, in tensors/) and a 0.8 GB draft-head sidecar.

This artifact exists first and foremost to run with the veloGB10 inference engine (gb10_inference) on one, two or four NVIDIA DGX Spark / GB10 systems. The NVIDIA weights are the unmodified FP4-Local release, so they can be used for any purpose, with any framework that reads the format (NVIDIA's card below names the vLLM containers that do); such a framework can simply ignore mtp-2.6bpw.safetensors.

Requires veloGB10 v0.7.9 or newer — the first release with FP4-Local support; earlier versions cannot load this pack. veloGB10 reads NVIDIA's compressed NVFP4 scale-factor format directly (exactly, no conversion step), so neither a container nor a re-packed copy is needed.

What this pack is: sources and credits

FP4-Local quantization: NVIDIA (Model Optimizer, quantization-aware distillation).
Optimized MTP draft head: HermiHg (exllamav3).
Base model: Qwen/Qwen3.8-Flash-Next — © the Qwen team.
Fidelity reference figures: turboderp.
Engine: veloGB10.

What was drafted in: HermiHg's optimized MTP draft head

Qwen3.8-Flash-Next carries a one-layer MTP (multi-token prediction) head. A speculative-decoding engine runs it as the drafter: it proposes the next few tokens, the full model verifies them in one pass, and only tokens the full model agrees with are kept — so the drafter changes speed, never the output.

The added file is HermiHg's mtp-2.6bpw.safetensors ("recommended" in that repository): a per-group mixed-precision EXL3 quantization of the original BF16 MTP head, made with exllamav3 (mul1 codebook, identity Hessian), packaged as a sidecar that shadows a model's built-in MTP weights. It holds only mtp.* tensors — 1,546 EXL3 trellis linears (each with its suh / svh / mul1 tensors) and 19 bf16 tensors — at these bit widths (HermiHg's allocation):

group	parameters	bits in 2.6bpw
input projections (`fc_embedding`, `fc_hidden`)	13.1 M	8
attention (`q`/`k`/`v`/`o`)	49.8 M	6
sparse-attention indexer (`index_qk_proj`)	1.6 M	8
shared expert (`gate`/`up`/`down`)	4.9 M	8
routed experts, fused gate+up	1,678 M	2.0
routed experts, down	838.9 M	3.0
norms, hyper-connections, router gates	—	bf16 (copies of the source)

What veloGB10 takes from it — and what it does not. With this file in the model folder, veloGB10's MTP drafter uses the sidecar's dense MTP linears — the two input projections, the attention block, the indexer projection and the shared expert — instead of NVIDIA's bf16 copies of those layers (fewer bytes read per draft pass). Everything else in the draft head stays NVIDIA's: the routed experts (NVIDIA's NVFP4 MTP experts; the sidecar's 2-/3-bit experts are not read), the norms, the hyper-connection mixers and the router. The 2.6bpw and 3.1bpw files are byte-identical in every tensor veloGB10 reads (they differ only in the routed experts), so there is no reason to pick the larger one for veloGB10.

Why this is lossless. The sidecar only drafts. Every token is verified by the full NVIDIA FP4-Local model, so greedy output is byte-identical with and without the sidecar (checked at TP=1 and TP=2) and sampled output keeps the model's own distribution; only draft acceptance and draft cost can move.

What it does on veloGB10 (measured on DGX Spark). On its own the sidecar is a small change: at TP=1, one request, default sampling, decode 51.7 tok/s with it vs 51–52 without, acceptance 57 % vs 57–58 %. veloGB10 ships it together with a second draft-only setting, the draft-head screen (--fp4l-draft-head screen: an int4 copy of the draft head's 65,536 rows picks 16 candidate row blocks per draft pass and only those are scored, exactly). The two together measured 57.3 tok/s vs 51–52 at TP=1, and a VeloBenchmark run at TP=2 moved the median decode from 72.2 to 76.4 tok/s. Both are veloGB10's defaults.

How veloGB10 finds it. --fp4l-mtp-sidecar auto (the default) uses the mtp-*.safetensors file in the model folder (the lexicographically last one if there are several); without such a file, NVIDIA's own MTP head drafts. Under TP the head ships the file to every node with the rest of the model. --fp4l-mtp-sidecar off ignores the file and uses NVIDIA's own MTP head (for A/B checks). The boot log says which head is in use.

Running it with veloGB10

Download a release binary of veloGB10 (one self-contained file; see its README), and the pack with hf download doth4580/Qwen3.8-Flash-Next-FP4-Local --local-dir /path/to/Qwen3.8-Flash-Next-FP4-Local. The server is OpenAI-compatible on http://<head-ip>:9000/v1. The flags below are the ones this pack was tested with; --max-batch sets how many requests run at once.

TP=2 and TP=4 only: the pack does not fit a single GB10 at 262,144 tokens of context.

Two GB10s (TP=2)

On the second machine (no model copy, no configuration):

./gb10_inference --node --port 29500

On the head (the machine with the model folder):

./gb10_inference --server \
  --model-dir /path/to/Qwen3.8-Flash-Next-FP4-Local \
  --tp 2 --nodes <node-ip>:29500 \
  --host 0.0.0.0 --port 9000 \
  --max-seq-len 262144 \
  --max-batch 2 \
  --max-tokens 65536 \
  --prefix-cache on \
  --mtp=auto

Four GB10s (TP=4)

Start ./gb10_inference --node --port 29500 on each of the three other machines, then on the head:

./gb10_inference --server \
  --model-dir /path/to/Qwen3.8-Flash-Next-FP4-Local \
  --tp 4 --nodes <node1-ip>:29500,<node2-ip>:29500,<node3-ip>:29500 \
  --host 0.0.0.0 --port 9000 \
  --max-seq-len 262144 \
  --max-batch 2 \
  --max-tokens 65536 \
  --prefix-cache on \
  --mtp=auto

The nodes need no copy of the model. The head sends each node only its own share of the weights over the network and keeps it in a local cache, so a second start of the same model transfers nothing. On a box with two active RoCE port pairs, name the one to use with --rdma-dev <rail1>,<rail2>; with one pair it is found automatically.

Measured with veloGB10

VeloBench runs against the served API on NVIDIA DGX Spark-class GB10 machines (2026-11-05 to 2026-11-07, veloGB10 0.7.7 development builds), at production sampling: each request sends the pack's default sampler settings, thinking on, one request at a time for the single-request columns. Decode is in output tokens per second and includes speculative decoding. One run per cell; sampled runs vary by roughly ±10%.

Topology	Draft source	Code turn decode	Story turn decode	All-turn median decode	Prefill (tok/s)	2 requests, aggregate	Draft acceptance
TP=2	pack's MTP head	129	60	82	3,341	113	74.2%
TP=4	pack's MTP head	161	79	105	3,894	160	73.2%
TP=2	HermiHg MTP head	140	65	83	3,377	135	71.9%
TP=4	HermiHg MTP head	169	83	103	3,865	164	72.9%
TP=2	DotH-MTP head	139	59	80	3,401	133	71.2%
TP=4	DotH-MTP head	172	85	93	3,881	158	71.9%

Quality — what you get

In short: this pack is a faithful, well-served copy of NVIDIA's FP4-Local, but it is not near-lossless: its distance from the original model lies between the EXL3 3.05 and 4.05 bpw quants, and on task benchmarks it ties EXL3 4.05. veloGB10 offers it for completeness; if you want the closest copy of the original, use EXL3 5.05 or 6.05 (two or more Sparks); if you want speed at similar fidelity, EXL3 4.05 is faster.

Tasks (veloGB10, TP=2):

benchmark	FP4-Local (this pack)	EXL3 4.05 bpw
GSM8K, all 1,319 questions (8-shot CoT, thinking on, greedy)	96.2 %	95.6 % (paired test p = 0.26: a tie)
tool-eval-bench (69 scenarios, seed 42, temperature 0, thinking on)	87 / 100	88 / 100

NVIDIA's own figures (vLLM, see its card below): GPQA Diamond 91.5 % and ToolEvalBench 88.7 % vs 92.2 % and 89.4 % for the BF16 original. NVIDIA's "lossless" wording refers to the compression format of the NVFP4 scale factors (exactly decodable), not to model accuracy.

Distance from the original model (KL divergence of the next-token distribution, nats per token; lower = closer):

pack	vs the BF16 original (turboderp, exllamav3)	vs EXL3 6.05 bpw (veloGB10, 79,241 reference-sampled tokens)	perplexity on outside text (EXL3 6.05: 2.875)
EXL3 6.05 bpw	0.0031	(reference)	2.875
EXL3 5.05 bpw	0.0040	0.0014	2.878
EXL3 4.05 bpw	0.0066	0.0028	2.879
NVIDIA FP4-Local (this pack)	0.0102 ¹	0.0098	2.846
EXL3 3.05 bpw	0.0174	0.0099	2.880
measurement noise floor	0.0026

¹ turboderp's chart labels this point "NVFP4 W4A16" (~4.8 bpw); it is very likely, but not certainly, this exact pack.
The 6.05 reference shares the EXL3 packs' rounding, so the middle column flatters EXL3: against the BF16 original the 4.05-vs-FP4-Local gap is about 1.5x (left column), not the 3.5x the middle column shows. The ranking is the same.
The lower perplexity on outside text (prose, documentation, code the models did not write) is real: NVIDIA retrained the weights by quantization-aware distillation, so this is a slightly different model, not a closer copy.
The engine is not the bottleneck: NVIDIA's own recommended DGX Spark recipe (vLLM container, MXFP8 lm_head, 4-bit prefill activations, fp8 KV) measured 0.0155 on the same tokens (0.0113 with vLLM's most exact settings); veloGB10 serves every stored value exactly and lands closer to the original (0.0098).

Precision in veloGB10

veloGB10 serves every stored value exactly by default: NVFP4 experts and MXFP8 dense layers with their exact per-block scales (W4A16 / W8A16 with f16 activations, fp32 accumulation), and the bf16 / fp32 tensors (lm_head, hyper-connection mixers, router, embeddings, norms, n-gram projections) at their stored precision — no re-quantization and no conversion. The faster ends are opt-in:

flag	default (exact)	opt-in (faster, changes values)
`--fp4l-lm-head`	`bf16`	`f16` (one shift, 2 values round), `mxfp8` (about half the head's bytes)
`--fp4l-plain`	`exact` (stored bf16)	`f16` copies of the bf16 tensors
`--fp4l-norms`	`f32`	`f16`
`--fp4l-prefill-dense`	`exact`	`lt` (f16 dequant + cuBLASLt)
`--hc-int8`	off (stored precision)	int8 hyper-connection mixers

The KV cache is the engine's default --kv-cache q8 (8-bit keys and values, as for every pack veloGB10 serves); --kv-cache f16 keeps it unquantized at twice the KV memory (packed speculative rounds then need --lane-pack-kv any).

Two settings only change the drafter and are on by default: --fp4l-draft-head screen and --fp4l-mtp-sidecar auto (see above); --fp4l-draft-head head and --fp4l-mtp-sidecar off turn them off.

Verification

Lossless loading: every compressed NVFP4 scale plane in the pack is decoded, re-encoded with the producer's rule and compared byte for byte with the stored stream (--probe-fp4l); the MXFP8 / NVFP4 values are used as stored.
Kernels vs an exact host reference on the pack's real tensors (--probe-fp4l-gpu: MXFP8, NVFP4, bf16 and f16 GEMMs at decode, verify and prefill widths; batch invariance; the paired launches bit-identical to single ones).
Speculation is lossless: --bench-mtp LOSSLESS_OK (MTP output == plain greedy); at TP=2 the speculative scheduler's spec program emits exactly the plain arm's tokens with all ranks agreeing (14,577 graphed digests).
Greedy output identical across engine builds at TP=1, TP=2 and TP=4, with and without the draft-only settings.
Not covered: an end-to-end comparison against NVIDIA's vLLM containers; video input.

Files

File	Notes
`tensors/model-00001..00021-of-00021.safetensors`	NVIDIA's weights (~96 GB): MXFP8 dense layers, NVFP4 experts (compressed scale planes), bf16 head / MTP / mixers, fp32 norms, the n-gram table and the vision tower
`model.safetensors.index.json`, `config.json`, `generation_config.json`	NVIDIA's index and configs
`chat_template.jinja`, `tokenizer.json`, `tokenizer_config.json`, `vocab.json`, `merges.txt`	tokenizer and chat template
`preprocessor_config.json`, `video_preprocessor_config.json`	vision preprocessors
`mtp-2.6bpw.safetensors`	added: HermiHg's optimized MTP draft head (EXL3, 805 MiB, Apache-2.0)
`README.md`	this card (NVIDIA's card is reproduced below)

Notes

Images are served (verified at TP=1 and TP=2) through the pack's own vision tower; video and audio parts return 400 for now.
Context is 262,144 tokens (the config's native length).
Need the original MTP head? --fp4l-mtp-sidecar off, or delete mtp-2.6bpw.safetensors.

License

NVIDIA FP4-Local weights and files: governed by the NVIDIA Open Model Agreement; the Qwen3.8-Flash-Next base model is governed by the Qwen Community License 1.0 (see NVIDIA's card below).
mtp-2.6bpw.safetensors: released by HermiHg under Apache-2.0; it is a quantization of the Qwen3.8-Flash-Next MTP head (base model license as above).

Read the linked terms for the binding text. This repository redistributes these files unmodified and is not affiliated with or endorsed by NVIDIA, Qwen or HermiHg.

Intellectual property

We do not claim any intellectual-property ownership of the model, its weights, its architecture or its original documentation. All rights stay with the original authors and with every contributor credited above, under their own licences, which apply to this repository unchanged. Our contribution is limited to what the "What this pack is" section says we did (quantization, packaging, testing and the veloGB10 instructions). If you are a rights holder and want something here changed or removed, open a discussion on this repository.

Original model card — NVIDIA Qwen3.8-Flash-Next-FP4-Local (verbatim)

The text below is NVIDIA's model card for nvidia/Qwen3.8-Flash-Next-FP4-Local, reproduced verbatim from revision b9ce18a6887e18c089fdea8509a33e63429a3300 (its YAML header is merged into the header of this card). Its usage instructions describe NVIDIA's vLLM containers, not veloGB10.

Model Overview

IMPORTANT: the NVFP4 scale factors in this checkpoint are in a new lossless compression format, but upstream vLLM support for this format has not yet landed. You must use one of the containers provided below.

Description:

The NVIDIA Qwen3.8-Flash-Next-FP4-Local model is the quantized version of Alibaba's Qwen3.8-Flash-Next model, which is an auto-regressive language model that uses an optimized transformer architecture. Qwen3.8-Flash-Next is a causal language model with a vision encoder, hybrid attention (Gated DeltaNet and Qwen Sparse Attention), Mixture-of-Experts, gated residual streams, and n-gram embeddings. For more information, please check here. The NVIDIA Qwen3.8-Flash-Next-FP4-Local model is quantized with Model Optimizer using quantization-aware distillation (QAD).

The checkpoint occupies approximately 96 GiB on disk and is best suited for local AI hardware. It has been validated with vLLM on the following hardware:

NVIDIA RTX PRO 6000 Blackwell — single GPU, with PLE (n-gram embedding table) offload. 850K tokens of FP8 KV Cache
NVIDIA DGX Spark — Can run with or without PLE offload. 1M tokens of FP8 KV Cache with PLE offload

This model is ready for commercial or non-commercial use.

Third-Party Community Consideration

This model is not owned or developed by NVIDIA. This model has been developed and built to a third-party's requirements for this application and use case; see link to Non-NVIDIA (Qwen3.8-Flash-Next) Model Card from Qwen.

License/Terms of Use:

GOVERNING DOWNLOAD TERMS: Use of this model is governed by NVIDIA Open Model Agreement.

ADDITIONAL INFORMATION : The Qwen3.8-Flash-Next base model is governed by the Qwen Community License 1.0. Qwen3.8-Flash-Next.

Deployment Geography:

Global

Use Case:

Developers looking to take off-the-shelf, pre-quantized models for deployment in AI Agent systems, chatbots, RAG systems, and other AI-powered applications.

Release Date:

Hugging Face 10/05/2026 via https://huggingface.co/nvidia/Qwen3.8-Flash-Next-FP4-Local

References

NVIDIA Model Optimizer: https://github.com/NVIDIA/Model-Optimizer

Model Architecture:

Architecture Type: Transformers
Network Architecture: Hybrid Attention (Gated DeltaNet and Qwen Sparse Attention) with Mixture-of-Experts (Qwen4ExpForConditionalGeneration)
Number of Model Parameters: 125B in total and 6B activated, plus 51B n-gram embedding and 4B MTP
This model was developed based on Qwen3.8-Flash-Next

Input:

Input Type(s): Text, Image, Video
Input Format(s): String, Red, Green, Blue (RGB), Video (MP4/WebM)
Input Parameters: One-Dimensional (1D), Two-Dimensional (2D), Three-Dimensional (3D)
Other Properties Related to Input: Context length up to 262K natively and extensible up to 1,000,000 tokens.

Output:

Output Type(s): Text
Output Format: String
Output Parameters: One-Dimensional (1D): Sequences
Other Properties Related to Output: None

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.

Software Integration:

Supported Runtime Engine(s):

vLLM

Supported Hardware Microarchitecture Compatibility:

NVIDIA Blackwell

Preferred Operating System(s):

Linux

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

Model Version(s):

The model version is FP4 QAD 1.0 and is quantized with nvidia-modelopt v0.47.0

Training and Evaluation Datasets:

Calibration Dataset:

Link: Subset of Nemotron-Post-Training-Dataset-v3, Nemotron-Post-Training-Dataset-v2 and subset of Nemotron-Pretraining-Dataset
Data Collection Method by dataset: Automated.
Labeling Method by dataset: Automated.
Properties: NVIDIA's Nemotron-Post-Training-v3 is an open collection of approximately 50 curated Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) datasets designed for the Nemotron 3 model family (Nano, Super, and Ultra). NVIDIA's Nemotron-Post-Training-Dataset-v2 is a post-training dataset curated by NVIDIA containing multi-turn conversations across diverse topics. The Nemotron-Pre-Training-Datasets collection on Hugging Face provides large-scale data corpora used to train the NVIDIA Nemotron model family

Training Dataset:

Link: Subset of Nemotron-Post-Training-Dataset-v3, Nemotron-Post-Training-Dataset-v2 and subset of Nemotron-Pretraining-Dataset; only prompts from the datasets were used for data synthesis.
Data Modality: Text
Text Training Data Size: 500 Million Tokens, repeated for 3 epochs
Data Collection Method by dataset: Hybrid: Automated, manually-collected, Synthetic
Labeling Method by dataset: Hybrid: Automated, manually-labelled, Synthetic
Properties: The Qwen3.8-Flash-Next-FP4-Local model was trained exclusively on a post-training corpus includes synthetic data for reasoning, code, science, tool use, instruction following, structured outputs, and multilingual tasks. Dataset disclosures are published in the nvidia/nemotron-post-training-v2 and subset of nvidia/nemotron-post-training-v3 and subset of nvidia/nemotron-pre-training-datasets Hugging Face collections.

Inference:

Acceleration Engine: vLLM Test Hardware: NVIDIA DGX Spark and NVIDIA RTX PRO 6000 Blackwell

Evaluation

Datasets: GPQA Diamond, ToolEvalBench
Data Collection Method by dataset: Hybrid: Automated, Manually-Collected
Labeling Method by dataset: Hybrid: Manually-Labeled, Automated
Properties: GPQA Diamond contains 198 graduate-level multiple-choice questions written by domain experts in biology, physics, and chemistry. ToolEvalBench is a tool-calling quality benchmark that runs deterministic multi-turn agent scenarios against mock tools, scoring tool selection, parameter precision, multi-step chains, error recovery, and structured output.

The accuracy benchmark results are presented in the table below:

Precision	GPQA Diamond	ToolEvalBench
BF16	92.2%	89.4%
FP4-Local	91.5%	88.7%

Baseline: Qwen3.8-Flash-Next.

Quantization-Aware Distillation

The BF16 teacher generates responses and supplies token-level probability and hidden-state targets. The trainable NVFP4 and MXFP8 weights are quantized and reconstructed for each forward pass. Gradients update the underlying weights so their low-precision representations better match the teacher.

The objective combines next-token probability matching using total variation, hidden-state matching, and separate losses for end-of-response and end-of-thinking behavior. These boundary losses target the teacher's decisions to continue, finish reasoning, and stop responding.

Training uses the Quatrain distillation trainer: 2,500 trunk updates followed by 1,500 joint-refinement updates, which also train the n-gram embedding tables and simulate MXFP8 shared-expert weights. Attention remains frozen, using its MXFP8 weights during joint refinement.

What's quantized

Component	Stored Precision
Decoder routed experts	QAD NVFP4; E2M1 values, E4M3 block scales, FP32 global/input scales
Decoder attention	MXFP8 projection selection from the pinned source
MTP routed experts	NVFP4, BF16 activations; block scales stored directly
Vision attention linears	MXFP8 E4M3 values; UE8M0 scales per 32 weights; 54 matrices
Vision MLP and merger linears	NVFP4 E2M1 values; E4M3 scales per 16 weights and FP32 global scale; 56 matrices; BF16 activations
Other vision tensors	BF16; 223 tensors, including normalization, biases, position embeddings, and convolutions
Normalization parameters	100 FP32 tensors (97 hyperconnection and 3 PLE norms); 203 BF16 tensors; original bytes preserved

Inference:

Acceleration Engine: vLLM
Test Hardware: NVIDIA DGX Spark and NVIDIA RTX PRO 6000 Blackwell

Usage

This checkpoint requires community vLLM containers (provided in cooperation with the "Local Inference Lab" community organization) until all features are available in upstream vLLM.

NVIDIA DGX Spark

vLLM container: eugr/spark-vllm-b12x:latest

Start the container. Set HF_TOKEN in the host environment first.

mkdir -p $HOME/.cache/huggingface $HOME/.cache/vllm $HOME/.cache/flashinfer $HOME/.triton $HOME/.cache/b12x

docker run --rm -it \
  --gpus all \
  --ipc host \
  --network host \
  --shm-size=16g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  --security-opt seccomp=unconfined \
  --security-opt apparmor=unconfined \
  -e HF_TOKEN=$HF_TOKEN \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -v $HOME/.cache/vllm:/root/.cache/vllm \
  -v $HOME/.cache/flashinfer:/root/.cache/flashinfer \
  -v $HOME/.triton:/root/.triton \
  -v $HOME/.cache/b12x:/root/.cache/b12x \
  --entrypoint /bin/bash \
  eugr/spark-vllm-b12x:latest

Then launch vLLM inside the container:

export VLLM_PLE_TABLE_MEMORY="disk"
export B12X_DISK_BACKEND="io_uring"
export CUTE_DSL_ARCH="sm_121a"
export SAFETENSORS_FAST_GPU="1"
export VLLM_WORKER_MULTIPROC_METHOD="spawn"
export VLLM_SSM_CONV_STATE_LAYOUT="DS"
export VLLM_USE_AOT_COMPILE="1"
export VLLM_USE_MEGA_AOT_ARTIFACT="1"
export VLLM_USE_V2_MODEL_RUNNER="1"
export B12X_POLICY_MODE="auto"
export VLLM_MXFP8_LM_HEAD="1"
export VLLM_B12X_MOE_FP4_LAYER_MAX_INPUT_SCALE="w13"
export VLLM_B12X_MOE_FP4_FORCE_A16=1
export B12X_W4A16_A4_PREFILL=1

vllm serve nvidia/Qwen3.8-Flash-Next-FP4-Local \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --pipeline-parallel-size 1 \
    --mamba-cache-mode align \
    --enable-prefix-caching \
    --enable-chunked-prefill \
    --dtype bfloat16 \
    --kv-cache-dtype fp8 \
    --quantization modelopt_mixed \
    --block-size 16 \
    --load-format b12x \
    --max-model-len 262144 \
    --max-num-seqs 8 \
    --max-num-batched-tokens 4096 \
    --speculative-config '{"method":"mtp","num_speculative_tokens":4}' \
    --gdn-decode-kernel b12x \
    --linear-backend b12x \
    --moe-backend b12x \
    --no-enable-flashinfer-autotune \
    --mm-encoder-tp-mode data \
    --reasoning-parser qwen3 \
    --tool-call-parser qwen3_xml \
    --enable-auto-tool-choice \
    --compilation-config '{"pass_config":{"fuse_act_quant":true}}' \
    --gpu-memory-utilization 0.8

NVIDIA RTX PRO 6000 Blackwell

vLLM container: ghcr.io/local-inference-lab/vllm:release-10152026

Simplified run command:

  docker run -d --name qwen38-tp1 --init --gpus '"device=0"' \
    --restart on-failure --network host --ipc host --shm-size 32g --stop-timeout 30 \
    --ulimit memlock=-1 --ulimit stack=67108864:67108864 \
    -v model-cache:/root/.cache/huggingface -v qwen38-runtime:/cache \
    -e PROFILE=qwen38-flash-next -e PORT=8000 \
    ghcr.io/local-inference-lab/vllm:release-10152026

Two step verbose commands:

Start the container. Set HF_TOKEN in the host environment first.

docker run --rm -it \
  --gpus all \
  --ipc host \
  --network host \
  --shm-size=16g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  -e HF_TOKEN=$HF_TOKEN \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --entrypoint /bin/bash \
  ghcr.io/local-inference-lab/vllm:release-10152026

Then launch vLLM inside the container:

export B12X_DENSE_SPLITK_TURBO=1
export B12X_DYNAMIC_DETERMINISTIC_OUTPUT=0
export B12X_DYNAMIC_DIRECT_EXPERT_SCALES=1
export B12X_DYNAMIC_SKIP_SPLIT_BARRIER_RESET=1
export B12X_DYNAMIC_SPLIT_COMPUTE_MAC=224
export B12X_DYNAMIC_SPLIT_FAST_PREPARE=1
export B12X_DYNAMIC_SPLIT_LOW_SMEM=1
export B12X_DYNAMIC_SPLIT_ROUTE_COMPUTE=1
export B12X_DYNAMIC_WORK_SOURCE=persistent_grid
export B12X_W4A16_A4_PREFILL=1
export B12X_DISK_BACKEND=io_uring
export B12X_MHC_PDL=1
export B12X_PCIE_ONESHOT_BLOCK_LIMIT=4
export B12X_PCIE_ONESHOT_PDL=1
export B12X_PCIE_ONESHOT_THREADS=512
export CUDA_BINARY_LOADER_THREAD_COUNT=8
export CUDA_DEVICE_ORDER=PCI_BUS_ID
export CUDA_MODULE_LOADING=LAZY
export CUTE_DSL_ARCH=sm_120a
export INSTANTTENSOR_BACKEND=BUFFERED
export NCCL_BUFFSIZE=2097152
export NCCL_CUMEM_ENABLE=0
export NCCL_IB_DISABLE=1
export NCCL_MAX_NCHANNELS=16
export NCCL_MIN_NCHANNELS=16
export NCCL_NET_PLUGIN=spcx
export NCCL_P2P_LEVEL=SYS
export NCCL_PROTO=LL,LL128,Simple
export OMP_NUM_THREADS=2
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
export SAFETENSORS_FAST_GPU=1
export TORCHINDUCTOR_LOOP_ORDERING_AFTER_FUSION=0
export TORCH_CUDA_ARCH_LIST=12.0a
export VLLM_B12X_DENSE_ACTIVATION_MODE=auto
export VLLM_B12X_MOE_FP4_FORCE_A16=1
export VLLM_CAUSAL_CONV1D_UPDATE_HOIST=1
export VLLM_COMPUTE_NANS_IN_LOGITS=0
export VLLM_DISABLED_KERNELS=MarlinFP8ScaledMMLinearKernel
export VLLM_ENABLE_PCIE_ALLREDUCE=1
export VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH=1
export VLLM_LM_HEAD_A16=1
export VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS=0
export VLLM_MTP_NVFP4_LM_HEAD=1
export VLLM_MXFP8_LM_HEAD=0
export VLLM_PCIE_ALLREDUCE_BACKEND=b12x
export VLLM_PLE_CPU_OFFLOAD=1
export VLLM_QWEN3_8_FLASH_NEXT_HC_TP=0
export VLLM_QWEN3_8_FLASH_NEXT_MTP_COMPACT=1
export VLLM_QWEN3_8_FLASH_NEXT_OVERLAP=1
export VLLM_SSM_CONV_STATE_LAYOUT=DS
export VLLM_USE_FASTOKENS=1
export VLLM_USE_V2_MODEL_RUNNER=1
export VLLM_WORKER_MULTIPROC_METHOD=spawn
export TORCH_ALLOW_TF32_CUBLAS_OVERRIDE=1
export TORCH_NCCL_USE_COMM_NONBLOCKING=0

vllm serve nvidia/Qwen3.8-Flash-Next-FP4-Local \
    --host 0.0.0.0 \
    --port 8000 \
    --async-scheduling \
    --block-size 64 \
    --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE","custom_ops":["all"]}' \
    --decode-context-parallel-size 1 \
    --dtype bfloat16 \
    --enable-auto-tool-choice \
    --enable-chunked-prefill \
    --no-enable-flashinfer-autotune \
    --enable-prefix-caching \
    --enable-prompt-tokens-details \
    --gdn-decode-kernel b12x \
    --gpu-memory-utilization 0.975 \
    --kv-cache-dtype fp8 \
    --no-language-model-only \
    --linear-backend b12x \
    --load-format instanttensor \
    --mamba-cache-mode align \
    --mamba-ssm-cache-dtype auto \
    --max-cudagraph-capture-size 64 \
    --max-model-len 262144 \
    --max-num-batched-tokens 6019 \
    --max-num-seqs 16 \
    --mm-encoder-tp-mode data \
    --mm-processor-cache-gb 0.0 \
    --moe-backend b12x \
    --pipeline-parallel-size 1 \
    --quantization modelopt_mixed \
    --reasoning-parser qwen3 \
    --speculative-config '{"method":"mtp","draft_sample_method":"probabilistic","rejection_sample_method":"standard","moe_backend":"b12x","num_speculative_tokens":3}' \
    --tensor-parallel-size 1 \
    --tool-call-parser qwen3_xml

Ethical Considerations

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

For more detailed information on ethical considerations for this model, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy Subcards below.

Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.

SUBCARDS:

Explainability

Field	Response
Intended Task/Domain:	Text generation, reasoning, summarization, and question answering.
Model Type:	Text and Image-to-text transformer
Intended Users:	This model is intended for developers, researchers, and customers building/utilizing LLMs, while balancing accuracy and efficiency.
Output:	Text String(s)
Describe how the model works:	Generates text by predicting the next word or token based on the context provided in the input sequence using multiple self-attention layers.
Name the adversely impacted groups this has been tested to deliver comparable outcomes regardless of:	Not Applicable
Technical Limitations & Mitigation:	The model was trained on data that contains toxic language and societal biases originally crawled from the internet. Therefore, the model may amplify those biases and return toxic responses especially when prompted with toxic prompts. Therefore, before deploying any applications of this model, developers should perform safety testing and tuning tailored to their specific applications of the model.
Verified to have met prescribed NVIDIA quality standards:	Yes
Performance Metrics:	Accuracy, Throughput, and user-side throughput
Potential Known Risk	The model may generate answers that may be inaccurate, omit key information, or include irrelevant or redundant text producing socially unacceptable or undesirable text, even if the prompt itself does not include anything explicitly offensive.
Licensing:	GOVERNING DOWNLOAD TERMS: Use of this model is governed by NVIDIA Open Model Agreement.

ADDITIONAL INFORMATION : The Qwen3.8-Flash-Next base model is governed by the Qwen Community License 1.0. |

Bias

Field	Response
Participation considerations from adversely impacted groups protected classes in model design and testing:	None
Measures taken to mitigate against unwanted bias	None

Safety & Security

Field	Response
Model Application Field(s):	Chat, Instruction Following, Chatbot Development, Code Generation, Reasoning
Describe the life critical impact (if present)	Not Applicable
Use Case Restrictions:	Abide by the GOVERNING DOWNLOAD TERMS: Use of this model is governed by NVIDIA Open Model Agreement.

ADDITIONAL INFORMATION : The Qwen3.8-Flash-Next base model is governed by the Qwen Community License 1.0. | | Model and Dataset Restrictions: | The Principle of least privilege (PoLP) is applied limiting access for dataset generation. Restrictions enforce dataset access during training, and dataset license constraints adhered to. Model checkpoints are made available on Hugging Face, and may become available on cloud providers' model catalog. |

Privacy

Field	Response
Generatable or reverse-engineerable personal data	No
Personal data used to create this model	None Known
Was consent obtained for any personal data used	Not Applicable
How often is the dataset reviewed	Before Release
Was data from user interactions with the AI model used to train the model	No
Is there provenance for all datasets used in training	Yes
Does data labeling comply with privacy laws	Yes
Is the data compliant with data-subject requests for correction or removal	No, not possible with externally-sourced data.
Applicable NVIDIA Privacy Policy	NVIDIA Privacy Policy

Downloads last month: 1

Safetensors

Model size

188B params

Tensor type

U32

BF16

I64

F32

F8_E4M3

Model tree for doth4580/Qwen3.8-Flash-Next-FP4-Local

HermiHg/Qwen3.8-Flash-Next-Optimized-MTP-Heads-exl3

nvidia/Qwen3.8-Flash-Next-FP4-Local

Merge model

this model