Draai Qwen3-Coder-Next lokaal: Vibe code een analyticsdashboard

Qwen3-Coder-Next is een open-weight codemodel van het Qwen-team, gebouwd voor agentic programmeren en lokale developer-workflows. Het gebruikt een spaarzame mixture-of-experts-ontwerp om efficiënt te blijven en toch sterk te presteren op moderne code- en tool-use-benchmarks, met ondersteuning voor lange context en complexe meerstaps taken.

Wat Qwen3-Coder-Next extra interessant maakt, is hoe competitief het is vergeleken met top closed modellen. Vroege evaluaties laten zien dat het prestatieniveaus kan halen die dicht in de buurt komen van systemen zoals Claude Sonnet 4.5, terwijl je het nog steeds lokaal kunt draaien met volledige controle over je setup, privacy en snelheid, zonder afhankelijk te zijn van dure gehoste API’s.

Bron: Qwen/Qwen3-Coder-Next

In deze tutorial bouwen we llama.cpp vanaf de broncode, draaien we Qwen3-Coder-Next lokaal met de llama.cpp inference server en koppelen we die vervolgens aan Qwen Code CLI. Tot slot vibe coden we een eenvoudig data-analyticsdashboard.

Qwen3-Coder-Next hardware- en softwarevereisten

Voordat je Qwen3-Coder-Next lokaal gaat bouwen en draaien, heb je een werkende Linux-ontwikkelomgeving nodig met de standaard buildtools die vereist zijn om llama.cpp te compileren en GGUF-modellen te draaien.

Zorg naast systeem­pakketten ook dat je het volgende hebt:

• Python (>= 3.11) voor ondersteunende scripts en lokale workflows
• Node.js + npm (Node 20+) voor installatie van de Qwen Code CLI
• De juiste NVIDIA GPU-stuurprogramma’s
• De CUDA Toolkit geconfigureerd voor volledige GPU-versnelling

Begin met het updaten van je systeem en het installeren van de kern­afhankelijkheden:

sudo apt-get update
sudo apt-get install -y build-essential cmake curl git libcurl4-openssl-devMogelijk gemaakt door

Als je CUDA-versnelling wilt gebruiken, controleer dan of je NVIDIA GPU correct wordt gedetecteerd:

nvidia-smiMogelijk gemaakt door

In ons geval gebruiken we een NVIDIA RTX 3090 met 24GB VRAM. Omdat Qwen3-Coder-Next voor grotere quantisaties meer geheugen nodig heeft dan dat, worden de overige modelgewichten automatisch uitgeladen naar de systeem-RAM, zodat het model lokaal kan blijven draaien met goede prestaties.

Om Qwen3-Coder-Next soepel te draaien, zou je hardware ongeveer aan deze geheugendoelen moeten voldoen:

• 46GB RAM / VRAM / unified memory aanbevolen voor 4-bit GGUF inference.
• ~85GB geheugen vereist voor 8-bit varianten.

Als je geen 46GB beschikbaar hebt, kun je nog steeds kleinere gequantiseerde versies draaien (zoals 3-bit).

Een eenvoudige vuistregel is:

Schijf + RAM + VRAM ≥ quant-grootte

Als de volledige quant in het geheugen past, kun je snelle lokale prestaties verwachten. Zo niet, dan draait het model nog steeds door uit te laden, maar inference is trager.

llama.cpp installeren met CUDA-ondersteuning

Voordat we Qwen3-Coder-Next lokaal draaien, hebben we een snelle inference-engine nodig. De populairste optie is momenteel llama.cpp, dat lichte GGUF-inference en een eenvoudig te starten lokale server biedt.

Wil je de snelste setup, dan biedt llama.cpp prebuilt binaries voor macOS, Linux en Windows (inclusief CUDA-builds). Je kunt ze direct downloaden van de officiële GitHub-releas­epagina: Release b7936 · ggml-org/llama.cpp. 

Met een prebuilt-installatie kun je meteen de llama.cpp CLI-tools draaien of de inference-server starten zonder zelf iets te compileren.

In deze tutorial bouwen we llama.cpp handmatig in plaats van te vertrouwen op prebuilt binaries, om een paar belangrijke redenen:

