license: other
license_name: qwen-community-1.0
license_link: https://huggingface.co/Qwen/Qwen3.8-Flash-Next/blob/main/LICENSE
base_model: orcarouter/Qwen3.8-Flash-Next-Uncensored
base_model_relation: quantized
tags:

• exl3
• exllamav3
• qwen4_exp
• moe
• uncensored
• dgx-spark
• veloGB10

Qwen3.8-Flash-Next-Uncensored — EXL3 3 bpw (Lygodactylus)

Original model: orcarouter/Qwen3.8-Flash-Next-Uncensored by orcarouter. This repository holds quantized (modified) weights of it; the original model card follows this one, verbatim.

What this pack is

• Quantized weights: Lygodactylus's EXL3 pack Lygodactylus/Qwen3.8-Flash-Next-Uncensored-exl3-3bpw (revision fe57295cac), redistributed byte-identical. Quantization by Lygodactylus with exllamav3.
• Model: orcarouter/Qwen3.8-Flash-Next-Uncensored by orcarouter, an uncensored derivative of Qwen/Qwen3.8-Flash-Next by the Qwen team (Qwen Community License 1.0).
• Nothing added by us. This repository is a mirror kept so that the veloGB10 test results and instructions have a stable reference.

Built for veloGB10

This pack is published primarily for the veloGB10 inference engine (gb10_inference) on one, two or four NVIDIA DGX Spark / GB10 machines: it is the pack we load, test and benchmark there, and the commands below are the ones it was tested with. The weights are standard EXL3 (ExLlamaV3) format, so any framework that reads the format can use them too.

Running it with veloGB10

Download a release binary of veloGB10 (one self-contained file; see its README), and the pack with hf download doth4580/Lygodactylus-FlashNext-Uncensored-3bpw --local-dir /path/to/Lygodactylus-FlashNext-Uncensored-3bpw. 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.

One GB10 (TP=1)

./gb10_inference --server \
  --model-dir /path/to/Lygodactylus-FlashNext-Uncensored-3bpw \
  --host 0.0.0.0 --port 9000 \
  --max-seq-len 262144 \
  --max-batch 2 \
  --max-tokens 65536 \
  --prefix-cache on \
  --mtp=auto

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/Lygodactylus-FlashNext-Uncensored-3bpw \
  --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/Lygodactylus-FlashNext-Uncensored-3bpw \
  --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.

Optional draft heads. Speculation uses the pack's own MTP head by default. Two replacement heads were also tested with this pack (numbers below): HermiHg's optimized head (HermiHg/Qwen3.8-Flash-Next-Optimized-MTP-Heads-exl3) and our DotH-MTP head (doth4580/Qwen3.8-Flash-Next-DotH-MTP-BF16); the DotH-MTP card explains how to add a head to a pack folder. A draft head changes speed only, never the output.

Measured with veloGB10

