---

license: other

license_name: qwen-community-1.0

license_link: https://huggingface.co/orcarouter/Qwen3.8-Flash-Next-Uncensored/blob/8336e613ea508b13c2159bd0f68965d97a606b95/LICENSE

base_model: orcarouter/Qwen3.8-Flash-Next-Uncensored

base_model_relation: quantized

pipeline_tag: image-text-to-text

tags:

- gguf

- mixed-quant

- qwen4exp

- qwen3.8-flash-next

- uncensored

- abliterated

- dgx-spark

- ds4

- ssd-offload

---

Qwen3.8-Flash-Next-Uncensored Mixed-Quant SSD-PLE GGUF

> **This is a direct BF16 conversion of

> orcarouter/Qwen3.8-Flash-Next-Uncensored

> using the exact tensor-level MQ-Q5-SSD-PLE-BF16 recipe published for

> Qwen3.8-Flash-Next-Mixed-Quant-SSD-PLE-GGUF.**

> It is not requantized from an existing GGUF.

>

> The 51.2B-parameter predictive latent embedding (PLE) table is stored as a

> four-file BF16 SSD sidecar. A fresh extraction from the uncensored source

> checkpoint was performed; all four resulting files are byte-identical to

> the public reference PLE files. They are nevertheless included directly in

