Qwen 3.8 27B Uncensored GGUF: the Abliterated Local Build, 12 Quants, and the Research-Only Boundary

Qwen 3.8 27B uncensored GGUF is a real download, and the build to start with is Qwen3.8-27B-Uncensored-GGUF — published on Hugging Face on August 16, 2026 as the llama.cpp-native sibling of our abliterated FP8 release. It is the same refusal-removed 27-billion-parameter weights as Qwen3.8-27B-Uncensored-FP8, converted to GGUF for local inference: F16 plus 12 quantization tiers from Q2_K to Q8_0 (including the imatrix quants IQ3_M and IQ4_XS), the 262K context window, a separate vision projector, and the MTP speculative-decoding head intact. "Uncensored" means abliterated — the refusal direction was orthogonalized out of the weights — so it will answer where the aligned base refuses, and that is exactly why it is research-only. Here is what the repo actually contains, which quant fits your GPU, how to run it in llama.cpp, and the safety boundary you accept by downloading it.

The 30-second version: F16 plus 12 quants, Q4_K_M at 16.8 GB is the default pick, you need a llama.cpp build from May 2026 or newer, and this is a research tool with no guardrails — not something to deploy to end users.

What "uncensored GGUF" actually means — and how this build differs from the FP8 version

GGUF is the single-file model format llama.cpp uses; FP8 is a quantization scheme that runs on vLLM GPU servers. Our two uncensored releases are the same abliterated weights in two runtimes. Qwen3.8-27B-Uncensored-FP8 (August 15, 2026) targets vLLM on a server, re-quantized to the official Qwen3.8-27B-FP8 scheme so it serves on the identical kernel path. Qwen3.8-27B-Uncensored-GGUF (August 16, 2026) targets llama.cpp on a local machine — the desktop GPU or workstation you control. Same weights, different deployment model: cloud API vs local process.

Abliteration is a weight-level intervention, not a fine-tune. The refusal direction is a vector in the model's residual stream that, when activated, produces "I can't help with that"; the build finds that direction and orthogonalizes it out of the weights, following the approach of Arditi et al. 2024 ("Refusal in Language Models Is Mediated by a Single Direction"). No new weights are trained. The base is Qwen/Qwen3.8-27B — a dense 27B model with a hybrid architecture (48 Gated DeltaNet linear-attention layers and 16 full-attention layers), native vision, and a 262,144-token context. The license is Apache 2.0, inherited from the base. Note that Qwen's official repo ships BF16 safetensors only — there is no official Qwen GGUF — so any uncensored GGUF of this model, including this one, is a conversion of the open weights.

The quant ladder — F16 plus 12 tiers

The repo ships F16 (54.6 GB across two files) and 12 quantization tiers. Sizes below are the repo's own file sizes, read August 16, 2026; GGUF file sizes vary slightly from build to build.

• F16 — 54.6 GB (2 files) — reference precision

• Q8_0 — 29.0 GB — near-lossless, for high-end GPUs

• Q6_K — 22.4 GB — the quality-per-gigabyte sweet spot

• Q5_K_M — 19.5 GB / Q5_K_S — 19.0 GB — high quality on larger cards

• Q4_K_M — 16.8 GB — the recommended default

• Q4_K_S — 15.8 GB

• IQ4_XS — 15.3 GB — the best low-bit pick (imatrix-calibrated)

• Q3_K_L — 14.6 GB / Q3_K_M — 13.5 GB — for 16 GB cards

• IQ3_M — 12.8 GB — small footprint (imatrix-calibrated)

• Q3_K_S — 12.3 GB

• Q2_K — 10.9 GB — the smallest K-quant, a visible quality compromise

Hardware guidance: Q4_K_M on a 24 GB card (RTX 4090 or RTX 3090); IQ4_XS or Q3_K_M if you are on 16 GB; Q2_K only if you are squeezed to 12 GB. Because the base uses hybrid Gated DeltaNet attention, the KV cache is small — roughly 0.5 GB at 8K context — so you can push the window far higher than a conventional 27B dense model. Vision adds one separate file: the F16 projector is 931 MB. A 9-quant community abliterated series for the same base also exists; ours is the conversion of the documented FP8 abliteration, with the imatrix quants and the model card's refusal-delta numbers carried over.

How to run it in llama.cpp

