library_name: starlight
pipeline_tag: text-generation
inference: false
license: other
license_name: qwen-community-1.0
license_link: LICENSE
base_model:

• Qwen/Qwen3.8-Flash-Next
• ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF
  base_model_relation: quantized
  tags:
• starlight
• qwen3.8
• moe
• quantized
• trellis-coded
• mtp
• abliterated
• amd
• nvidia

Qwen3.8-Flash-Next iq3_xxs_turbo_mini (abliterated) for Starlight

For Starlight only. This repository holds a model file made for one program, the inference engine Starlight. It is not a Transformers or Safetensors checkpoint, and it is not meant for llama.cpp, Ollama, LM Studio or any other program: other programs are neither supported nor tested.

The abliterated twin of iq3_xxs_turbo_mini: Qwen3.8-Flash-Next, a mixture-of-experts language model, as one 50.03 GiB file for Starlight. It is the plain file plus one 10 KB tensor, starlight.ablate_r, that makes the Starlight engine remove the refusal direction at run time; no weight differs from the plain file. The plain file is the iq3_xxs_turbo file with its per-layer token table coded smaller as well (15.65 GiB in place of 20.30 GiB). Like iq3_xxs_turbo, its routed experts are trellis-coded 2-bit experts (29.9 GiB in place of 40.0 GiB for iq3_s_turbo). The draft head for multi-token prediction (MTP) is inside the file, and the vocabulary is pruned to 141,312 tokens.

At a glance

What is different from the plain file

One tensor is added: starlight.ablate_r, the refusal direction (2,560 float32 numbers, 10 KB). The Starlight engine reads it when it loads the file and removes that direction, at run time, from what the 144 matrices that write into the residual stream produce: the expert and shared-expert down projections of the 48 main layers (48 + 48), the state-space output of the 36 linear-attention layers and the attention output of the 12 full-attention layers. Every weight in the file is byte for byte the plain file's; only the file's index and the new tensor were added.

Measured by the Starlight project on an RX 9070 XT, 9 November 2026, with the same engine build, prompts and seeds for both files, MTP on, a q4 attention cache:

As a check that the stored tensor does what the run-time setting does, this file was run against the plain file started with STARLIGHT_FN_ABLATE set to the same direction: all 139 greedy generations of the battery came out token for token the same, with the same finish reasons, and so did all 119 sampled generations (same seeds).

The graded battery measures capability, not style: 175 against 176 is one generation, which this test cannot tell from chance (it resolves a gap of about 3 to 4 points), and it says that the project found no loss on those 218 generations, not that the two files write the same text. The last two rows are within the run-to-run spread of this test (5 % and more between runs). For scale: in this engine a change that only alters rounding reads about 0.005 nats of KL against its own reference (three such changes measured by the project on the iq3_s_turbo file: 0.0052 to 0.0057), because the router among 512 experts flips near-ties; the KL above is of that size. The loss row is a small shift toward lower loss on this text (0.0072 nats per token, about 0.2 % of the mean loss of 3.46), beyond the noise of the test (z -3.4); it is one text, and the project does not read it as a quality gain. This file was run on the AMD card only; the NVIDIA engine has the same projection in its source, but this file has not been run on an NVIDIA card.

Which of the three files to choose

The two iq3_xxs files exist to save memory, not to be faster: in the first head-to-head test (RX 9070 XT, 2 November 2026; an early engine build) iq3_xxs_turbo decoded at 56.4 tokens per second against 59.6 for iq3_s_turbo, and read prompts about 10 % slower, while needing 10 GiB less RAM for the experts. The per-layer token table is a lookup (one row per token) that stays in system RAM or on disk, so "GPU side" is the part that has to fit on the card and in RAM together. If you have the memory, iq3_s_turbo is the closer file to BF16.

The name iq3_xxs_turbo is a class label, not a tensor type: in our measurements the file lands close to the published IQ3_XXS pack (a little behind on KLD, no clear difference on top-1, a little ahead on perplexity), while its experts are trellis-coded TQ2_T blocks of 2.125 bits per weight, not IQ3_XXS blocks.

What is inside

