Come eseguire Muse Glimmer 30B in locale per il coding con l’IA

Come abbiamo visto nel nostro post sul blog, Muse Glimmer 30B è un nuovo modello open pensato per carichi agentici e di coding. 

Ciò che lo rende particolarmente interessante è che puoi eseguire l’intera configurazione in locale su una singola NVIDIA RTX 5090 con 32 GB di VRAM usando llama.cpp.

Il modello è disponibile in formato GGUF e, per questa guida, userò la quantizzazione dinamica di qualità superiore. 

La configurazione completa è composta da:

• muse-glimmer-30B-kquant-dynamic.gguf: 19,7 GB modello principale
• dflash-kquant.gguf: 1,63 GB modello di bozza per speculative decoding
• mmproj-kquant.gguf: 1,4 GB encoder di visione e percezione

Secondo la model card, la quantizzazione dinamica da 19,7 GB ha solo circa lo 0,2% di degradazione nei benchmark rispetto alla piena precisione. 

Nei miei test, eseguire il modello con una finestra di contesto da 64K ha usato circa 24 GB di VRAM, lasciando un margine utile sulla RTX 5090.

In questa guida imparerai a:

1. Compilare llama.cpp con supporto CUDA
2. Scaricare ed eseguire Muse Glimmer 30B in locale
3. Abilitare DFlash speculative decoding e input visivo
4. Testare il modello tramite API e Web UI integrata
5. Collegare il modello locale a OpenCode
6. Usare Muse Glimmer per creare e fare debug di un’app completa

Alla fine, avremo anche un’idea pratica di dove Muse Glimmer si comporta bene come modello di coding locale e dove invece fatica. Ti consiglio anche di dare un’occhiata alla nostra guida a Muse Spark 1.3 per scoprire le ultime novità.

1. Configura llama.cpp per l’inferenza su GPU

Prima di eseguire Muse Glimmer in locale, dobbiamo prima compilare llama.cpp con supporto CUDA così che il modello possa usare la GPU RTX 5090.

Inizia installando i pacchetti di sistema richiesti:

apt-get update

apt-get install -y \
    build-essential \
    cmake \
    curl \
    git \
    libcurl4-openssl-dev

Poi clona il repository di llama.cpp e spostati nella cartella del progetto:

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

Configura la build con CUDA abilitato:

cmake -B build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Ora compila gli strumenti da riga di comando, la CLI multimodale e il server:

cmake --build build --config Release -j \
    --target llama-cli llama-mtmd-cli llama-server

Una volta terminata la build, rendi llama-server disponibile globalmente così puoi eseguirlo da qualunque directory:

ln -sf "$(pwd)/build/bin/llama-server" /usr/local/bin/llama-server

Infine, conferma che l’installazione funzioni:

llama-server --version

Dovresti vedere un output simile a:

version: 10373 (38406d597)
built with GNU 13.3.0 for Linux x86_64

A questo punto, llama.cpp è compilato con supporto CUDA e llama-server è pronto a eseguire Muse Glimmer sulla GPU.

2. Scarica Muse Glimmer

Ora scarica il modello principale Muse Glimmer insieme ai file GGUF aggiuntivi necessari per lo speculative decoding e l’input visivo.

Per prima cosa, installa la CLI di Hugging Face:

pip install -U huggingface_hub

Poi accedi al tuo account Hugging Face:

hf auth login

Scegli l’opzione di login tramite browser, apri la pagina di autorizzazione e approva la connessione nel browser.

Ora scarica i tre file richiesti:

hf download meta-models/Muse-Glimmer-30B-GGUF \
    --local-dir Muse-Glimmer-30B-GGUF \
    --include "muse-glimmer-30B-kquant-dynamic.gguf" \
    --include "dflash-kquant.gguf" \
    --include "mmproj-kquant.gguf"

Questo scarica:

• muse-glimmer-30B-kquant-dynamic.gguf: il modello principale da 19,7 GB
• dflash-kquant.gguf: il modello di bozza usato per lo speculative decoding
• mmproj-kquant.gguf: l’encoder di percezione richiesto per l’input di immagini

I file sono piuttosto grandi, quindi il download può richiedere del tempo a seconda della tua connessione internet.

Una volta scaricati tutti e tre i file, avrai tutto il necessario per eseguire Muse Glimmer con generazione di testo, supporto visivo e DFlash speculative decoding.

3. Metti in servizio Muse Glimmer con Vision e Speculative Decoding

Con tutti e tre i file GGUF scaricati, possiamo ora avviare Muse Glimmer usando llama-server.

Il comando seguente carica il modello principale, abilita il modello di bozza DFlash per lo speculative decoding e aggiunge l’encoder di percezione per l’input visivo:

llama-server \
    -m /workspace/Muse-Glimmer-30B-GGUF/muse-glimmer-30B-kquant-dynamic.gguf \
    -md /workspace/Muse-Glimmer-30B-GGUF/dflash-kquant.gguf \
    --mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf \
    --spec-type draft-dflash \
    --spec-draft-n-max 15 \
    -ngl 99 \
    --spec-draft-ngl all \
    -fa on \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 64 \
    --ctx-size 64000 \
    --alias muse-glimmer-30B \
    --host 0.0.0.0 \
    --port 8910 \
    --jinja

