license: other
license_name: qwen-community-1.0
base_model:

• orcarouter/Qwen3.8-Flash-Next-Uncensored
• Qwen/Qwen3.8-Flash-Next
  base_model_relation: quantized
  pipeline_tag: text-generation
  library_name: gguf
  tags:
• gguf
• rocmfp4
• imatrix
• qwen4exp
• llama.cpp
• strix-halo
• gfx1151
• rocm
• amd
• ryzen-ai-max
• uncensored
• research

🔧 Runtime: build the ROCmFPX fork below

Stock llama.cpp will not load this file. You need both the qwen4exp architecture
and the ROCmFP4 tensor types in one tree. Upstream
charlie12345/ROCmFPX has the ROCmFP4 types but
not qwen4exp. Our fork has both:

kingjones30/ROCmFPX — a fork of charlie12345/ROCmFPX, branch main.

git clone https://github.com/kingjones30/ROCmFPX.git
cd ROCmFPX
cmake -B build -DGGML_HIP=ON -DGPU_TARGETS=gfx1151 -DGGML_NATIVE=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --target llama-server llama-quantize -j$(nproc)

Qwen3.8-Flash-Next-Uncensored — ROCmFP4 FAST imatrix GGUF — AMD Ryzen AI Max+ 395 / gfx1151

The importance-matrix-calibrated FAST build. Same recipe, same 4-bit size, same speed as the
plain FAST build
— measurably lower perplexity because quantization was weighted by a calibrated importance matrix.

⚠️ Research artifact. Refusal behaviour has been removed. This does not add capability — it
removes guardrails. Use it deliberately, in a context where that is appropriate, and own the output.

Measured quality — held-out WikiText-2 raw, -c 512

Both files are the same 4-bit recipe at 87.9 GiB / 4.27 bpw — the only difference is that this
one's quantization was importance-weighted. imatrix moves quality, not speed: decode t/s is
identical (same bits per weight), so this is graded on perplexity, not tok/s.

• Calibration corpus: bartowski
  calibration_datav3.
• ⚠️ The imatrix was computed on the 4-bit model, not BF16 — the 51.2B PLE table plus the
  128 GB GTT ceiling blocks a BF16 forward pass on Strix Halo. A higher-precision imatrix source
  would likely gain a little more. It is still a real, measured −5.9%.

For reference: dropping the protected Q6_K head to a fully 4-bit head costs only +1.5% PPL
(measured 5.1075 with imatrix) — small, now that imatrix calibration absorbs most of the head
damage. This build keeps the protected Q6_K head.

Speculative decoding (MTP) — now working on this arch

The qwen4exp MTP graph shipped with a broken combiner (it mean-pooled the hyper-connection
streams); draft-mtp acceptance sat near 0.36. This repo ships the fix as
qwen4exp-mtp-graph.patch — apply it to the fork above and rebuild.
With it, plus the stock Flash-Next MTP head from
kingjones777/Qwen3.8-Flash-Next-MTP-Heads-GGUF:

• acceptance 0.94, 31.80 tok/s with --spec-type draft-mtp vs 24.9 tok/s no-draft
  (+27.7%) — warm 160-token completion, neutral prompt, cache_prompt:false, same box/binary.

The bundled MTP head is stock Flash-Next (not uncensored). It only proposes draft tokens; the
main model verifies every one, so it never alters this model's output — it just makes generation
faster on content it can predict. Without the patch, plain decode is unaffected; only draft-mtp
needs it.

llama-server -m Qwen3.8-Flash-Next-Uncensored-Q4_0-ROCmFP4-FAST-imatrix-00001-of-00003.gguf \
  -md mtp-Qwen3.8-Flash-Next-Q6_K.gguf --spec-type draft-mtp \
  --spec-draft-n-min 2 --spec-draft-n-max 4 --n-gpu-layers-draft 99 \
  -ngl 999 -fa on -np 1 -c 131072 --jinja

⛔ ngram-mod at ≥64K can wedge the GPU