The table is the plain file's; the abliteration tensor adds 10,240 bytes.

The vocabulary is pruned from 248,320 to 141,312 tokens (141,148 real tokens and 164 padding entries); the 107,172 dropped tokens are removed from the model, and every kept token has the same text as in the original.

Memory and context window, as measured

Measured on 2 November 2026 through the Starlight Launcher with MTP (3 draft tokens), a q4 attention cache, 46 GiB of RAM locked and the whole cache on the card:

Both measurements were made with the plain file. The abliterated file has the same size to within 10 KB and uses the same memory.

Quality

Measured by the Starlight project against the published BF16 reference logits of the base model (jyohukuchan/qwen38-flash-next-bf16-logits): 12 text cases, 16,561 scored positions, Starlight engine on an RTX 5070 Ti, 2 November 2026. Lower KLD (mean KL divergence to BF16) and lower perplexity are better; top-1 is how often the file's most likely next token is the BF16 model's.

What the paired comparison on the same positions supports:

• The IQ3_S reference is clearly the closest to BF16 (KLD 0.065 below iq3_s_turbo, top-1 2.6 points higher), at 13 GiB more.
• iq3_s_turbo and the IQ3_XXS reference are tied (the KLD gap of 0.018 is within noise), and iq3_s_turbo is 6 GiB smaller.
• iq3_xxs_turbo has a KLD 0.034 higher than the IQ3_XXS reference (a real difference); top-1 does not clearly differ, and its perplexity is lower, though not clearly so.
• iq3_xxs_turbo_mini and iq3_xxs_turbo differ by 0.008 KLD, which is noise, and the mini file is 4.65 GiB smaller.

The engine's KL reading is about 2 % below an exact full-vocabulary calculation (checked on one case), so compare the rows with each other rather than with numbers published elsewhere.

The quality table was measured with the plain files (rows 4 and 5); the abliterated file differs from its plain twin only by the tensor described above.

About abliterated models

"Abliterated" means that the direction in the model's internal activations that carries refusals is removed. Requests that the original model would decline are answered. It is not a different or smarter model, and it has no content filter of its own: it will not warn, refuse or moderate.

In this file the direction is not edited into the weights. It is stored as one small tensor, starlight.ablate_r (2,560 numbers, 10 KB), and the Starlight engine removes it at run time from what the 144 matrices that write into the residual stream produce. Every weight is byte for byte the plain file's. A program that does not ask for this tensor never uses it, and everything else in the file is the plain file. When Starlight starts this file, its log says STARLIGHT_FN_ABLATE: writers projected off the direction in the GGUF tensor starlight.ablate_r.

• You are responsible for what you ask it and for what you do with its answers. Follow the law and the licence of the base model.
• Do not offer it to people who have not chosen an unfiltered model, and add your own safeguards where a use needs them.
• Everything the base model's card says about errors, bias and factual reliability still applies; removing refusals does not make answers more correct.

Pictures

The vision encoder is not inside this file. For picture input, put the separate vision file mmproj-Qwen3.8-Flash-Next-BF16.gguf (907,542,944 bytes, MD5 e95e4e6f9aa47c1c30519ba8d288b337) in the same folder as the model file; Starlight finds it by itself and uses it unchanged. It is published in ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF and is not part of this repository. Without it the model answers text only.

How to use

1. Download the file into the models folder of your Starlight installation:

   hf download feverdoingwork/Qwen3.8-Flash-Next-iq3_xxs_turbo_mini-abliterated-Starlight Qwen3.8-Flash-Next-abliterated-iq3_xxs_turbo_mini.starlight.gguf --local-dir <models folder>
   

2. Open the Starlight Launcher. Add the file to the Launcher's list with the entry under Launcher entry below (until a Launcher build lists it by itself); the Launcher then recognises the file by its MD5.

3. Choose your card and press Start. The Launcher starts the Starlight engine program for that card (AMD or NVIDIA) and serves the model on your own machine through an OpenAI-compatible HTTP interface.

Launcher entry

Until a Launcher build lists this file by itself, save the entry below as ~/.config/starlight-launcher/supported.json (if that file exists, add the entry to its models list) and restart the Launcher.