Questa configurazione usa una finestra di contesto da 64K, scarica il modello sulla GPU, abilita la Flash Attention ed esegue il server sulla porta 8910.

Una volta caricato il modello, sarà disponibile su:

http://127.0.0.1:8910

Puoi confermare che tutto funzioni correttamente inviando una semplice richiesta all’API compatibile con OpenAI:

curl -s http://127.0.0.1:8910/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "muse-glimmer-30B",
        "messages": [
            {
                "role": "user",
                "content": "Explain speculative decoding in three simple sentences."
            }
        ]
    }'

In questo test, Muse Glimmer ha generato 364 token di completamento a 83,94 token/secondo, mentre il prompt è stato elaborato a 147,48 token/secondo. 

Con DFlash speculative decoding abilitato, il modello di bozza ha proposto 1.665 token, di cui 253 accettati, per un tasso di accettazione di circa 15,2%. 

Il prompt da 64 token è stato elaborato in circa 434 ms, mentre la generazione ha richiesto approssimativamente 4,34 secondi. 

La risposta conferma che il modello è in esecuzione correttamente tramite l’API locale.

Puoi anche verificare quanta memoria GPU sta usando l’intera configurazione:

nvidia-smi

Con modello 30B quantizzato dinamicamente, modello di bozza DFlash, encoder di visione e finestra di contesto da 64K caricati insieme, la mia configurazione ha usato circa 23,8 GB di VRAM sulla RTX 5090.

Questo lascia circa 8 GB di VRAM disponibili, dandoci margine per sperimentare in seguito con finestre di contesto più grandi.

4. Testa Muse Glimmer nella Web UI con prompt di visione e coding

llama-server include una Web UI integrata, che rende semplice testare il modello senza inviare richieste API manualmente.

Apri:

http://127.0.0.1:8910

Puoi usare l’interfaccia per prompt testuali, comprensione di immagini e rapidi esperimenti di coding.

Dato che abbiamo caricato l’encoder di visione con:

--mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf

Muse Glimmer può anche accettare input di immagini.

Per testare la capacità visiva, ho caricato la copertina di uno dei miei libri e ho usato il seguente prompt:

Describe what you see in this image and point out the most important details.

Il modello ha prodotto una descrizione dettagliata della copertina e ha colto anche diversi elementi visivi minori. 

È stato un primo test utile per confermare che l’encoder di visione funzionasse correttamente.

Successivamente, ho testato la sua capacità di coding con un semplice task di generazione di un sito web:

Build a modern luxury watch website for VELORÉ, 
with a minimalist V logo, black/ivory/deep-green palette, 
cinematic hero, premium watches, smooth animations, 
and elegant Swiss-inspired styling.

Durante questo task di coding, la generazione ha avuto una media di circa 121 token al secondo, sensibilmente più veloce rispetto al precedente test di testo generale. 

DFlash speculative decoding sembrava funzionare particolarmente bene per questo tipo di generazione di codice sequenziale.

Il modello ha generato un sito di orologi di lusso utilizzabile. 

C’erano comunque alcuni problemi nell’output finale, il che non sorprende troppo per un modello da 30B, ma è riuscito a produrre un progetto completo molto rapidamente.

Muse Glimmer è presentato come un modello di coding agentico, quindi il test più importante è come si comporta quando deve creare file, eseguire comandi, testare il proprio lavoro e correggere i problemi. Lo testeremo ora collegandolo a OpenCode.

5. Collega Muse Glimmer a OpenCode e testa il coding agentico

Ora che Muse Glimmer è in esecuzione in locale, il passo successivo è collegarlo a OpenCode e vedere come si comporta come modello di coding agentico.

Per prima cosa, installa OpenCode:

curl -fsSL https://opencode.ai/install | bash

Ricarica la shell e conferma l’installazione:

exec bash
opencode --version

Per questo test, stavo usando:

1.18.16

Crea la directory di configurazione di OpenCode:

mkdir -p ~/.config/opencode

Invece di aprire un editor di testo, crea il file di configurazione direttamente dal terminale:

cat > ~/.config/opencode/opencode.json <<'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Muse Glimmer Local",
      "options": {
        "baseURL": "http://127.0.0.1:8910/v1"
      },
      "models": {
        "muse-glimmer-30B": {
          "name": "Muse Glimmer 30B"
        }
      }
    }
  },
  "model": "llama.cpp/muse-glimmer-30B"
}
EOF

Questo dice a OpenCode di usare l’API compatibile con OpenAI esposta dal nostro llama-server locale.

Poi crea un nuovo progetto:

mkdir muse-app
cd muse-app
git init
opencode

OpenCode avvierà la sua interfaccia da terminale con Muse Glimmer 30B già configurato come modello principale.

Crea un’app completa

