Esegui Qwen3-Coder-Next in locale: Vibe coding di una dashboard di analytics

Qwen3-Coder-Next è un modello di coding open-weight del team Qwen, pensato per la programmazione agentica e i flussi di lavoro locali per sviluppatori. Usa un mixture-of-experts sparso per restare efficiente pur offrendo ottime prestazioni nei benchmark moderni di coding e tool-use, con supporto per contesti lunghi e task complessi multi-step.

Ciò che rende Qwen3-Coder-Next particolarmente interessante è quanto sia competitivo rispetto ai migliori modelli closed. Le prime valutazioni mostrano che può raggiungere livelli di performance vicini a sistemi come Claude Sonnet 4.5, restando però qualcosa che puoi eseguire in locale con pieno controllo su setup, privacy e velocità, senza dipendere da costose API ospitate.

Fonte: Qwen/Qwen3-Coder-Next

In questo tutorial, compileremo llama.cpp dai sorgenti, eseguiremo Qwen3-Coder-Next in locale usando il server di inferenza di llama.cpp, quindi lo connetteremo a Qwen Code CLI. Infine, faremo vibe coding di una semplice dashboard di data analytics.

Prerequisiti hardware e software per Qwen3-Coder-Next

Prima di compilare ed eseguire Qwen3-Coder-Next in locale, ti serve un ambiente di sviluppo Linux funzionante con i tool di build standard necessari per compilare llama.cpp ed eseguire modelli GGUF.

Oltre ai pacchetti di sistema, assicurati di avere anche:

• Python (>= 3.11) per script di supporto e flussi di lavoro locali
• Node.js + npm (Node 20+) per installare Qwen Code CLI
• I driver NVIDIA GPU corretti
• Il CUDA Toolkit configurato per la piena accelerazione GPU

Inizia aggiornando il sistema e installando le dipendenze principali:

sudo apt-get update
sudo apt-get install -y build-essential cmake curl git libcurl4-openssl-devOfferto da

Se prevedi di usare l'accelerazione CUDA, verifica che la tua GPU NVIDIA sia rilevata correttamente:

nvidia-smiOfferto da

Nel nostro caso, stiamo usando una NVIDIA RTX 3090 con 24GB di VRAM. Poiché Qwen3-Coder-Next richiede più memoria per le quantizzazioni più grandi, i pesi restanti del modello verranno automaticamente offloadati nella RAM di sistema, permettendo comunque l'esecuzione locale con buone prestazioni.

Per eseguire Qwen3-Coder-Next senza intoppi, l'hardware dovrebbe soddisfare questi target di memoria approssimativi:

• 46GB tra RAM / VRAM / memoria unificata raccomandati per inferenza GGUF a 4 bit.
• ~85GB di memoria richiesti per le varianti a 8 bit.

Se non hai 46GB disponibili, puoi comunque eseguire versioni quantizzate più piccole (ad esempio a 3 bit).

Una semplice regola pratica è:

Disco + RAM + VRAM ≥ dimensione della quantizzazione

Se l'intera quantizzazione entra in memoria, puoi aspettarti buone prestazioni locali. In caso contrario, il modello verrà comunque eseguito tramite offloading, ma l'inferenza sarà più lenta.

Installare llama.cpp con supporto CUDA

Prima di eseguire Qwen3-Coder-Next in locale, ci serve un motore di inferenza veloce. L'opzione più popolare oggi è llama.cpp, che offre inferenza GGUF leggera e un server locale facile da avviare.

Se vuoi il setup più rapido, llama.cpp offre binari precompilati per macOS, Linux e Windows (inclusi build con CUDA abilitato). Puoi scaricarli direttamente dalla pagina delle release ufficiali su GitHub: Release b7936 · ggml-org/llama.cpp. 

Con un'installazione precompilata, puoi eseguire subito gli strumenti CLI di llama.cpp o avviare il server di inferenza senza compilare nulla.