VeloBench runs against the served API on NVIDIA DGX Spark-class GB10 machines (2026-11-05, 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%.

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 — orcarouter/Qwen3.8-Flash-Next-Uncensored

Reproduced verbatim from the original repository (metadata header removed).

Qwen3.8-Flash-Next-Uncensored

The full-precision BF16 abliterated (refusal-removed) build of Qwen's Qwen3.8-Flash-Next — the source for fine-tuning & quantization

	🛡️ New from Orca — OrcaCyber Zero 1.5 Post-trained for cybersecurity: vulnerability analysis, vulnerability reproduction, red teaming & offensive-security research. 98.01% pass@1 on CyberGym Level 1 · 1M context · function calling · OpenAI-compatible API.
🔌 New from Orca — Orca Connect Serving this with vLLM? Orca Connect puts the rig under your desk behind your usual OrcaRouter API key, next to 200+ hosted models, reachable from a laptop, a phone or a cloud agent. Outbound only: no port forwarding, no tunnel, no firewall rule. Requests your own hardware serves cost $0, and orca-connect claude points Claude Code at your rig for one session.

One Gateway. Every Model. — Route Smarter · Ship Safer · Spend Less.

Website · Model Catalog · GitHub · Discord · X

The full-precision BF16 abliterated (refusal-removed) build of Qwen/Qwen3.8-Flash-Next — a ~180B Mixture-of-Experts (125B params / ~6B active), hybrid-attention, native vision-language model with flexible thinking, tool-calling, and an MTP head. These are the source weights from which the quantized releases are derived, and the recommended base for further fine-tuning / post-training and quantization — the full vision tower and MTP head are preserved.

Derived releases:  •  Qwen3.8-Flash-Next-Uncensored (BF16 source)  •  Qwen3.8-Flash-Next-Uncensored-FP8 (block-FP8, mirrors official)  •  Qwen3.8-Flash-Next-Uncensored-MLX (4 / 6 / 8-bit, Apple Silicon).

⚠️ Disclaimer — read before use

This model has had its safety alignment substantially removed via abliteration (orthogonalizing the
refusal direction out of the residual stream). As a direct consequence:

• It will comply with harmful, unethical, offensive, or illegal requests that the original
  Qwen3.8-Flash-Next would refuse. It has no meaningful built-in guardrails.
• It is released strictly for legitimate research — interpretability, AI-safety and refusal-mechanism
  study, red-teaming, robustness evaluation, and controlled experiments.
• You assume full responsibility and liability for how you use it and for everything it generates. Do
  not deploy it to end users or in production without adding your own safety, moderation, and
  abuse-prevention layers.
• Use must comply with the Apache 2.0 License inherited
  from the base model, and all laws and regulations that apply to you.
• The authors and uploaders accept no liability for any misuse or harm. Its outputs do not reflect
  the views of the uploaders or of Qwen / Alibaba.

By downloading or using this model you acknowledge and accept the above.

🐋 Run it with OrcaCode Review

Models are only half the system.

OrcaCode Review turns every model listed on
OrcaRouter into a production code-review agent:

• reviews every PR
• finds security + correctness issues
• posts inline findings
• P0/P1 can block merges
• swap models anytime

Open model. Open harness. Open bill.

• Website — https://www.orcarouter.ai
• GitHub — https://github.com/Continuum-AI-Corp/Orca-Code-Review

Model details

Abliteration

Refusal-direction removal following Arditi et al. (2024), Refusal in Language Models Is Mediated by a
Single Direction. A single refusal direction r (k = 1) is estimated from the block-input residual
stream (the 2560-d Hyper-Connections GR-Read output, where the refusal direction is linearly separable —
the widened 4-branch output_hidden_states smears it) as the massive-activation-masked mean-difference of
harmful − harmless activations, selected at layer 24 by a full 9-layer quality sweep
(harmful 0.00 / KL 0.085). r is then orthogonalized out of every residual-writing matrix —
W' = W − r(rᵀW) — computed in float32:

Preserved (never touched): the full vision + video tower (333 visual.* tensors), the MoE
router (mlp.gate), the fused experts.gate_up_proj reader, all Hyper-Connection mixers, the
QSA sparse-attention indexer, the n-gram embedding table, mtp.fc_*, norms, and lm_head. The MTP
head's residual writers are abliterated consistently so speculative decoding keeps working. Max residual
leakage after the edit: 0.0755 (float32 projection → bf16 storage).

This is a surgical weight edit — it changes ~0 general capability (see Evaluation) while collapsing
refusal behaviour.

Fine-tuning & post-training

This BF16 checkpoint is the recommended base for post-training — full precision, whole VL tower + MTP
head, a drop-in for Qwen/Qwen3.8-Flash-Next in the transformers / Qwen4ExpForConditionalGeneration
stack (needs transformers 5.16+).

• SFT / DPO / RL work as on the base model (full-FT or LoRA/QLoRA).
• Re-quantization: quantize from these weights to FP8 / MLX / etc. (this is exactly how the derived
  releases were produced).
• Note: abliteration is a weight edit, not data-level unlearning. Fine-tuning on refusal-heavy /
  safety data can partially re-introduce refusals; neutral / task data preserves the uncensored behaviour.

Intended use

• Research into refusal mechanisms, alignment, and interpretability.
• Red-teaming and safety / robustness evaluation in controlled environments.
• A full-precision base for further fine-tuning, post-training, and quantization.

Evaluation

Measured on these exact weights served with vLLM (day-0 qwen4_exp image), against the official Qwen/Qwen3.8-Flash-Next served identically with the same scripts and settings. Full BF16. Refusal is judged by a rule-based opening-phrase classifier (caveat = answered but wrapped in a disclaimer) — indicative, not an LLM-judge / publication-grade number. Thinking is off unless stated.

Safety — harmful-prompt refusal, thinking OFF (lower = more uncensored)

Safety — harmful-prompt refusal, thinking ON (enable_thinking=true)

Judged on the final answer (text after </think>; responses truncated before a final answer are excluded):

Over-refusal — benign prompts wrongly refused (lower = better)

Capability retention — vs the official base (same scripts, same settings)

Verified working on this build: tool-calling ✅, vision/OCR ✅ 6/6, reasoning ✅. The vision + video tower is preserved byte-for-byte (333 visual.* tensors in BF16), so it remains a full vision-language model — a drop-in for the base.

Usage — self-host with vLLM (OpenAI-compatible)

qwen4_exp needs the day-0 vLLM image and transformers 5.16+.

docker run -d --name flashnext --gpus all --ipc host -p 8000:8000 \
  -v /path/to/Qwen3.8-Flash-Next-Uncensored:/model \
  vllm/vllm-openai:qwen38-flash-next-x86_64-cu130 \
  --model /model --served-model-name Qwen3.8-Flash-Next-Uncensored \
  --tensor-parallel-size 8 --trust-remote-code --max-model-len 262144 \
  --enable-expert-parallel --enable-auto-tool-choice --tool-call-parser qwen3_coder

--enable-expert-parallel is required for the FP8 build (MoE intermediate 640 ÷ TP is not divisible by the FP8 block 128 without it); it is harmless for BF16. Tool calls use the Qwen3-Coder XML format (--tool-call-parser qwen3_coder). Toggle reasoning per
request with chat_template_kwargs={"enable_thinking": true|false}; pass image_url content parts for
vision.

Bias, risks, and limitations

• Safety guardrails removed — the model will produce harmful, biased, or offensive content on request
  (see the disclaimer).
• It inherits any biases and limitations of the base Qwen3.8-Flash-Next.
• The reported refusal metric is a rule-based heuristic; evaluate rigorously for your own use case.

License

Apache 2.0, inherited from the base model
Qwen/Qwen3.8-Flash-Next. Abliteration does not change
the underlying license obligations.