Per testare il modello su qualcosa di più realistico, gli ho chiesto di costruire un’app per la ricerca medica:

Build a modern medical AI web app called MedSearch AI.
Use Python FastAPI for the backend and HTML, CSS and JavaScript for the frontend.
Create a clean dark interface where users can ask medical research questions. 
Send prompts to my local Muse Glimmer server at:http://127.0.0.1:8910/v1/chat/completions
Add web search for the latest reliable medical information, show sources clearly, 
support streaming responses and Markdown, and include a clear-chat button and server status indicator.

Create all files, install dependencies, test the app, and tell me how to run it.

Il risultato iniziale è stato notevole. Ha impiegato solo circa un minuto per generare l’intero progetto. 

Ha creato backend, frontend, dipendenze e struttura complessiva dell’app molto rapidamente.

Poi gli ho chiesto di testare sia il backend sia la UI.

Qui ho iniziato a notare le debolezze del modello.

Veloce nella creazione, più debole nel debugging

Su benchmark di coding artificiali, Muse Glimmer ha un posizionamento simile al modello Qwen3.6 27B , ma dai miei test pratici, lo trovo sensibilmente peggiore quando si tratta di lavorare davvero su un task di coding.

Il problema più grande è stato il debugging.

Muse Glimmer era molto veloce nel creare un progetto completo da zero, ma quando qualcosa andava storto, faticava a risolvere il problema in autonomia. Poteva passare molto tempo provando cose diverse senza fare grandi progressi.

Alla fine ho dovuto dirgli esattamente cosa fare. 

Per esempio, gli ho detto esplicitamente di:

1. Avviare il server backend in background.
2. Aspettare che il server sia disponibile.
3. Inviare una richiesta all’applicazione in esecuzione.
4. Verificare la risposta.
5. Correggere eventuali errori riscontrati.
6. Testare di nuovo l’applicazione.

Una volta date queste istruzioni concrete, ha compreso il compito e le ha seguite con successo.

Questa è probabilmente la lezione più importante che ho tratto usando Muse Glimmer con OpenCode. 

Devi essere molto esplicito su ciò che vuoi che faccia. 

Invece di dire "testa l’applicazione" o "risolvi il problema", funziona molto meglio quando descrivi l’esatta sequenza di azioni che dovrebbe compiere.

Il prompt engineering è quindi particolarmente importante con questo modello.

L’applicazione finale

Dopo aver superato i problemi di debugging, l’applicazione MedSearch AI risultante ha funzionato molto bene.

L’app era veloce, ricca di funzionalità e sorprendentemente semplice. 

Ha usato un backend FastAPI leggero con semplice HTML, CSS e JavaScript invece di affidarsi a un grande framework frontend.

Quella semplicità è stata in realtà uno degli aspetti che ho apprezzato del risultato. 

Muse Glimmer ha creato un’app IA funzionale senza introdurre complessità non necessaria.

La mia esperienza finora è che Muse Glimmer è eccellente nel generare rapidamente molto codice funzionante, ma è molto meno affidabile quando deve diagnosticare problemi, pianificare il debugging in più passaggi e riprendersi autonomamente dai fallimenti.

Per il coding locale, questa distinzione conta. 

Se gli dai istruzioni chiare e dettagliate, può essere molto capace. 

Se ti aspetti che capisca autonomamente ogni passaggio, soprattutto durante il debugging, i limiti diventano molto più evidenti.

Considerazioni finali

Muse Glimmer 30B è ancora un modello molto nuovo, e questo è emerso nei miei test. 

È stato molto veloce nel generare codice, ma ha faticato di più con il debugging e i compiti multi-step. Spesso ho dovuto dirgli esattamente cosa fare prima che potesse procedere.

Anche con questi problemi, penso che il modello abbia molto potenziale. 

Con prompt migliori e futuri miglioramenti, lo vedo diventare un modello di coding locale molto usabile, in linea con la mia esperienza con Qwen3.6 27B.

Penso anche che questa sia un’ottima direzione per Meta AI. 

C’è un chiaro interesse per gli agenti di coding locali perché possono offrire:

• Costi inferiori, senza addebiti API
• Maggiore privacy per il tuo codice e i tuoi dati
• Più controllo sull’output
• La possibilità di lavorare in locale senza dipendere da un’API di modelli esterna

Nella mia configurazione, il modello ha usato circa 24 GB di memoria GPU, il che lo rende praticabile per hardware locale di fascia alta. 

Puoi anche eseguire modelli come questo con memoria di sistema o unificata, sebbene le prestazioni saranno inferiori.

In questa guida, abbiamo compilato llama.cpp, scaricato i file GGUF di Muse Glimmer, abilitato visione e speculative decoding, testato l’API e la Web UI e collegato il modello a OpenCode. 

Lo abbiamo anche usato per creare e testare un’app completa. 

La mia principale conclusione è che Muse Glimmer è molto veloce nel creare codice, ma ha ancora bisogno di istruzioni chiare quando fa debugging o gestisce compiti agentici più complessi.