{
  "models": [
    {
      "id": "flash-iq3-xxs-turbo-mini-abl",
      "abl_of": "flash-iq3-xxs-turbo-mini",
      "group": "Flash",
      "family": "flash",
      "title": "Flash iq3_xxs_turbo_mini (abliterated)",
      "files": ["Qwen3.8-Flash-Next-abliterated-iq3_xxs_turbo_mini.starlight.gguf"],
      "size": 53714932416,
      "md5": ["3c7b835fbe2ba3696502f5c8cb2be9ee"],
      "min_cards": 1,
      "kv": ["q4"],
      "spec": ["mtp"],
      "needs": ["TQ2_T", "TQ3_K"],
      "note": "Qwen3.8-Flash-Next, ABLITERATED at run time (the file carries the direction as one 10 KB tensor; the engine removes it), with trellis-coded experts and a trellis-coded per-layer token table (50.0 GiB). One card of either maker: the experts that do not fit the card live in system RAM."
    }
  ]
}

Verify the download

echo "84fb2c951d0e5edf64d1d5439c782e8eba525d003ea86317e7cc0404a579feff  Qwen3.8-Flash-Next-abliterated-iq3_xxs_turbo_mini.starlight.gguf" | sha256sum --check

The same line is in SHA256SUMS. The Starlight Launcher knows the file by its MD5, 3c7b835fbe2ba3696502f5c8cb2be9ee.

Related files

All six are the same base model, packed for Starlight:

• feverdoingwork/Qwen3.8-Flash-Next-iq3_s_turbo-Starlight: 64.78 GiB, the base recipe.
• feverdoingwork/Qwen3.8-Flash-Next-iq3_s_turbo-abliterated-Starlight: the same file, abliterated in the weights.
• feverdoingwork/Qwen3.8-Flash-Next-iq3_xxs_turbo-Starlight: 54.68 GiB, trellis-coded experts.
• feverdoingwork/Qwen3.8-Flash-Next-iq3_xxs_turbo-abliterated-Starlight: the same file plus one tensor that makes the engine remove the refusal direction at run time.
• feverdoingwork/Qwen3.8-Flash-Next-iq3_xxs_turbo_mini-Starlight: 50.03 GiB, trellis-coded experts and a smaller token table.
• feverdoingwork/Qwen3.8-Flash-Next-iq3_xxs_turbo_mini-abliterated-Starlight: the same file plus one tensor that makes the engine remove the refusal direction at run time.

Limits

• Starlight only (see the notice at the top). Until a Launcher build lists this file by itself, it needs the entry under Launcher entry.
• Experts that do not fit on the card are read from system RAM. This file's experts take 29.9 GiB against 40.0 GiB for iq3_s_turbo. It was not measured on a 32 GB machine.
• Its quality is below iq3_s_turbo's on KLD (see the table above): choose it when memory, not quality, is the limit.
• Pictures need the separate vision file (see Pictures).
• The base model's own limits apply, and like every language model it can state wrong things with confidence.

License and credits

• Licence: Qwen Community License 1.0, the licence of the base model; the full text is in LICENSE. In short, as the licence says: keep its notice with every copy; if a commercial product or service has more than 100 million monthly active users or US$ 20 million in monthly revenue, the model name must be shown in its interface; and a Model-as-a-Service or AI Work Assistant business needs a separate licence from Qwen. Read the licence for the exact terms.
• Base model: Qwen3.8-Flash-Next by the Qwen team.
• Trellis-coded experts: the experts of the 48 main layers come from the Gyro-M release of AgentionAI (agentionai/Qwen3.8-Flash-Next-Gyro-GGUF, Qwen Community License). Gyro is AgentionAI's trellis-coded quantisation format (QTIP family); its format specification and reference decoder are Apache-2.0. Starlight reads the format with its own kernels. The file's header keeps one key of that format, agention.trellis.state_bits, which the engine reads; the other header text that named the source release has been rewritten to neutral words.
• Calibrated quantisation of everything else: the GSQ-RCO quantisation of ISTA-DASLab (ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), which the base file builds on.
• Abliteration direction, merging, recipe and the Starlight engine: the Starlight project.