• Laatste updates en bugfixes uit de GitHub-repository
• Volledige CUDA-ondersteuning geoptimaliseerd voor Linux-systemen
• Betere prestaties afgestemd op je specifieke GPU en omgeving
• Vereist voor nieuwere quant-formaten en recente verbeteringen in modeloutputkwaliteit

Laten we beginnen met het downloaden van de officiële llama.cpp-broncode rechtstreeks van GitHub. Zo werken we met de meest recente versie, inclusief de nieuwste CUDA-verbeteringen en bugfixes:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cppMogelijk gemaakt door

Je zou nu in de map llama.cpp moeten staan, die alles bevat om het project from scratch te bouwen.

Vervolgens configureren we het buildsysteem met CMake. Deze stap genereert de benodigde buildbestanden en schakelt GPU-versnelling via CUDA in:

cmake /workspace/llama.cpp -B /workspace/llama.cpp/build -DGGML_CUDA=ON -DBUILD_SHARED_LIBS=OFFMogelijk gemaakt door

Nu compileren we het daadwerkelijke inference-serverbinaire. Dit onderdeel host Qwen3-Coder-Next lokaal en stelt een API-endpoint beschikbaar voor codetools en CLI-integraties:

cmake --build /workspace/llama.cpp/build -j --clean-first --target llama-serverMogelijk gemaakt door

Na het bouwen staan de gecompileerde uitvoerbare bestanden in de map build/bin/. Om ze makkelijker direct vanuit de hoofdmap te draaien, kun je ze zo kopiëren:

cp /workspace/llama.cpp/build/bin/llama-server /workspace/llama.cpp/llama-serverMogelijk gemaakt door

Het Qwen3-Coder-Next-model downloaden

Nu llama.cpp is geïnstalleerd, is de volgende stap het downloaden van het Qwen3-Coder-Next GGUF-model van Hugging Face.

Zorg eerst dat je een recente Python-installatie (>= 3.11) hebt, omdat de Hugging Face-tools en transferutilities daarvan afhankelijk zijn.

Om grote GGUF-bestanden efficiënt te downloaden gebruiken we de Hugging Face Hub-client samen met de high-speed Xet- en transfer-backends:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferMogelijk gemaakt door

Schakel vervolgens Hugging Face’s geoptimaliseerde transfer-backend in:

export HF_HUB_ENABLE_HF_TRANSFER=1Mogelijk gemaakt door

Nu kunnen we de Unsloth dynamic GGUF-versie van Qwen3-Coder-Next downloaden. In deze tutorial halen we specifiek de UD-Q4_K_XL-quantisatie op.

Dit is een uitstekende standaardkeuze omdat het een prima balans biedt tussen:

• Modelkwaliteit (zeer sterke codeprestaties)
• Inference-snelheid (snel genoeg voor lokale vibe coding-workflows)
• Geheugenefficiëntie (past op high-end consument-GPU’s met RAM-uitladen)

Het Q4-formaat betekent dat het model is gecomprimeerd naar 4-bit precisie, waardoor het veel lichter is dan volledige FP16-gewichten en toch indrukwekkende outputkwaliteit behoudt. 

hf download unsloth/Qwen3-Coder-Next-GGUF \
  --local-dir /workspace/models/qwen3-coder-next \
  --include "*UD-Q4_K_XL*"Mogelijk gemaakt door

Zodra het commando draait, beginnen de modelbestanden te downloaden naar je lokale map.

Op een hogesnelheidsnetwerk duurt dit meestal slechts een paar minuten. Na voltooiing heb je het GGUF-model klaar om te laden in llama-server voor lokale inference.

De Qwen3-Coder-Next inference-server draaien

Zodra het GGUF-model is gedownload, kunnen we Qwen3-Coder-Next lokaal starten met de llama-server-backend. Dit start een OpenAI-compatibele API-server waar codetools en CLI’s mee kunnen verbinden.

Draai het volgende commando:

./llama-server \
  --model "/workspace/models/qwen3-coder-next/Qwen3-Coder-Next-UD-Q4_K_XL.gguf" \
  --alias "Qwen3-Coder-Next" \
  --host 0.0.0.0 \
  --port 8080 \
  --threads 32 \
  --threads-batch 32 \
  --ctx-size 20000\
  --batch-size  1024\ 
  --ubatch-size 256 \
  --jinja \
  --flash-attn on \
  --temp 0.7 \
  --top-p 0.9 \
  --min-p 0.05 \
  --fit on \
  --swa offMogelijk gemaakt door