Three steps. One non-obvious requirement: the qwen35 architecture and MTP support landed in llama.cpp in May 2026, so update to a build from 2026-05 or newer — older builds will not load these files (per the repo README).

1. Download the quant you chose plus the vision projector. The repo is gated, so you log in to Hugging Face and accept the conditions first — reading the README is part of accepting what this model is.

huggingface-cli download orcarouter/Qwen3.8-27B-Uncensored-GGUF --include "Qwen3.8-27B-Uncensored-Q4_K_M.gguf" "mmproj-Qwen3.8-27B-Uncensored-f16.gguf" --local-dir ./qwen-unc

2. Start llama-server. This serves an OpenAI-compatible endpoint; -ngl 99/ offloads every layer to the GPU.

llama-server -m ./qwen-unc/Qwen3.8-27B-Uncensored-Q4_K_M.gguf --mmproj ./qwen-unc/mmproj-Qwen3.8-27B-Uncensored-f16.gguf -ngl 99 -c 16384 --jinja --host 0.0.0.0 --port 8080

3. (Optional) enable the MTP speculative-decoding head. Add --spec-type draft-mtp/ — the nextn head is embedded in every quant, so no separate draft model is needed.

Text-only research runs can drop --mmproj/; image input needs it, because this is a native vision-language model. The endpoint is http://localhost:8080/v1/chat/completions, so existing OpenAI SDK code works with a base-URL swap.

No GPU? The same uncensored line is hosted

Local GGUF costs nothing per token but needs roughly 17 GB of VRAM for the Q4_K_M tier. If you do not own the hardware, the hosted card obsidian/Qwen3.8-27B on OrcaRouter serves the same uncensored 27B line — vision, reasoning, 262K context — at $0.40 per million input tokens and $4.21 per million output, with access gated to security researchers, red teams, and AI-safety researchers. Same family of weights, two runtimes: GGUF locally, FP8 in the cloud. The moderation decision stays on your side either way.

The safety boundary — read this before you download

This model has had its safety alignment substantially removed. It will comply with harmful, unethical, offensive, or illegal requests that the base Qwen3.8-27B would refuse, and it has no meaningful built-in guardrails. It is released strictly for legitimate research — interpretability, refusal-mechanism study, red-teaming, robustness evaluation, and guardrail testing. You assume full responsibility and liability for how you use it and for everything it generates, and you must not deploy it to end users or into production without adding your own safety, moderation, and abuse-prevention layers. The authors accept no liability. The license is Apache 2.0.

The measured behavior tells you what "uncensored" costs. From the model card's safety-evaluation suite — run on the FP8 build and dated August 15, 2026, which is the weights this GGUF converts: harmful-prompt refusal falls from 64–99% on the base to 0–6% on the abliterated weights, benign over-refusal drops from 5.6% to 0.4%, and capability scores stay within ±1.3 points of the base. Those numbers are why this class of model is a legitimate research object — and they are also the warning.

This article deliberately contains no harmful prompts. If you are evaluating the model, run the standard refusal benchmarks — AdvBench, HarmBench, StrongREJECT, XSTest-safe — and read the numbers yourself. That is the sanctioned way to study a refusal-removed model.

When this build is the wrong answer

1. You want a normal assistant. Wrong model. It has no guardrails and will comply with harmful requests. Use the aligned Qwen3.8-27B instead.

2. Anything you would put in front of end users. Wrong model regardless of intent. Apache 2.0 does not transfer your liability, and shipping a no-guardrail model to users is not a deployment strategy.

3. You are on Apple Silicon. The GGUF will run, but the MLX conversion of the base model is the more natural fit — see our separate MLX guide.

4. You do not want to run it at all. Use the hosted card — same weights, no 17 GB of VRAM, and the same research-only gate.

Bottom line

"Qwen 3.8 27B uncensored GGUF" has an answer, and it is a concrete download: Qwen3.8-27B-Uncensored-GGUF — F16 plus 12 quantization tiers for llama.cpp, the abliterated weights from our FP8 build, 262K context, vision, and MTP, under Apache 2.0 and research-only. Pick Q4_K_M on a 24 GB card, update llama.cpp past May 2026, and run it as a local OpenAI-compatible server. It is a research instrument for studying refusals and testing guardrails — not a chatbot, and not something to ship. The weights are free; the responsibility for what you do with them is entirely yours.

For legitimate research, the F16 and all 12 quant tiers are on Hugging Face: Download the GGUF from Hugging Face