Qwen3.8-27B-Uncensored-NVFP4: Een serving-runbook voor Blackwell-GPU's

Qwen3.8-27B-Uncensored-NVFP4 staat sinds 19 augustus 2026 op Hugging Face, en in de tien dagen daarna is het ongeveer 32.700 keer gedownload. Dit is geen launchverslag — de gewichten zijn tien dagen oud, er is geen aankondiging om over te rapporteren, en de zusterbuilds Qwen3.8-27B-Uncensored-FP8 en Qwen3.8-27B-Uncensored-GGUF worden al op deze blog gedocumenteerd. Het is een runbook voor een build die mensen nu actief aan het downloaden zijn: wat NVFP4 eigenlijk is, waarom deze specifieke build het mengt met FP8, welke GPU's er baat bij hebben en welke niet, hoe je het serveert, en wie het zou moeten verkiezen boven de FP8- of GGUF-builds — en wie niet.

Eén ding vooraf, want het laat elke beginnende downloader struikelen: de repo is afgeschermd. De naïeve hf download orcarouter/Qwen3.8-27B-Uncensored-NVFP4 one-liner mislukt met een authenticatiefout totdat je bent ingelogd bij Hugging Face en de toegangsvoorwaarden van de repo op de modelpagina hebt geaccepteerd. Alles hieronder gaat ervan uit dat je beide hebt gedaan.

Ook vooraf: de modelkaart van deze repository zit achter dezelfde toegangsbeveiliging, dus niets hier parafraseert die. Wat volgt is gebaseerd op de openbare bestandslijst en repository-metadata, op NVIDIA's openbare NVFP4-documentatie, en op veldrapporten van mensen die Qwen3.8-27B NVFP4-builds op Blackwell draaien. Waar een cijfer afkomstig is van een praktijkbeoefenaar in plaats van een leverancier, vermeldt de tekst dat.

Wat deze build is

Qwen3.8-27B-Uncensored-NVFP4 is de NVFP4-kwantificatie van Qwen3.8-27B-Uncensored, de geablitereerde versie van Ali​baba's Qw​en/Qwen3.8-27B die de orcarouter-organisatie op 2026-08-18 publiceerde. Abliteratie verwijdert de weigeringsrichting van het model uit de residustroom; die techniek wordt uitgelegd in onze uitleg over ongecensureerde modellen en wordt hier niet opnieuw uitgelegd. De basis is de dichte 27B met hybride aandacht — 48 lineaire-aandachtslagen plus 16 volledige-aandachtslagen — native beeld- en videobegrip, een context van 262.144 tokens en een ingebouwde MTP-speculatieve-decoderingkop. Apache 2.0 van begin tot eind.

Wat deze build interessant maakt, is niet de abliteratie maar de kwantiseringsindeling, omdat het bewust een gekwantiseerde build is — als je naar NVFP4 zocht, draait het om het formaat. Volgens de openbare metadata en kwantiseringsconfiguratie van de repository is het een mixed-precision compressed-tensors-build: de attention-projecties zijn FP8 (E4M3), de MLP's zijn NVFP4 (4-bit, verpakt), en de vision-encoder, de MTP-kop, de lm_head en de linear-attention-normen en -bias zijn in BF16 gelaten. De safetensors-metadata van de openbare bestandslijst komt overeen met dat schema: ongeveer 3,5 miljard parameters in BF16, 9,4 miljard in FP8-E4M3, en 15 miljard in de verpakte 4-bit-tensors, ongeveer 24,7 GB op schijf verdeeld over vijf shards plus een aparte model-extra-shard. Geen van dit alles is een claim over hoe het serveert — runtime-VRAM en doorvoer voor deze exacte repo zijn nergens gepubliceerd die ik vandaag kan citeren. De omvang op schijf komt uit de bestandslijst, het formaat uit de configuratie, en het hieronder beschreven serveergedrag is door de community geverifieerd op nauw verwante NVFP4-builds.

Wat NVFP4 is, en hoe het verschilt van FP8 en van INT8/AWQ

NVFP4 is NVIDIA's 4-bits floating-pointformaat, geïntroduceerd voor de vijfde generatie tensor cores op Blackwell, en NVIDIA's eigen technische blog is de juiste primaire bron daarvoor. Het slaat gewichten op als E2M1 — één tekenbit, twee exponentbits, één mantissebit — en schaalt ze in blokken: elke 16 waarden delen een E4M3 FP8-schaal, en de hele tensor krijgt een per-tensor FP32-scalair. Dat tweetraps-schema is precies waar het formaat om draait: het herstelt het dynamisch bereik dat een naïeve 4-bits float zou verliezen, ten koste van een paar bits overhead per blok. De praktische verschillen, in één regel:

• NVFP4 versus FP8 — beide zijn floating-point, maar FP8 (E4M3, 8-bit) draait op Hopper en Blackwell, terwijl NVFP4 4-bit is en alleen op Blackwell native wordt versneld. NVIDIA noemt ruwweg 3,5× kleinere gewichten dan FP16 en ongeveer 1,8× kleiner dan FP8, en op Blackwell draait de matmul rechtstreeks op de FP4-tensorcores.

• NVFP4 vs INT8/AWQ — INT8 (W8A8) en AWQ (W4A16) zijn integerformaten die vanaf Ampere draaien; AWQ is 4-bit maar integer, en op de meeste hardware worden de gewichten voor de matmul gedequantiseerd naar een breder type. NVFP4 is 4-bit float met blokschaling, waardoor het meer precisie in de lage bits behoudt, en het heeft een native FP4-GEMM-pad dat de integerformaten niet hebben.

• NVFP4 vs MXFP4 — de twee worden voortdurend verward. MXFP4 gebruikt blokken van 32 elementen en E8M0-schalen (machten van twee); NVFP4 gebruikt blokken van 16 elementen en E4M3-schalen. De fijnere blokken geven NVFP4 een betere isolatie van uitschieters, en dat is de reden waarom het formaat de de-facto 4-bit standaard is op Blackwell serving stacks.

Welke hardware profiteert — en welke niet

Het allerbelangrijkste feit over deze build: NVFP4 is een Blackwell-formaat. Het bewijst zijn nut alleen op de GPU's waarvan de tensorcores FP4 GEMM native implementeren, en op al het andere is het het verkeerde gereedschap, hoe snel de machine op papier ook is.

• Blackwell — RTX 50-serie, B200/B300, RTX PRO 6000, DGX Spark (GB10) — dit is waar NVFP4 de juiste keuze is: native FP4-tensorcores, de kleinste server-grade voetafdruk in de ongecensureerde lijn, en het formaat waarvoor de build is gemaakt.

• Hopper — H100/H200 — geen native FP4 GEMM. NVFP4 degradeert naar een weight-only dequant-pad dat langzamer is en niets oplevert. Gebruik hier Qwen3.8-27B-Uncensored-FP8; die build is op precies deze hardware geverifieerd.

• Ampere/Ada — RTX 3090/4090 — NVFP4 biedt op deze ook geen versnelling. De GGUF-build, met de Q4_K_M-variant van 16,8 GB, is het juiste hulpmiddel voor een 24 GB-kaart.

• Apple Silicon — NVFP4 is niet relevant op een Mac. De MLX-build (of GGUF) is degene die draait.

Een eerlijke nuance: community-forks draaien NVFP4 weight-only op pre-Blackwell-hardware. Een community-NVFP4-build van hetzelfde ge-ablitereerde model is expliciet opgezet voor V100-klasse kaarten via een gepatchte vLLM-fork, en de recente DGX Spark-recepten rond Qwen3.8-27B zijn een apart iets. Dat zijn specialistische paden met hun eigen kanttekeningen, niet waar deze build op mikt. Als je op Blackwell zit, maakt dat allemaal niets uit; als je niet op Blackwell zit, is de FP8- of GGUF-build de betere download.

Hoe serveer je het?

De repository is getagd voor vLLM, en het compressed-tensors-formaat wordt automatisch gelezen uit config.json — je selecteert niet handmatig een kwantiseringsschema. De stack waar beoefenaars op uitkomen voor Qwen3.8-27B NVFP4-builds is een recente vLLM op een Blackwell-kaart, een FP8-KV-cache en de eigen MTP-head van het model voor speculatieve decodering. Unsloth's NVFP4-gids, de meest geciteerde community-referentie, beveelt vLLM 0.25.0 of nieuwer aan met FlashInfer en de CUTLASS-DSL-kernelafhankelijkheid voor het snelle FP4-pad.

Een werkend startpunt, samengesteld uit de geverifieerde vlaggen van onze FP8-build en de NVFP4-recepten van de community, allemaal op één regel:

vllm serve orcarouter/Qwen3.8-27B-Uncensored-NVFP4 --kv-cache-dtype fp8 --max-model-len 262144 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder --speculative-config '{"method": "mtp", "num_speculative_tokens": 3}'

• FP8 KV cache — de meest breed compatibele manier om het cachegeheugen te halveren; gebruikers melden dat het de context die je kunt vasthouden ongeveer verdubbelt. NVFP4 KV-cache-ondersteuning bestaat, maar is beperkt tot sommige attention-backends, dus FP8 KV is de veiligere standaard.