Uitleg van belangrijke argumenten:

• --model: Pad naar de gedownloade Qwen3-Coder-Next GGUF-checkpoint
• --alias: Vriendelijke modelnaam die in API-clients wordt getoond
• --host 0.0.0.0: Stelt de server bloot op alle netwerkinterfaces (handig voor externe toegang)
• --port 8080: Draait de inference-API op poort 8080
• --threads 32: Gebruikt 32 CPU-threads voor maximale throughput
• --threads-batch 32: Parallelle batchverwerking voor snellere tokengeneratie
• --ctx-size 20000: Stelt een grote contextwindow (~20K tokens) in voor lange codesessies
• --batch-size 1024: Verbetert GPU-benutting tijdens inference
• --ubatch-size 256: Regelt micro-batching voor soepelere prestaties
• --jinja: Schakelt chattemplate-formattering in die nodig is voor instructiestijl-modellen
• --flash-attn on: Activeert Flash Attention voor snellere long-context inference
• --temp 0.7: Houdt outputs gefocust maar nog creatief voor vibe coding
• --top-p 0.9: Nucleus sampling voor gebalanceerde diversiteit
• --min-p 0.05: Filtert tokens met extreem lage waarschijnlijkheid voor schonere completions
• --fit on: Past lagen automatisch in VRAM en laadt de rest uit naar RAM
• --swa off: Schakelt sliding window attention uit (beter voor full-context taken)

Laat de server, zodra die draait, open in dat terminalvenster. Open daarna een nieuw terminaltabblad of -sessie om de API te testen zonder de server te stoppen.

In de nieuwe terminal kun je bevestigen dat alles werkt door de beschikbare modellen op te vragen:

curl http://127.0.0.1:8080/v1/modelsMogelijk gemaakt door

Als de server correct draait, zie je Qwen3-Coder-Next terug in de response, wat betekent dat je lokale inference-endpoint klaar is voor gebruik.

Toegang tot het lokale Qwen3-Coder-Next API-endpoint via Web UI

Zodra de inference-server draait, kun je ook direct met Qwen3-Coder-Next interacteren via de ingebouwde llama.cpp Web UI.

Open je browser en ga naar: http://127.0.0.1:8080.

Dit opent een eenvoudige ChatGPT-achtige interface waarin je snel prompts kunt testen en kunt verifiëren dat het model correct reageert.

Vraag het model bijvoorbeeld iets praktisch te genereren, zoals een eenvoudige Python trading-bot.

Binnen enkele seconden krijg je een volledig antwoord met werkende code en duidelijke implementatiestappen.

Wat vooral indruk maakt, is de snelheid. Op onze setup genereert Qwen3-Coder-Next ongeveer 44 tokens per seconde, waardoor lokaal coderen zeer responsief aanvoelt — snel genoeg voor realtime vibe coding-workflows.

De Qwen Code CLI installeren en instellen

Nu de lokale inference-server draait op http://127.0.0.1:8080/v1, kunnen we die verbinden met Qwen Code CLI. Zo krijg je een lichte, terminalgebaseerde code-assistent die via de OpenAI-compatibele API met je lokale Qwen3-Coder-Next-model praat.

Qwen Code CLI is een tool op basis van Node, dus je hebt nodig:

• Node.js 20+
• npm (op Ubuntu/Debian automatisch geïnstalleerd met Node.js)

Installeer Node.js via NodeSource (aanbevolen om de juiste versie te krijgen):

sudo apt update
sudo apt install -y curl ca-certificates
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejsMogelijk gemaakt door

Installeer nu de Qwen Code CLI globaal:

npm install -g @qwen-code/qwen-code@latestMogelijk gemaakt door

Controleer of deze correct is geïnstalleerd:

qwen --version Mogelijk gemaakt door

0.9.0Mogelijk gemaakt door

Qwen CLI verwacht OpenAI-achtige omgevingsvariabelen. We maken een eenvoudige configuratie­file die aangeeft:

• Gebruik een dummy API-sleutel (omdat we lokaal draaien)
• Stuur requests naar llama-server op poort 8080
• Gebruik exact de modelnaam die we met --alias hebben ingesteld

Maak de configmap en .env-file aan:

mkdir -p ~/.qwen
cat > ~/.qwen/.env <<'EOF'
OPENAI_API_KEY="dummy"
OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
OPENAI_MODEL="Qwen3-Coder-Next"
EOFMogelijk gemaakt door

Start nu Qwen Code:

qwen Mogelijk gemaakt door

Op dit punt is je CLI gekoppeld aan je lokale Qwen3-Coder-Next-server, dus elke prompt draait lokaal in plaats van een gehoste API te gebruiken.

Vibe coding van het analytical dashboard met Qwen3-Coder-Next

Nu alles lokaal draait, kunnen we beginnen met vibe coding van een eenvoudig analyticsdashboard met behulp van de Qwen Code CLI.

Maak eerst een nieuwe projectmap en ga erin:

mkdir dashboardcd dashboardMogelijk gemaakt door

Start vervolgens de Qwen CLI in deze map:

qwenMogelijk gemaakt door

Geef het model nu een duidelijke, eenvoudige instructie, bijvoorbeeld:

“Bouw een HTML-analyticsdashboard met dummydata (sales, users, revenue, churn), toon KPI-kaarten, een interactieve tabel en minstens één grafiek, voeg datumbereik- en categoriefilters toe.”

Binnen seconden begrijpt Qwen3-Coder-Next de requirements en splitst de taak op in een gestructureerd plan voordat het code schrijft.

Na het afvinken van de checklist genereerde het model in één keer een volledig werkend dashboard, inclusief:

• index.html
• style.css
• script.js

Wanneer je het bestand index.html in je browser opent, zie je meteen een modern, goed gestructureerd dashboard met strakke styling, KPI-kaarten en realistische placeholder-metrics. 

De filters, tabelinteracties en downloadopties werken allemaal soepel out of the box.

Als je verder naar beneden scrolt, bevat het dashboard ook gedetailleerde transactiegegevens met ongeveer 150 dummyrecords, waardoor het aanvoelt als een echt analyticsproduct.

Hoewel niet elke mogelijke visualisatie wordt gegenereerd (bijvoorbeeld een lijn­grafiek voor omzet-in-de-tijd zou een mooie toevoeging zijn), is het nog steeds bijzonder indrukwekkend dat een lokaal draaiend gequantiseerd model in feite in één keer een functionerend dashboard kan opleveren. 

Al met al kostte de hele build slechts een paar minuten van prompt tot werkende output.

Tot slot

Ik ben eerlijk: mijn ervaring met Qwen3-Coder-Next was een beetje gemengd.

Op papier suggereren de evaluaties dat het dicht in de buurt zou moeten komen van frontier-modellen zoals Claude Sonnet 4.5, en het idee om een 80B MoE-codemodel lokaal te draaien is oprecht spannend. 

In deze tutorial hebben we met succes llama.cpp met CUDA-ondersteuning gebouwd, de Unsloth GGUF-quant gedownload, een lokale inference-server gestart en zelfs in minuten een werkend analyticsdashboard vibe gecode. De lokale snelheid en responsiviteit waren indrukwekkend, zeker voor een open-weight setup.

Maar in de praktijk zag ik niet consequent de betrouwbaarheid op “Sonnet-niveau” die sommige benchmarks impliceren. Ik heb een paar uur geprobeerd het model te gebruiken in complexere agent-omgevingen zoals opencode, en ik liep steeds tegen issues aan zoals toolfouten, instabiele generaties en af en toe lusgedrag.

Interessant genoeg voelde het model een stuk betrouwbaarder zodra ik overstapte op een eenvoudigere workflow met Qwen Code CLI. In die setting presteerde het goed voor directe codetaken, snel prototypen en vibe coding-sessies. Het was soepel, snel en oprecht leuk om lokaal te gebruiken.

Mijn conclusie: Qwen3-Coder-Next is absoluut het experimenteren waard, zeker als je een krachtige lokale code-assistent wilt zonder cloud-API’s. Maar ik zou het nog niet aanraden als volledige vervanging voor production-grade code-agents, tenzij je bereid bent tijd te steken in debuggen, het afstellen van llama.cpp-instellingen en het optimaliseren van prestaties voor jouw hardware.

Wil je meer leren over werken met AI in je workflows, bekijk dan de AI-Assisted Coding for Developers-cursus.