--spec-type ngram-mod is fine at 32K but at ≥64K a context-checkpoint restore desyncs the QSA
indexer cache from the KV caches and wedges the SDMA queue (Ring sdma0 reset failure, hard
power-off to recover). Field report by
@liusecret on
…-STRIX-GGUF#6.
Workaround (no new binary): -ctxcp 0 -cpent -1. draft-mtp above is unaffected by this.

Recipe

Quantized from the BF16 weights published by
orcarouter/Qwen3.8-Flash-Next-Uncensored
— the abliteration work is theirs, not mine. Go star their repo.

The Q6_K head: output.weight is Q6_K, never 4-bit. Every sampled token passes through the lm
head, so its quantization error lands directly in the argmax. Verified by exact tensor name
after both quantize and split. With imatrix, a fully 4-bit head costs only +1.5% PPL (measured);
the Q6_K head here keeps that last 1.5%.

Building a runtime that loads these files

Two patches, both in this repo: qwen4exp-on-rocmfpx-d3ca537.patch (arch enablement, 156 KB) and
qwen4exp-mtp-graph.patch (draft-mtp fix).

git clone https://github.com/charlie12345/ROCmFPX.git
cd ROCmFPX && git checkout d3ca537
curl -LO https://huggingface.co/kingjones777/Qwen3.8-Flash-Next-Uncensored-ROCmFP4-FAST-imatrix-GGUF/resolve/main/qwen4exp-on-rocmfpx-d3ca537.patch
git apply qwen4exp-on-rocmfpx-d3ca537.patch
curl -LO https://huggingface.co/kingjones777/Qwen3.8-Flash-Next-Uncensored-ROCmFP4-FAST-imatrix-GGUF/resolve/main/qwen4exp-mtp-graph.patch   # optional, for draft-mtp
git apply qwen4exp-mtp-graph.patch
cmake -B build -DGGML_HIP=ON -DGPU_TARGETS=gfx1151 -DGGML_NATIVE=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --target llama-server llama-quantize -j$(nproc)

Speed — Ryzen AI MAX+ 395, gfx1151, ROCm 7.2.4, full offload

Decode speed is identical to the plain FAST build (same bits, same layout) — measured there at
22.75 tok/s gen / 387.3 tok/s prompt / 63.3 GiB GTT (one fixed 6,963-token prompt,
cache_prompt:false, median of 4 settled samples). This model's native max context is 262,144
and it runs there on a 128 GB box; the window is cheap (QSA caps KV), depth is what costs.

Files

Sharded to stay under HF's 50 GB limit. Point --model at the first shard.

Usage

llama-server \
  --model Qwen3.8-Flash-Next-Uncensored-Q4_0-ROCmFP4-FAST-imatrix-00001-of-00003.gguf \
  --mmproj mmproj-Qwen3.8-Flash-Next-Uncensored-BF16.gguf \
  --host 127.0.0.1 --port 8080 \
  --n-gpu-layers 999 --flash-attn on --fit off \
  --ctx-size 131072 --threads 16 --jinja

Do not use --no-mmap (and do not use -dio). The PLE table is streamed from the file through
the page cache; forcing it into anonymous memory gets the process OOM-killed with nothing in the
server log.

Reproduction

imatrix : llama-imatrix -f calibration_datav3.txt -o unc.imatrix --output-format dat -ngl 999 -c 512 -b 512 -fa on -dev ROCm0
quantize: llama-quantize --imatrix unc.imatrix --output-tensor-type q6_K <BF16> <out> Q4_0_ROCMFP4_FAST 16
ppl     : llama-perplexity -m <this> -f wiki.test.raw -ngl 999 -fa on -dev ROCm0 -c 512   (NO -dio)

A number without its binary is a rumour — every figure above is measured on the runtime above.

Acknowledgements

charlie12345/ROCmFPX — defines the ROCmFP4 tensor
formats; every file here was produced with its llama-quantize and runs on its runtime. MIT.
The qwen4exp architecture is applied on top via the bundled patches.
llama.cpp — engine, GGUF format, conversion tooling.
AMD ROCm — the compute platform (ROCm 7.2.4, gfx1151).
orcarouter — published the uncensored BF16 checkpoint this
is built from; the abliteration is their engineering.
Qwen team — the original base model. License qwen-community-1.0.