• MTP speculatieve decodering — het model wordt geleverd met een MTP-drafthoofd, en de gekwantiseerde versie behoudt het in BF16. Beoefenaars melden dat twee tot drie draft-tokens goed werken met NVFP4-gewichten op Blackwell, met de grootste winst bij gestructureerde output zoals JSON en toolaanroepen.

• Vision — de vision-encoder blijft in BF16 behouden in deze build. Voeg --language-model-only toe om alleen-tekst te bedienen; laat het weg als je beeld- of video-invoer nodig hebt.

• Op een DGX Spark — een paar veldgerapporteerde valkuilen: houd --gpu-memory-utilization op of onder 0.90 (hogere waarden hebben de machine vastgezet tijdens het laden van gewichten), en voeg --safetensors-load-strategy lazy toe als het geheugen krap is. Je hebt ook een GB10-build van vLLM nodig voor de sm_121a-kernels.

Eerlijke prestaties: er zijn geen gepubliceerde, onafhankelijke doorvoercijfers voor deze exacte repository. De metingen die bestaan, zijn voor nauw verwante NVFP4-builds. Unsloth rapporteert 1,41–1,49× de tokens per seconde van BF16 op een B200 voor zijn eigen Qwen3.8-27B-NVFP4-build (89,8 tot 133,7 tok/s bij batch 1, 3.048 tot 4.407 bij batch 64), en één DGX Spark-gebruiker op de NVIDIA-forums rapporteert ongeveer 20–32 tok/s met NVFP4-gewichten, een FP8-KV-cache en MTP-diepte 3. Beide zijn het citeren waard; geen van beide is een benchmark van deze repository.

Gebruikspatronen die daadwerkelijk werken

Beoefenaars die Qwen3.8-27B-familie-modellen op Blackwell draaien, komen uit op een handvol instellingen. Beschouw deze als veldrapporten, niet als leveranciersrichtlijnen — Qw​en documenteert het meeste hiervan niet, en de eigen kaart van deze repo is afgeschermd.

• reasoning_effort is de knop die er het meest toe doet. De standaardinstelling xhigh zorgt ervoor dat het model bij elke aanvraag lang nadenkt. Mensen die agent-loops draaien, zetten standaard op medium en verlagen naar low — of schakelen het denken volledig uit met enable_thinking: false — voor latentiegevoelige losse aanroepen. Op een enkele Blackwell-GPU is xhigh-redenering bij een routinetaak de manier waarop je eindigt met een snel model en langzame antwoorden.

• Samplers zijn gekoppeld aan de denkmodus, niet onafhankelijk. Community-consensus: denkmodus aan draait op temperatuur 1.0 / top_p 0.95; denkmodus uit draait op temperatuur 0.7 / top_p 0.80 met presence_penalty 1.5. Het omwisselen van de twee sets verslechtert de uitvoerkwaliteit.

• Gebruik een actuele chat-template. Het qwen3_5-template plaatst elke assistent-beurt in een think-blok, en meerdere gebruikers melden looping of afgekapte antwoorden met verouderde templates; de door de community gerepareerde Qw​en-Fixed-Chat-Templates en Qw​en-Sharp-varianten stellen preserve_thinking in en stoppen de loops. Als je geleverde output doordraaft na de stop-token, is dit het eerste wat je moet controleren.

• Begroot voor lange redeneertraces in agentwerk. Beoefenaars melden dat het 3.8-generatiemodel ongeveer twee keer zoveel tokens per taak genereert als zijn 3.6-voorganger — de kwaliteitssprong komt deels door langer nadenken. Voor lange xhigh-antwoorden moet je de redeneeruitvoer streamen, anders krijg je te maken met gateway-timeouts.

• Tool calling blijft intact na de kwantisering. Het function-calling-pad overleeft zowel de abliteration als de 4-bits conversie; schakel het in met de qwen3_coder tool-call-parser en het model kiest tools op dezelfde manier als het basismodel.

Wie zou deze build moeten kiezen — en wie niet

De eerlijke beslissing, zonder de quant-keuzewiskunde te herhalen die onze FP8- en GGUF-posts al in detail behandelen:

• Kies NVFP4 als je op Blackwell draait en de kleinste server-grade voetafdruk wilt in de ongecensureerde lijn met FP4-tensor-core-snelheid — en je onderzoek, red-team- of interpreteerbaarheidswerk doet dat legitiem een abliterated model nodig heeft.

