Instructions to use orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8")
model = AutoModelForMultimodalLM.from_pretrained("orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8

SGLang

How to use orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8 with Docker Model Runner:
```
docker model run hf.co/orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8
```

You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Qwen3.8-Flash-Next-Uncensored-FP8

An abliterated (refusal-removed) & offline block-FP8 build of Qwen's Qwen3.8-Flash-Next

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

Website · Model Catalog · GitHub · Discord · X

An abliterated and offline block-FP8 quantized build of Qwen/Qwen3.8-Flash-Next. It removes the safety refusal direction, then re-quantizes to the exact FP8 scheme of the official Qwen/Qwen3.8-Flash-Next-FP8 so it serves with the identical vLLM kernel path — 262K context, tools + reasoning + MTP + vision 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


Base model	`Qwen/Qwen3.8-Flash-Next`
Architecture	`Qwen4ExpForConditionalGeneration` (`qwen4_exp`, Qwen4 preview) — 48 layers, hidden 2560, hybrid attention (36 Gated-DeltaNet linear + 12 full-attention, interval 4), 512 fused experts, top-10 + shared expert, 51B-param PLE n-gram embedding, Hyper-Connections residual, native vision + video tower, and an MTP speculative-decoding head
Modification	Abliteration (refusal-direction removal) then offline block-FP8 quantization
Quantization	Block-FP8 (E4M3), `weight_block_size [128,128]`, dynamic activations — mirrors official byte-for-byte in scheme
Format	safetensors, ~186 GB, 131 shards (152,089 tensors; 75,264 FP8)
Preserved	Full vision + video tower and MTP head (drop-in for the base)
Context	262,144 tokens

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:

Component	matrices edited
`self_attn.o_proj` (12 full-attention layers + MTP)	13
`linear_attn.out_proj` (36 GDN linear-attention layers)	36
`mlp.experts.down_proj` (fused 3D, all 512 experts × 49 layers)	49
`mlp.shared_expert.down_proj`	49
`ple.value_proj` + `embed_tokens` (row space)	2
Total residual-writer tensors	149

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.

Offline block-FP8 quantization scheme

Quantization is done offline on the abliterated BF16 weights, reproducing the official Qwen/Qwen3.8-Flash-Next-FP8 recipe exactly:

What is quantized: only the 512 routed-expert projections (experts.{e}.down/gate/up_proj), stored un-fused per expert as float8_e4m3fn + weight_scale_inv (BF16) in 128×128 blocks — 75,264 tensors, matching the official checkpoint tensor-for-tensor.
The abliterated BF16 keeps experts fused 3D (experts.down_proj [512,2560,640], experts.gate_up_proj [512,1280,2560]); the quantizer un-fuses them to the official per-expert layout (down = slice; gate/up = split of gate_up at 640) before block-quantizing.
Activations: per-token dynamic FP8 — no calibration set.
Kept in BF16 (modules_to_not_convert): attention / linear_attn, shared_expert, mlp.gate, Hyper-Connection mixers, embeddings, lm_head, MTP, and the whole vision tower.
The 51B-param n-gram table is reused byte-for-byte from the official FP8 (it is bit-identical to the base — abliteration does not touch it), so the checkpoint matches the official FP8 exactly.
Verified vs the official FP8: block scales reproduce the official weights exactly (scale_relerr = 0); FP8 codes match to sub-ULP rounding.

vLLM therefore serves this build with the same block-scaled FP8 kernel as the official checkpoint, with the same MTP speculative decoding.

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. FP8 (block-FP8 weights + dynamic FP8 activations). 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)

Benchmark	n	Base	This model	Caveat (this)
AdvBench	100	100.0%	2.0%	54.0%
JailbreakBench (harmful)	100	94.0%	0.0%	52.0%
StrongREJECT	150	99.3%	1.3%	58.0%
HarmBench (standard)	150	100.0%	1.3%	48.7%
MaliciousInstruct	100	98.0%	0.0%	50.0%
SimpleSafetyTests	50	64.0%	2.0%	72.0%
ForbiddenQuestions	150	75.3%	2.7%	60.0%
Custom probes (zh/en)	11	63.6%	0.0%	36.4%

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

Benchmark	n	Base	This model
AdvBench	100	7.0%	0.0%
JailbreakBench (harmful)	100	5.0%	0.0%
StrongREJECT	150	2.0%	0.0%
HarmBench (standard)	150	2.0%	0.0%
MaliciousInstruct	100	1.0%	0.0%
SimpleSafetyTests	50	4.0%	0.0%
ForbiddenQuestions	150	0.7%	0.0%
Custom probes (zh/en)	11	9.1%	0.0%

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

Benchmark	n	Base (no-think / think)	This model (no-think / think)
XSTest-safe	250	9.6% / 0.4%	1.2% / 0.4%

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

Benchmark	n	Base	This model	Δ
MMLU (0-shot letter)	300	90.0%	88.0%	-2.0
MMLU-Pro (CoT)	400	77.8%	76.5%	-1.2
GSM8K (CoT)	150	92.0%	90.7%	-1.3
CMMLU (0-shot, Chinese)	500	81.8%	81.2%	-0.6

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-FP8:/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.

Downloads last month: -

Safetensors

Model size

180B params

Tensor type

BF16

F8_E4M3

I64

Model tree for orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8

Base model

Qwen/Qwen3.8-Flash-Next

Quantized

(92)

this model

Collection including orcarouter/Qwen3.8-Flash-Next-Uncensored-FP8

Qwen3.8 Flash Next Uncensored / Abliterated

Collection

5 items • Updated 24 minutes ago • 2