license: apache-2.0
base_model: SC117/Qwen3.8-Flash-Next-GSQ-RCO-abliterated-GGUF
library_name: strata
tags:

• strata
• gguf
• quantized
• abliterated
• uncensored
• moe

Qwen3.8-Flash-Next · GSQ-RCO-abliterated IQ3_S — prebuilt Strata pack

SC117/Qwen3.8-Flash-Next-GSQ-RCO-abliterated-GGUF is already a Strata-ready GGUF, but Strata
still needs a pack (dense tensors + tensor index + tokenizer) built from it — and that step is
exactly where people get stuck. The source card says it plainly:

"changing only the GGUF paths is not enough, --pack must point to a pack built from this repository's GGUF files"

This repository is that pack — complete and verified except for dense.bin (1.5 GB), which is
still being uploaded from a slow uplink. Until it appears, you lose nothing: build it yourself in
9 seconds from the same GGUF (see Build dense.bin yourself below) and check the result against
the sha256 published here. Everything else the pack needs is already in this repository.

This is not the model. It is ~1.5 GB of dense weights plus the index into the GGUFs; your copy
of the two shards stays wherever your downloader put it and is read directly by the engine.

What you need

The pack is keyed to the tensor offsets of one revision. If upstream re-uploads the GGUF, this
pack stops matching and the engine exits with
ArenaExpertSource: the pack's native_experts.txt does not match the model — then rebuild with
tools/iq_pack.py, or ask for an updated pack.

Verified input (checked byte-for-byte on the box this pack was built)

What is in this repository

pack/
  dense.bin               1,538,035,200 B   the small float tensors  (uploading — build it yourself meanwhile, see below)
  index.txt                      93,697 B   1,079 tensors, 302 served natively
  native_experts.txt              3,316 B   expert offsets, bound to shard 00001
  conversions.json                  346 B
  tokenizer/                                vocab.json, merges.txt, chat_template.jinja, …
  *.sha256ok                                one hash per file (same layout as other Strata packs)
strata-config.example.json                  fill in five paths and run

Pack hashes (also shipped as *.sha256ok beside each file):

Build dense.bin yourself (9 seconds, no 1.5 GB download)

The pack's only large file is a pure function of the GGUF: the packer copies the small float tensors
and skips the experts, so anyone with the two shards rebuilds it byte-identically.

cd <your Strata checkout>
STRATA_GGUF_PY=C:/path/to/Strata/third_party/llama.cpp/gguf-py \
  .venv/Scripts/python.exe tools/iq_pack.py --gguf "<path to shard 00001>" --out "<empty folder>"

That writes dense.bin, index.txt, native_experts.txt, conversions.json and tokenizer/.
Check dense.bin against the sha256 listed above (d2af3d83…): if it matches, your pack is byte-identical
to this one. index.txt, native_experts.txt and tokenizer/ are already in this repository — either
copy them from here or keep the ones you just built (same bytes, hashes above).

How to run it

1. Keep both GGUF shards in one folder with their original filenames (the engine finds shard 2 beside shard 1).
2. Put pack/ anywhere (any drive) — it does not have to sit next to the GGUFs.
3. Copy strata-config.example.json and fill in five paths:
   --pack → …/pack, --native → shard 00001, --ple-gguf → shard 00002,
   tokenizer → …/pack/tokenizer, --mtp → the strata/rt folder from the model repo
   (mtp-q2_0.gguf + strata/rt/*; see the caveat below if you use another build's MTP).
4. Start it from your Strata checkout:

.venv\Scripts\python.exe -u serve\server.py --engine strata --config "C:\path\to\strata-config.json" --port 8080

First load takes a few minutes; the engine prints its progress and then serves
http://127.0.0.1:8080/ (web UI) and http://127.0.0.1:8080/v1 (OpenAI-compatible, model alias
rvn / strata). Do not use --compat-bf16 — that flag is for ordinary (non-GSQ-RCO)
quantizations and would dequantize the small projections this layout keeps at BF16/Q8_0.

Measured on the reference box (RTX 3060 12 GB + GTX 1080 Ti 11 GB, i7-9700K, 64 GB)

Numbers are this hardware's; a 3090 or a different split will differ. Note that the first few
answers after a start are slower while the expert cache warms, and decode speed is a function of
how much context is in front of it.

Caveats

• Never reuse another model's pack. A pack describes one model's tensor offsets; the engine
  refuses a mismatched native_experts.txt.
• The MTP draft head is base-derived and NOT abliterated in this family. The repo's strata/rt
  (built with mtp-q2_0.gguf) is the matching one. A draft head from another build still loads —
  a proposed draft is kept only when it equals the token the model itself sampled, so output
  content is unaffected; you may just see a lower draft-acceptance rate.
• This model is abliterated (refusal direction removed) with no built-in guardrails: its own
  card warns to supply your own moderation, access control and legal review. The edit is an
  aggressive all-layer one (orcarouter lineage). Independent measurements of that family report
  reduced multi-step agent persistence — judge it on your own workload.
• The quantization scheme, not the nominal tier, carries the quality: this is GSQ (learned grid +
  scale) with RCO budget assignment, transplanted with orcarouter's abliterated tensors by SC117
  with every GSQ value and scale left untouched. Per-tensor hashes are in the source repo.

Attribution and licence

Apache-2.0 throughout, with attribution to every upstream (the Qwen base carries its own community
licence):

• Base model — Qwen / Qwen3.8-Flash-Next (Alibaba)
• Quantization — ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF — GSQ + RCO
• Abliterated tensors — orcarouter/Qwen3.8-Flash-Next-Uncensored-GGUF (144 tensors, transplanted)
• The abliterated GSQ-RCO build — SC117/Qwen3.8-Flash-Next-GSQ-RCO-abliterated-GGUF
• The pack — built with tools/iq_pack.py from that repo's GGUF at the revision above.

日本語の説明は README.ja.md にあります。