> this repository so the Q5 artifact is self-contained. An [official FP8 PLE

> sidecar](#choose-a-ple-sidecar-bf16-or-fp8) is also available separately.

>

> A dedicated ds4 external SSD-PLE loader is required. Compatibility with

> generic llama.cpp, vLLM, SGLang, or other GGUF runtimes is not implied.

>

> Update 2026-09-02: the five-round prefill campaign on ds4-dfm-rs@230655d brings this artifact to 910.7 tok/s median cold prefill on an 8,259-token repeated-passage prompt (three fresh workers: 909.5, 910.7, 911.2 tok/s; the same-day unmodified baseline measured 556.2 tok/s) and 597.1 tok/s on a 7,937-token markdown prompt whose n-grams miss the PLE page cache. See the campaign section below for the per-round table and method.

>

> On a single NVIDIA DGX Spark, the Q5+Sidecar path on ds4-dfm-rs@f879bf5 reached 603.4 tok/s median cold prefill across three fresh-worker 8,025-prompt-token runs: 607.3, 601.3, and 603.4 tok/s, all with zero cached tokens. With --mtp-draft 2, a short MTP-friendly two-bank run reached 29.4 tok/s API-timing-derived aggregate decode from concurrent 140- and 192-token completions. The decode figure is aggregate across both banks, not single-stream throughput.

>

> A one-bank 524,288-token YaRN configuration was verified on ds4-dfm-rs@ccd2d39. On the same DGX Spark and this Q5+Sidecar artifact, an HTTP request completed with 524,240 prompt tokens plus one generated token at 215.4 prefill tok/s and zero memory-census faults. This verifies near-full 512K execution, not long-context quality, multi-bank serving, MTP decode, or sustained throughput.

>

> Update 2026-09-04 — same-layout base-sibling reference: On one DGX Spark / GB10, the base Q5+Sidecar artifact measured 1,163.5 tok/s mean incremental prefill and 28.0 tok/s mean decode in a 32-frontier sweep on ds4-dfm-rs@a8fcd97, from 2K through 64K context in 2K steps with 128 greedy tokens per frontier. Embedded MTP draft 2 remained active without quenching, and prefill includes MTP prefix maintenance. This Uncensored artifact was not rerun in that sweep, so that sweep is a shared-runtime and layout reference rather than an artifact-specific result.

>

> Update 2026-09-06: three more prefill rounds on ds4-dfm-rs@974d706 (opening chunk, MoE glue traffic, one-pass block output; docs/qwen38-prefill-2026-09-06.md). Measured on this artifact on one DGX Spark with the production server shape (two banks, 196,608 context, --mtp-draft 2, three fresh workers per binary, thinking disabled, max_tokens 1): the 8,259-token repeated-passage prompt went 1372.1 → 1401.5 tok/s (+2.1%), the 7,937-token cold-PLE markdown prompt 1402.1 → 1476.7 tok/s (+5.3%) and the 8,036-token x-prompt 1557.0 → 1587.5 tok/s (+2.0%), main 0510117 before. The same-layout base sibling's cold single-shot ds4-bench prefill moved 1,214.8 → 1,362.1 tok/s at 8K (+12.1%) and 1,382.7 → 1,439.7 tok/s at 64K (+4.1%). Every adopted round is bit-identical to the kernels it replaces on the fixtures. See the 2026-09-06 campaign section below.

>

> Update 2026-09-06 (r4) — same-layout base-sibling reference: three further prefill rounds on ds4-dfm-rs@abdf25c (dense D2R for K=2560, HC-mix Q8 emit, o_proj K=6144). The base sibling's cold ds4-bench medians are 1,431.5 tok/s at 8K and 1,554.8 tok/s at 64K. The republished 2K–64K incremental sweep (MTP draft 2, aligned-Q8 owner, 2 GiB PLE cache) is 1,235.9 tok/s mean prefill and 28.4 tok/s mean decode. This Uncensored artifact was not rerun in that sweep; that sweep remains a shared-runtime and layout reference.

>

> Update 2026-09-07: three more prefill rounds on ds4-dfm-rs@6e036c4 (docs/qwen38-prefill-2026-09-07.md): SwiGLU quantized straight into the fused expert-down, a leaner fused QSA attention (four barriers per tile, conflict-free partial stores) and a batched SSD-PLE gather lease. Measured on this artifact on one DGX Spark with the production server shape (two banks, 196,608 context, --mtp-draft 2, three fresh workers per binary, thinking disabled, max_tokens 1): the 8,259-token repeated-passage prompt went 1,482.5 → 1,557.4 tok/s (+5.1%), the 7,937-token cold-PLE markdown prompt 1,546.3 → 1,651.4 tok/s (+6.8%) and the 8,036-token x-prompt 1,676.8 → 1,761.8 tok/s (+5.1%), with the 256-token greedy continuation and its MTP acceptance byte-identical before and after (30.6 / 30.6 tok/s), main ef37468 before. The same-layout base sibling's cold single-shot ds4-bench prefill moved 1,429.9 → 1,504.6 tok/s at 8K (+5.2%) and 1,557.2 → 1,648.4 tok/s at 64K (+5.9%); its 2K–64K incremental sweep is now 1,248.8 / 28.4 tok/s mean prefill / decode (base sibling only; this Uncensored artifact was not rerun in that sweep). Every round is bit-identical to the kernels it replaces. See the 2026-09-07 campaign section below.

> Update 2026-09-08 — FP8 PLE, measured on this Q5 artifact: the same 2K–64K card sweep with only the PLE sidecar changed measured 1,247.2 → 1,310.8 tok/s prefill (+5.1%), and 28.93 → 28.96 tok/s decode (+0.1%). Median of three run means per format, interleaved fresh processes on one DGX Spark; same main GGUF, binary, 2 GiB PLE cache, 16 workers and MTP draft 2. Automatic MTP quenching occurred in 0/3 BF16 and 0/3 FP8 runs; all samples are retained. Decode differences include generation and MTP policy effects. PLE files shrink from 95.37 to 47.68 GiB. Protocol, raw CSV and limits.

!BF16 and FP8 PLE paired 2K–64K throughput on Qwen3.8 Flash Next uncensored Q5

Measured on this artifact. Curves are per-frontier medians; bands are observed min–max over three runs. One warm session per process, 2,048-token incremental prefill and 128 greedy tokens per frontier; prefill includes MTP prefix maintenance.

Support my work

I work on making large language models practical on hardware they were never

really designed to fit on — through mixed quantization, inference

optimization, custom kernels, and serving experiments.

While much of the development happens on local hardware, calibration,

profiling, and large-scale validation often require expensive on-demand GPUs.

Contributions help pay for that compute, storage, and testing infrastructure,

so I can keep experimenting and publishing the results openly.

<a href="https://www.buymeacoffee.com/baekpica" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee" style="height: 60px !important;width: 217px !important;"></a> <a href="https://github.com/sponsors/Baekpica" target="_blank"><img src="https://img.shields.io/badge/Sponsor-EA4AAA?style=for-the-badge&logo=githubsponsors&logoColor=white" alt="Sponsor Baekpica on GitHub" style="height: 60px !important;width: 217px !important;"></a>

These measurements are reproducible with ds4-dfm-rs, a Rust-host continuation of DwarfStar for explicit, hardware-validated large-model inference on NVIDIA DGX Spark. It preserves the antirez → Entrpi → Baekpica lineage and integrates a growing set of model families with minimal abstraction while retaining the native CUDA/MMQ kernels.

Source and recipe pins

| Input | Pinned revision |

|---|---|

| Source checkpoint | orcarouter/Qwen3.8-Flash-Next-Uncensored@8336e61 |

| Public recipe reference | Baekpica/Qwen3.8-Flash-Next-Mixed-Quant-SSD-PLE-GGUF@95e1cdf |

The destination checkpoint has the same audited tensor topology as the recipe

source: 1,658 source tensors and 179,999,981,459 parameters. The released Q5

main map matches the public reference row for row: zero missing, extra, or

changed tensor recipes.

Choose a PLE sidecar: BF16 or FP8

Both sidecar variants are available in this repository. Select one with

hf download; the commands below download only PLE files.

| Sidecar | Directory | Embedding files | Scale |

|---|---|---:|---|

| BF16 | MQ-Q5-SSD-PLE-BF16/ple/ | 95.3682 GiB (4 files) | none |

| FP8 E4M3FN | PLE-FP8/ | 47.6841 GiB (4 files) | one shared BF16 scalar (2 bytes) |

BF16 sidecar:

qwen_repo=Baekpica/Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF
qwen_root=./Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF

hf download "$qwen_repo" \
  --include 'MQ-Q5-SSD-PLE-BF16/ple/*' \
  --local-dir "$qwen_root"
(cd "$qwen_root/MQ-Q5-SSD-PLE-BF16/ple" && sha256sum -c SHA256SUMS)

FP8 sidecar, including the required scale and manifest:

qwen_repo=Baekpica/Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF
qwen_root=./Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF

hf download "$qwen_repo" \
  --include 'PLE-FP8/*' \
  --local-dir "$qwen_root"
(cd "$qwen_root/PLE-FP8" && sha256sum -c SHA256SUMS)

To download the Q5 main GGUF only before selecting a sidecar:

hf download "$qwen_repo" \
  --include 'MQ-Q5-SSD-PLE-BF16/*.gguf' \
  --include 'MQ-Q5-SSD-PLE-BF16/SHA256SUMS.main' \
  --local-dir "$qwen_root"
(cd "$qwen_root/MQ-Q5-SSD-PLE-BF16" && sha256sum -c SHA256SUMS.main)

The FP8 PLE is extracted byte for byte from

Qwen/Qwen3.8-Flash-Next-FP8@236dfdf,

with all 128 embedding tensors and the original weight_scale preserved.

It uses 160-byte rows and one global BF16 scale; the scale is not a

128×128 block-scale array. See the format and extraction details.

FP8 runtime support is implemented in ds4-dfm-rs PR #22 and

validated with the existing main GGUFs. Use a build containing this change;

the published MQ-Q5-SSD-PLE-BF16 filenames and main GGUF metadata stay intact.

export DS4_QWEN_PLE_DIR="$(realpath "$qwen_root/PLE-FP8")"
# Run the existing ds4 / ds4-server / ds4-bench command with this environment.

The startup log must report dtype=FP8_E4M3FN. The runtime keeps FP8 pages in

the bounded cache and gathers the source-compatible scaled BF16 values for

the existing compute path. Unset the variable to use BF16. Use a separate

--kv-disk-dir for each main model and PLE format; cross-format snapshots are

rejected. See usage, exact numerical contract and validation.

The paired Q5 measurements above establish runtime throughput on their

workload; they do not establish BF16-equivalent task quality or FP8 256K/512K

throughput.

The separate BF16 Uncensored partial-fork fixture still has a token mismatch,

reproduced with the pre-PR runtime. The FP8 fixture passes; the linked guide

records both results without changing the existing fork/compute logic.

Download and verify

repo=Baekpica/Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF
root=./Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF
variant=MQ-Q5-SSD-PLE-BF16

hf download "$repo" \
  --include "$variant/*" \
  --local-dir "$root"

(cd "$root/$variant" && sha256sum -c SHA256SUMS)

The main GGUF is split into three files. The PLE sidecar is stored under

MQ-Q5-SSD-PLE-BF16/ple/ as four page-aligned files, so no local symlink or

second variant download is required.

Serve with ds4-dfm-rs

Build ds4-dfm-rs with make cuda-spark, then start the weight owner from that checkout and keep it running:

MODEL=/path/to/Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF/MQ-Q5-SSD-PLE-BF16/Qwen3.8-Flash-Next-Uncensored-MQ-Q5-SSD-PLE-BF16-00001-of-00003.gguf
MANIFEST=/tmp/qwen38-uncensored-q5.weights.manifest

CUDA_VISIBLE_DEVICES=0 ./ds4_weight_server \
  --base "$MODEL" \
  --manifest "$MANIFEST" \
  --backend vmm \
  --scope base \
  --reserve-gb 32 \
  --no-repack-iq2-aligned \
  --no-repack-q2k-aligned \
  --repack-q8-aligned

After the owner reports ready manifest=..., start the Rust-host worker in another terminal. This is the 196,608-context, two-bank Q5+Sidecar configuration used for the measurements above:

MODEL=/path/to/Qwen3.8-Flash-Next-Uncensored-Mixed-Quant-SSD-PLE-GGUF/MQ-Q5-SSD-PLE-BF16/Qwen3.8-Flash-Next-Uncensored-MQ-Q5-SSD-PLE-BF16-00001-of-00003.gguf
MANIFEST=/tmp/qwen38-uncensored-q5.weights.manifest
KV_DIR=./qwen38-uncensored-q5-kv
mkdir -p "$KV_DIR"

CUDA_VISIBLE_DEVICES=0 \
DS4_CUDA_WEIGHT_IPC_MANIFEST="$MANIFEST" \
DS4_CUDA_WEIGHT_IPC_SCOPE=base \
DS4_MEMGOV=observe \
DS4_SESSION_GRAPH_FIT=0 \
DS4_SESSION_GRAPH_HEADROOM_MB=0 \
DS4_QWEN_BATCH=1 \
DS4_QWEN_PREFILL_CHUNK=8192 \
DS4_QWEN_PLE_CACHE_MB=512 \
DS4_QWEN_PLE_WORKERS=16 \
DS4_SERVER_CONTINUOUS=1 \
DS4_SERVER_COALESCE_MAX=2 \
DS4_SERVER_COALESCE_MAX_TOKENS=16384 \
DS4_SERVER_COALESCE_WAIT_MS=20 \
DS4_SERVER_WARM=1 \
DS4_SERVER_FORK=1 \
DS4_SERVER_FORK_PARTIAL=1 \
./ds4-server --cuda -m "$MODEL" -c 196608 -n 32768 \
  --host 0.0.0.0 --port 8002 --cors \
  --model-id Qwen3.8-Flash-Next-Uncensored-Mixed-Quant \
  --mem-floor-gb 2 --mtp-draft 2 --no-update-check \
  --kv-disk-dir "$KV_DIR" --kv-disk-space-mb 32768

The example binds to all interfaces; use --host 127.0.0.1 unless remote access is intended. Keep the published ple/ directory beside the first GGUF shard.

For the verified 512K run, retain the same owner but use one worker bank with

-c 524288 -n 256 --cont-width 1, set DS4_QWEN_PREFILL_CHUNK=1024 and

DS4_SERVER_COALESCE_MAX=1, and set DS4_SERVER_WARM=0,

DS4_SERVER_FORK=0, and DS4_SERVER_FORK_PARTIAL=0. The run did not enable

--mtp-draft 2; the runtime selected static YaRN factor 2. Its 524,241 total

tokens finished 47 tokens below the configured context cap.

DS4_SESSION_GRAPH_FIT=0 remains an explicit fit-check override, not a

guarantee that the allocation fits.

Quantization recipe

| Model region | Target | Residency |

|---|---:|---|

| 51.2B-parameter PLE n-gram table, 128 logical parts | BF16 | SSD sidecar; bounded cache only |

| Routed expert gate/up, interior layers 2–45 | Q4_K | accelerator-resident |

| Routed expert gate/up, edge layers 0, 1, 46, 47 | Q5_K | accelerator-resident |

| Routed expert down, main 512 columns | Q5_K | accelerator-resident |

| Routed expert down, 128-column tail | Q5_0 | accelerator-resident |

| MTP routed experts and most always-active matrices | primarily Q8_0 | accelerator-resident |

| Hyper-connection, convolution, and vision tensors | BF16 where required | accelerator-resident |

| Norms, gates, recurrent/control state | F32 where required | accelerator-resident |

| Integer PLE controls | I64 | accelerator-resident |

Only the K-quant tiers from the original Q6 SSD-PLE map are lowered:

Q5_K → Q4_K for 88 tensors and Q6_K → Q5_K for 56 tensors. The 48

width-128 expert-down tails remain Q5_0, preserving the existing optimized

tail kernel and dispatch. There is no pruning, expert dropping, expert

merging, or layer dropping.

Audited storage metrics

| Metric | Value |

|---|---:|

| Main logical parameters | 128,799,735,699 |

| Main tensor count | 1,628 |

| Main tensor payload | 83,263,928,920 bytes / 77.5456 GiB |

| Main GGUF files | 83,274,984,448 bytes / 77.5559 GiB |

| Main effective BPW | 5.1717 |

| PLE parameters | 51,200,245,760 |

| PLE payload | 102,400,491,520 bytes / 95.3679 GiB |

| PLE physical files | 4 × 25,600,196,608 bytes |

| PLE file bytes including alignment | 102,400,786,432 bytes / 95.3682 GiB |

GGUF metadata/alignment, bounded PLE cache, KV state, and runtime workspace

are separate from the tensor-payload figures above.

Artifact layout

MQ-Q5-SSD-PLE-BF16/
├── Qwen3.8-Flash-Next-Uncensored-MQ-Q5-SSD-PLE-BF16-*.gguf
├── SHA256SUMS
├── SHA256SUMS.main
├── quant-recipe.yaml
├── artifact-manifest.json
├── main-artifact-manifest.json
├── verify-main-gguf.json
└── ple/
    ├── ple-bf16-00001-of-00004.bin
    ├── ple-bf16-00002-of-00004.bin
    ├── ple-bf16-00003-of-00004.bin
    ├── ple-bf16-00004-of-00004.bin
    ├── ple-manifest.json
    └── SHA256SUMS

Artifact verification

The included manifests and reports cover:

• source checkpoint revision and full local-file integrity;
• exact source tensor names, shapes, dtypes, shard membership, and parameter count;
• row-for-row equivalence with the public Q5 tensor recipe;
• exact equivalence of all 128 PLE logical parts, four physical-file layouts,

offsets, control values, and alignment rules;

• BF16 PLE extraction with per-part hashes and complete-file rereads;
• independent SHA-256 reads of all seven weight files;
• GGUF v3 metadata, split numbering, tensor names, shapes, types, offsets,

extents, byte counts, and payload bounds;

• remote Hub LFS byte counts and SHA-256 values after upload.

These are artifact-integrity checks. The DGX Spark Q5+Sidecar throughput

figures at the top of this card were re-benchmarked on this fine-tuned weight

set; full-window quality and sustained-concurrency results are not claimed.

SSD runtime contract

The 95.37 GiB PLE sidecar must not become resident in the accelerator's

unified-memory pool. The ds4 path expects exact CPU-side Qwen n-gram row

derivation, asynchronous SSD prefetch, a bounded pinned page cache, and mapped

UVA gather. Registering or unbounded-mapping the entire sidecar defeats the

artifact's residency objective.

Extended ds4 performance history, long-context tests, multimodal tests, and

runtime engineering notes remain on the

public reference model card.

This card reports the current Q5+Sidecar headline measurements and the exact

Rust-host serving configuration used for them.

2026-09-02 prefill optimization campaign (ds4-dfm-rs)

Five incremental rounds on ds4-dfm-rs

(d9f96a8 → 230655d), each measured against the previously adopted commit on

one NVIDIA DGX Spark with this MQ-Q5-SSD-PLE-BF16 artifact, the canonical

two-bank serving command (DS4_QWEN_BATCH=1, 8,192-token prefill chunks,

512 MiB PLE cache with 16 page workers, --mtp-draft 2, 196,608 configured

context), three fresh workers with fresh disk-KV directories per variant,

thinking disabled, max_tokens 1, and the API's timings.prefill_tok_s.

Two prompts were used: a 31,000-character prompt made of one 7,750-character

passage repeated four times (8,259 tokens; the last three copies hit the PLE

page cache, which reproduces the regime of the 2026-09-01 numbers above) and a

23,150-character markdown/code document (7,937 tokens) whose n-grams miss the

PLE cache, so ~6.5 s of its prefill is SSD page reads.

| Round | Change | Commit | 8,259-token repeated prompt (median of 3) | 7,937-token cold-PLE prompt (median of 3) |

|---|---|---|---:|---:|

| baseline | 81e2cfa | – | 556.2 tok/s | 417.6 tok/s |

| 1 | Q5_0/Q8_0 expert-down tail fused into the MMQ worklist kernel | d9f96a8 | 635.0 (+14.2%) | 452.6 (+8.4%) |

| 2 | shared expert gate/up/down on the MMQ tier (K=640 down as one fused-tail expert) | 6a3ae08 | 740.5 (+16.6%) | 503.5 (+11.2%) |

| 3 | counting-sort expert id maps (bit-identical) + redundant non-finite passes dropped | d575263 | 792.7 (+6.9%) | 520.0 (+3.3%) |

| 4 | Q5_K/Q8_0 gate/up on the compact worklist pair; PLE key/value and QSA k/v pairs on MMQ | 6e14b33 | 883.5 (+11.2%) | 591.7 (+13.8%) |

| 5 | hyper-connection rows converted to BF16 once | 230655d | 910.7 (+3.3%) | 597.1 (+0.6%) |

Cumulative: 556.2 → 910.7 tok/s (+63.7%) on the repeated prompt and

417.6 → 597.1 tok/s (+43.0%) on the cold-PLE prompt. Per-round percentages

are against the preceding round's rerun on the same day and are not additive

across days. Rounds 1–3 and 5 leave a 64-token greedy continuation of the

repeated prompt unchanged; round 4 changes it after the first ten tokens (both

continuations are coherent; the change tracks the PLE/QSA pairs moving from

Q8_0 DP4A kernels to the Q8_1-activation MMQ tier used by every other

projection, while the new Q5_K/Q8_0 worklist pairs are bit-identical to the

generic routed matmul on the fixture). A Linux-AIO rewrite of the PLE page

workers was measured and rejected (cold-PLE prompt 593 → 511 tok/s); the raw

NVMe sustains 53K–91K random 4 KiB IOPS at 16–64 threads, so the remaining

cold-PLE cost is a pipeline limit, not a device limit. Raw rows, scripts and

the nsys traces live in the campaign directory referenced from the repository

README.

2026-09-06 prefill campaign (ds4-dfm-rs)

Three more rounds on ds4-dfm-rs

(0510117 → 974d706, docs/qwen38-prefill-2026-09-06.md),

after the 2026-09-04 long-context rounds: the prompt's first prefill chunk

opens at 2,048 rows so the SSD-PLE reads of the full-size chunk behind it

overlap the opening chunk's decoder layers (7a5f872); the expert-down main

input is read in place from the SwiGLU rows and the routed gate/up activation

is quantized once per token instead of once per assignment slot (9696fd6);

the routed expert sum, the shared-expert sigmoid gate and the residual add

run as one pass (974d706). Each round is bit-identical to the kernels it

replaces on the fixtures. The rounds were developed and measured per round on

the same-layout base sibling (cold single-shot ds4-bench prefill on one DGX

Spark: 8,192 tokens 1,214.8 → 1,362.1 tok/s, +12.1%; 65,536 tokens 1,382.7 →

1,439.7 tok/s, +4.1%; 196,608 tokens 1297.5 → 1325.6 tok/s).

This artifact, owner swapped to it, same day: the production server shape

(the canonical two-bank command, 196,608 configured context, --mtp-draft 2,

three fresh workers with fresh disk-KV directories per binary, thinking

disabled, max_tokens 1, the API's timings.prefill_tok_s), the same prompts

as the 2026-09-02 table:

| binary | 8,259-token repeated prompt (median of 3) | 7,937-token cold-PLE markdown prompt (median of 3) | 8,036-token x-prompt (median of 3) |

|---|---:|---:|---:|

| 0510117 (before) | 1372.1 | 1402.1 | 1557.0 |

| 974d706 (after) | 1401.5 (+2.1%) | 1476.7 (+5.3%) | 1587.5 (+2.0%) |

Decode on the 8,259-token chat prompt with 256 greedy tokens and MTP draft 2:

30.7 → 31.7 tok/s; UNC_the continuation differs; with DS4_QWEN_PREFILL_OPENING=0 the new binary reproduces the old text, so the opening chunk's GEMM shapes, not the kernels, move a near-tie token.

Two attempts in the same campaign were measured and rejected: reading the

token-compact activation through a per-column map inside the MMQ tile

(gate/up kernel +22%, prefill −3%) and folding the weighted SwiGLU into the

up launch's store (bit-identical, but the scattered gate reads cost more than

the coalesced pass they replaced: cold 8K −0.7%).

2026-09-06 r4 (D2R, same-layout base-sibling reference)

Three further rounds on feature/qwen-prefill-opt-20260906-r4

(d9989bb / c00eacd / abdf25c) were measured on the base sibling:

dense D2R for K=2560, one HC-mix Q8 emit, o_proj K=6144. Cold

ds4-bench medians of three: 1,431.5 tok/s at 8K and **1,554.8 tok/s

at 64K**. The republished 2K–64K incremental sweep (MTP draft 2,

aligned-Q8 owner, 2 GiB PLE cache) is 1,235.9 tok/s mean prefill and

28.4 tok/s mean decode. This Uncensored artifact was not rerun in

that sweep.

2026-09-07 prefill campaign (ds4-dfm-rs)

Three more rounds on ds4-dfm-rs

(ef37468 → 6e036c4, docs/qwen38-prefill-2026-09-07.md):

the weighted SwiGLU quantized straight into the fused expert-down's Q8

operands (1273c68), a fused QSA attention with four barriers per tile and

conflict-free partial stores (30826d6), and an SSD-PLE gather that leases

16,384-row tiles under one store lock (6e036c4). The rounds were developed

and gated on the same-layout base sibling (cold single-shot ds4-bench,

same-hour off/on medians of three: 8K 1,429.9 → 1,504.6 tok/s cumulative,

+5.2%; 64K 1,557.2 → 1,648.4, +5.9%); every round is bit-identical to the

kernels it replaces.

Measured on this Uncensored artifact on the production server shape (the

canonical two-bank command, 196,608 configured context, --mtp-draft 2,

three fresh workers per binary, thinking disabled, max_tokens 1,

timings.prefill_tok_s), the same prompts as the earlier tables:

| binary | 8,259-token repeated prompt (median of 3) | 7,937-token cold-PLE markdown prompt (median of 3) | 8,036-token x-prompt (median of 3) |

|---|---:|---:|---:|

| ef37468 (before) | 1482.5 | 1546.3 | 1676.8 |

| 6e036c4 (after) | 1557.4 (+5.1%) | 1651.4 (+6.8%) | 1761.8 (+5.1%) |

Decode on the 8,259-token chat prompt with 256 greedy tokens and MTP draft

2: 30.6 → 30.6 tok/s, 1.63 tokens per step both, and the 256-token text is

byte-identical between the two binaries, as the kernels are.

The republished 2K–64K incremental sweep (base sibling, MTP draft 2, 2 GiB

PLE cache, aligned-Q8 owner) on 6e036c4 is **1,248.8 tok/s mean

prefill and 28.4 tok/s mean decode** (was 1,235.9 / 28.4);

this Uncensored artifact was not rerun in that sweep.

Reproduction

The converter, Q5/PLE plan builders, source-map port and audit tools,

quantizer source, pinned manifests, and verification reports are included in

the reproduction directory. Exact commands are documented

in reproduction/README-Uncensored-Q5.md.

License and behavior

The included LICENSE is the Qwen Community License 1.0 copied

from the pinned source checkpoint. This quantization does not add safety

training or change the behavioral intent of the source fine-tune; review the

source model card

before deployment.