In questo tutorial, compileremo manualmente llama.cpp invece di affidarci ai binari precompilati per alcuni motivi importanti:

• Ultimi aggiornamenti e bug fix dal repository GitHub
• Pieno supporto CUDA ottimizzato per sistemi Linux
• Prestazioni migliori, ottimizzate per la tua GPU e l'ambiente specifico
• Necessario per formati di quantizzazione più recenti e per i miglioramenti più nuovi nella qualità dell'output del modello

Cominciamo scaricando il codice sorgente ufficiale di llama.cpp direttamente da GitHub. Questo assicura che lavoriamo con la versione più recente, inclusi i miglioramenti CUDA e i bug fix più aggiornati:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cppOfferto da

A questo punto dovresti essere dentro la directory llama.cpp, che contiene tutto il necessario per compilare il progetto da zero.

Ora dobbiamo configurare il sistema di build usando CMake. Questo passaggio genera i file di build necessari e abilita l'accelerazione GPU tramite CUDA:

cmake /workspace/llama.cpp -B /workspace/llama.cpp/build -DGGML_CUDA=ON -DBUILD_SHARED_LIBS=OFFOfferto da

Adesso compiliamo il binario del server di inferenza. È il componente che ospiterà Qwen3-Coder-Next in locale ed esporrà un endpoint API per strumenti di coding e integrazioni CLI:

cmake --build /workspace/llama.cpp/build -j --clean-first --target llama-serverOfferto da

Una volta completata la build, gli eseguibili compilati si trovano nella directory build/bin/. Per renderli più comodi da eseguire direttamente dalla cartella principale del progetto, puoi copiarli così:

cp /workspace/llama.cpp/build/bin/llama-server /workspace/llama.cpp/llama-serverOfferto da

Scaricare il modello Qwen3-Coder-Next

Ora che llama.cpp è installato, il prossimo passo è scaricare il modello Qwen3-Coder-Next GGUF da Hugging Face.

Prima di iniziare, assicurati di avere un'installazione recente di Python (>= 3.11), dato che gli strumenti e le utility di trasferimento di Hugging Face ne dipendono.

Per scaricare in modo efficiente i file GGUF di grandi dimensioni, useremo il client Hugging Face Hub insieme ai backend ad alta velocità Xet e transfer:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferOfferto da

Poi abilita il backend di trasferimento ottimizzato di Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1Offerto da

Ora possiamo scaricare la versione Unsloth dynamic GGUF di Qwen3-Coder-Next. In questo tutorial, prenderemo in particolare la quantizzazione UD-Q4_K_XL.

È un'ottima scelta di default perché offre un eccellente compromesso tra:

• Qualità del modello (prestazioni di coding molto solide)
• Velocità di inferenza (abbastanza rapida per flussi di lavoro di vibe coding locale)
• Efficienza di memoria (entra in GPU consumer di fascia alta con offloading in RAM)

Il formato Q4 significa che il modello è compresso a precisione a 4 bit, rendendolo molto più leggero dei pesi FP16 completi pur mantenendo un'ottima qualità di output. 

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

Una volta avviato il comando, i file del modello inizieranno a scaricarsi nella tua directory locale.

Su una rete ad alta velocità, in genere bastano pochi minuti. Al termine, avrai il modello GGUF pronto da caricare in llama-server per l'inferenza locale.

Eseguire il server di inferenza Qwen3-Coder-Next

Una volta scaricato il modello GGUF, possiamo avviare Qwen3-Coder-Next in locale usando il backend di inferenza llama-server. Questo avvia un server API compatibile con OpenAI a cui strumenti di coding e CLI possono connettersi.

Esegui il seguente comando:

./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 offOfferto da

Argomenti chiave spiegati:

• --model: Percorso al checkpoint Qwen3-Coder-Next GGUF scaricato
• --alias: Nome amichevole del modello mostrato nei client API
• --host 0.0.0.0: Espone il server su tutte le interfacce di rete (utile per accesso remoto)
• --port 8080: Esegue l'API di inferenza sulla porta 8080
• --threads 32: Usa 32 thread CPU per la massima throughput
• --threads-batch 32: Parallelizza l'elaborazione in batch per generazione token più veloce
• --ctx-size 20000: Imposta una finestra di contesto ampia (~20K token) per lunghe sessioni di coding
• --batch-size 1024: Migliora l'utilizzo della GPU durante l'inferenza
• --ubatch-size 256: Controlla il micro-batching per prestazioni più fluide
• --jinja: Abilita il formato chat template richiesto dai modelli istruzionali
• --flash-attn on: Attiva la Flash Attention per inferenza più rapida su contesti lunghi
• --temp 0.7: Mantiene gli output focalizzati ma ancora creativi per il vibe coding
• --top-p 0.9: Nucleus sampling per un equilibrio nella diversità
• --min-p 0.05: Filtra token a probabilità molto bassa per completamenti più puliti
• --fit on: Adatta automaticamente i layer in VRAM e offloada il resto in RAM
• --swa off: Disabilita la sliding window attention (meglio per task a pieno contesto)

Una volta avviato il server, lascialo in esecuzione in quella finestra del terminale. Poi, apri una nuova scheda o sessione del terminale per testare l'API senza fermare il server.

Dal nuovo terminale, puoi confermare che tutto funzioni interrogando i modelli disponibili:

curl http://127.0.0.1:8080/v1/modelsOfferto da

Se il server è in esecuzione correttamente, dovresti vedere Qwen3-Coder-Next nella risposta, il che significa che il tuo endpoint di inferenza locale è pronto all'uso.

Accedi all'endpoint API locale di Qwen3-Coder-Next tramite Web UI

Una volta che il server di inferenza è in esecuzione, puoi interagire con Qwen3-Coder-Next anche direttamente tramite la Web UI di llama.cpp integrata.

Apri il browser e visita: http://127.0.0.1:8080.

Si apre un'interfaccia in stile ChatGPT dove puoi testare rapidamente i prompt e verificare che il modello risponda correttamente.

Per esempio, inizia chiedendo al modello di generare qualcosa di pratico, come un semplice bot di trading in Python.

In pochi secondi, otterrai una risposta completa con codice funzionante e passaggi di implementazione chiari.

Ciò che colpisce in particolare è la velocità. Nel nostro setup, Qwen3-Coder-Next genera circa 44 token al secondo, il che rende il coding locale estremamente reattivo, abbastanza veloce per flussi di lavoro di vibe coding in tempo reale.

Installa e configura Qwen Code CLI

Ora che il server di inferenza locale è in esecuzione su http://127.0.0.1:8080/v1, possiamo collegarlo a Qwen Code CLI. Questo ti dà un assistente di coding leggero da terminale che dialoga con il tuo modello Qwen3-Coder-Next locale tramite l'API compatibile con OpenAI.

Qwen Code CLI è uno strumento basato su Node, quindi ti servono:

• Node.js 20+
• npm (installato automaticamente con Node.js su Ubuntu/Debian)

Installa Node.js da NodeSource (consigliato per ottenere la versione corretta):

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 nodejsOfferto da

Ora installa Qwen Code CLI globalmente:

npm install -g @qwen-code/qwen-code@latestOfferto da

Verifica che sia installato correttamente:

qwen --version Offerto da

0.9.0Offerto da

Qwen CLI si aspetta variabili d'ambiente in stile OpenAI. Creeremo un semplice file di configurazione che gli dica di:

• Usare una chiave API fittizia (dato che stiamo eseguendo in locale)
• Inviare le richieste a llama-server sulla porta 8080
• Usare il nome modello esatto impostato con --alias

Crea la directory di config e il file .env:

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"
EOFOfferto da

Ora avvia Qwen Code:

qwen Offerto da

A questo punto, la tua CLI è collegata al server Qwen3-Coder-Next locale, quindi ogni prompt viene eseguito in locale invece di chiamare un'API ospitata.

Vibe coding della dashboard analitica con Qwen3-Coder-Next

Ora che tutto è in esecuzione in locale, possiamo iniziare a fare vibe coding di una semplice dashboard di analytics usando la Qwen Code CLI.

Per prima cosa, crea una nuova cartella di progetto e spostati al suo interno:

mkdir dashboardcd dashboardOfferto da

Poi avvia la CLI di Qwen dentro questa directory:

qwenOfferto da

Ora dai al modello un'istruzione chiara e semplice, per esempio:

«Crea una dashboard di analytics in HTML con dati fittizi (vendite, utenti, ricavi, churn), mostra KPI card, una tabella interattiva e almeno un grafico, aggiungi filtri per intervallo di date e categoria.»

In pochi secondi, Qwen3-Coder-Next capisce i requisiti e scompone il task in un piano strutturato prima di scrivere il codice.

Dopo aver completato la checklist, il modello ha generato una dashboard funzionante completa in un colpo solo, includendo:

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

Quando apri il file index.html nel browser, vedrai subito una dashboard moderna, ben strutturata, con stile pulito, KPI card e metriche segnaposto realistiche. 

I filtri, le interazioni della tabella e le opzioni di download funzionano tutte fluidamente out of the box.

Scorrendo verso il basso, la dashboard include anche dati di transazioni dettagliati con circa 150 record fittizi, rendendola simile a un vero prodotto di analytics.

Pur non generando ogni possibile visualizzazione (ad esempio, un grafico a linee dei ricavi nel tempo sarebbe un bel plus), resta estremamente notevole che un modello quantizzato in esecuzione locale possa produrre una dashboard funzionale praticamente in un solo passaggio. 

Nel complesso, l'intero sviluppo ha richiesto solo pochi minuti dal prompt all'output funzionante.

Considerazioni finali

Sarò sincero: la mia esperienza con Qwen3-Coder-Next è stata un po' mista.

Sulla carta, le valutazioni suggeriscono che dovrebbe essere vicino a modelli di frontiera come Claude Sonnet 4.5, e l'idea di eseguire in locale un modello MoE da 80B per il coding è davvero entusiasmante. 

In questo tutorial, abbiamo compilato con successo llama.cpp con supporto CUDA, scaricato la quantizzazione Unsloth GGUF, avviato un server di inferenza locale e persino fatto vibe coding di una dashboard di analytics funzionante in pochi minuti. La velocità e la reattività locali sono state impressionanti, soprattutto per un setup open-weight.

Ma nella pratica, non ho visto in modo consistente l'affidabilità “a livello Sonnet” che alcuni benchmark suggeriscono. Ho passato un paio d'ore cercando di usare il modello in ambienti agent più complessi come opencode, e ho continuato a incontrare problemi come errori degli strumenti, generazioni instabili e occasionali loop negli output.

Interessante notare che il modello è sembrato molto più affidabile quando sono passato a un flusso di lavoro più semplice usando la Qwen Code CLI. In quel contesto, si è comportato bene per task di coding diretti, prototipazione rapida e sessioni di vibe coding. È stato fluido, veloce e davvero divertente da usare in locale.

La mia conclusione: Qwen3-Coder-Next vale assolutamente la pena di essere provato, soprattutto se vuoi un potente assistente di coding locale senza API cloud. Ma non lo consiglierei ancora come sostituto completo di agent di coding da produzione, a meno che tu non sia pronto a investire tempo in debug, tuning delle impostazioni di llama.cpp e ottimizzazione delle prestazioni per il tuo hardware.

Se ti interessa approfondire l'uso dell'AI nei tuoi flussi di lavoro, ti consiglio di dare un'occhiata al corso AI-Assisted Coding for Developers.