• Kies Qwen3.8-27B-Uncensored-FP8 als je op Hopper werkt, of je het breedst geverifieerde vLLM-pad wilt — het zijn dezelfde gewichten op 8-bit, geverifieerd op een H200, met een VRAM-ondergrens van ruwweg 40 GB.

• Kies Qwen3.8-27B-Uncensored-GGUF als je op een consumenten-GPU of een Mac draait, of als je llama.cpp wilt in plaats van vLLM — de Q4_K_M-tier is de beste keuze voor lokaal gebruik.

• Kies geen van beide als je maximale getrouwheid wilt, je iets gebruikersgericht bouwt (zie de veiligheidsgrens hieronder), of je helemaal niet zelf wilt hosten — dezelfde ongecensureerde lijn wordt via OrcaRouter aangeboden, beperkt tot onderzoekers, dus er is geen GPU nodig.

De veiligheidsgrens — alleen voor onderzoek

Dit is een abliterated model, en de quant plaatst de guardrails niet terug. De weigeringrichting is verwijderd uit de residustroom van Qw​en/Qwen3.8-27B, en NVFP4 is een precisiewijziging, geen veiligheidsinterventie — het model zal voldoen aan verzoeken die het basismodel weigert, en deze build heeft geen ingebouwde moderatie. Het is vrijgegeven voor interpreteerbaarheid, AI-veiligheid en red-team-onderzoek onder Apache 2.0, en de verantwoordelijkheid ligt bij jou.

Twee evaluatiepunten die veel te zelden aan bod komen in de wereld van ongecensureerde modellen. Ten eerste: een enkele jailbreak-test die triviaal slaagt, is geen geslaagde veiligheidsevaluatie — ge-ablitereerde modellen laten die opzettelijk falen. Meet waar je daadwerkelijk om geeft met de juiste testbatterijen (AdvBench, HarmBench en StrongREJECT voor schadelijkheid; XSTest-safe voor overmatige weigering) en vergelijk de weigeringspercentages vóór en na de interventie. Ten tweede: evalueer de kwantisatie, niet alleen het basismodel: een 4-bit-build kan het gedrag in randgevallen veranderen, zelfs als de geaggregeerde scores er goed uitzien. Stel dit niet beschikbaar aan eindgebruikers zonder je eigen moderatie- en misbruikpreventielagen.

Waar OrcaRouter past

Een tien dagen oud gekwantiseerd bouwsel is het schoolvoorbeeld van routeren in plaats van vast bedraden. Je kunt een route opzetten die naar de NVFP4-build wijst die je zelf draait, en bij een storing overgaan op een gehost model als het bouwsel zich onder belasting misdraagt — één interface, geen herbedrading tussen providers wanneer je wisselt. OrcaRouter geeft de catalogusprijs van de provider door zonder opslag, dus als de prijs van het onderliggende model verandert, weerspiegelt je endpoint dat dezelfde dag in plaats van op je factureringscyclus.

En als het erom gaat helemaal geen GPU te draaien: dezelfde ongecensureerde lijn is beschikbaar via OrcaRouter, toegankelijk voor beveiligingsonderzoekers en red teams, met automatische failover tussen providers. Of je deze NVFP4-build nu zelf host of de gehoste lijn gebruikt, het is in beide gevallen één API-sleutel.

De bottom line

Qwen3.8-27B-Uncensored-NVFP4 is de juiste download als je het abliterated model op Blackwell serveert en de kleinste footprint wilt met FP4-tensor-core-snelheid. Het is de verkeerde download op Hopper (gebruik de FP8-build), op een consumenten- of Apple-GPU (gebruik de GGUF- of MLX-build), of als je maximale getrouwheid nodig hebt. Het is niet nieuw — het is al downloadbaar sinds 19 augustus 2026 — maar het wordt massaal gedownload, en nu weet je waar je aan begint voordat je de gate accepteert.

Niet weer een build van dit model — Qwen3.8-Flash-Next-Uncensored is een aparte release: geablitereerd van Qwen3.8-Flash-Next, een 176B-opgeslagen / 6B-actieve mixture-of-experts-preview van de Qwen4-architectuur. Dezelfde abliteratietechniek, andere gewichten, zijn eigen collectie.

Alle zes 27B-builds — BF16, GGUF, MLX, FP8, INT8 en NVFP4 — zijn verzameld in de Qwen3.8-27B-Uncensored-collectie op Hugging Face.

Deze gewichten zijn bewust uitsluitend lokaal beschikbaar. Om de abliterated build tegen een gehoste basislijn te meten, Qwen3.8-27B wordt aangeboden op OrcaRouter tegen de lijstprijs van de provider met 0% opslag — het standaardmodel, met intacte veiligheidsalignment.