Proudly debugging the system since 1981

Tag: strata

RustingStrata: raddoppiare le prestazioni dell’AI locale con una RTX 3060

Qualche settimana fa avevo raccontato la mia esperienza con Strata, un progetto che mi aveva incuriosito per la possibilità di utilizzare modelli AI di grandi dimensioni su un normale PC, senza ricorrere a servizi cloud.

L’esperimento era stato positivo: con una NVIDIA RTX 3060 da 12 GB ero riuscito a utilizzare un modello con un contesto molto ampio, ottenendo prestazioni interessanti per una configurazione hardware consumer.

Recentemente mi sono imbattuto in RustingStrata, un progetto che affronta lo stesso problema con un’implementazione completamente diversa: un motore di inferenza scritto in Rust, progettato per sfruttare CPU e GPU in modo ibrido.

La curiosità era inevitabile: quanto poteva cambiare rispetto a Strata?

RustingStrata: un motore di inferenza scritto in Rust

RustingStrata è un progetto open source che permette di eseguire modelli GGUF sfruttando contemporaneamente CPU e GPU.

L’aspetto interessante è la gestione dei modelli Mixture of Experts (MoE). Non tutti i parametri di questi modelli vengono utilizzati per elaborare ogni token: RustingStrata sfrutta questa caratteristica mantenendo sulla GPU gli esperti che riesce a ospitare nella VRAM e gestendo gli altri attraverso la memoria di sistema.

Il posizionamento degli esperti viene inoltre adattato dinamicamente in base al loro effettivo utilizzo.

Il risultato è la possibilità di utilizzare modelli molto più grandi della memoria video disponibile, senza dover rinunciare completamente all’accelerazione GPU.

Il progetto supporta sia CUDA sia Vulkan. Nel mio caso, naturalmente, ho scelto CUDA.

Installazione: qualche ostacolo con CUDA

L’installazione su Windows è abbastanza semplice: il progetto è scritto in Rust e può essere compilato direttamente dai sorgenti con Cargo.

cargo build --release

Il primo problema è arrivato proprio con CUDA.

Sul PC avevo già installato il CUDA Toolkit 12.8, ma RustingStrata utilizza cudarc e richiede le librerie NVRTC della versione CUDA 13. Inizialmente il motore non riusciva a inizializzare CUDA e ripiegava automaticamente su Vulkan.

La soluzione è stata scaricare dal sito NVIDIA il pacchetto standalone NVRTC 13.1, senza dover sostituire l’intera installazione del CUDA Toolkit.

Ho estratto le DLL in:

C:\AI\CUDA\13.1

E ho aggiunto la directory al PATH prima di avviare il programma:

set "PATH=C:\AI\CUDA\13.1;%PATH%"

Le librerie necessarie erano nvrtc64_130_0.dll e nvrtc-builtins64_131.dll.

A quel punto CUDA è stato inizializzato correttamente e i kernel sono stati compilati per l’architettura sm_86 della RTX 3060.

Il problema della calibrazione

Superato il problema CUDA, mi sono imbattuto in un secondo ostacolo.

RustingStrata dispone di un comando calibrate che misura le prestazioni del sistema e individua alcuni parametri ottimali per l’esecuzione del modello.

La prima esecuzione terminava però con un errore di copia in memoria GPU:

Error: htod: 4128768 bytes at 77660160 into 80216064

Ho provato a modificare il contesto, il margine di VRAM e il formato della KV cache, senza successo.

Analizzando il codice sorgente ho individuato una possibile causa: durante la calibrazione il modello veniva caricato con tre draft MTP, una funzionalità utilizzata per la speculative decoding.

Ho quindi modificato temporaneamente il parametro nella chiamata a GpuModel::load, passando da 3 a 0, disabilitando MTP durante la calibrazione.

Dopo aver ricompilato il progetto, calibrate è finalmente terminato correttamente, generando il file JSON con i parametri misurati.

Non ho approfondito ulteriormente la causa dell’errore, ma il workaround è stato sufficiente per completare la configurazione.

Il benchmark: 121K token, stesso hardware e stesso modello

Arriviamo alla parte più interessante.

Per confrontare i due motori ho utilizzato lo stesso test già eseguito con Strata: un prompt di circa 121.000 token, costruito sul classico scenario “Ago in un pagliaio”.

L’obiettivo è verificare se il modello riesce a recuperare informazioni specifiche nascoste all’interno di una grande quantità di testo.

Per rendere il confronto significativo ho mantenuto invariati:

  • Hardware: AMD Ryzen 5 9600X, 32 GB DDR5 e NVIDIA RTX 3060 da 12 GB.
  • Modello: Ornith-1.5-35B-A3B-IQ4_XS.gguf.
  • Prompt e domande.

I risultati sono stati decisamente interessanti.

MetricaStrataRustingStrata
Prompt121K token121K token
Prefill340 tok/s730 tok/s
Generazione~30 tok/s~30 tok/s
Risposte corretteSìSì

La differenza più evidente riguarda il prefill, cioè la fase in cui il motore legge ed elabora il prompt prima di iniziare a generare la risposta.

RustingStrata raggiunge circa 730 token al secondo contro i 340 di Strata: più del doppio, con un incremento di circa il 115%.

La velocità di generazione è invece sostanzialmente identica, intorno ai 30 token al secondo per entrambi i motori.

Non attribuirei però particolare significato a quest’ultimo dato: il test “Ago in un pagliaio” è pensato soprattutto per verificare la capacità di recuperare informazioni da un contesto molto esteso. I pochi token generati non permettono di valutare in modo significativo le prestazioni di decoding.

Un altro elemento importante è che entrambi i motori hanno fornito le risposte corrette. Non ho quindi osservato, in questo test, un peggioramento della capacità di recupero delle informazioni passando a RustingStrata.

Considerazioni finali

Il risultato mi ha sorpreso positivamente.

Il dato che considero più significativo non è tanto la velocità di generazione, rimasta sostanzialmente invariata, quanto il tempo necessario per elaborare il contesto.

Quando si utilizza un coding agent, oppure si sottopone al modello una grande quantità di codice, documentazione o cronologia delle conversazioni, il prefill può rappresentare una parte importante del tempo di attesa.

Passare da 340 a 730 token al secondo significa ridurre sensibilmente questa attesa.

Naturalmente un singolo test non è sufficiente per stabilire che RustingStrata sia sempre più veloce di Strata in qualsiasi scenario. Servirebbero ulteriori benchmark con prompt di dimensioni differenti.

Ma il risultato ottenuto sulla mia macchina è concreto: stesso modello, stesso prompt, stesso hardware e risposte corrette da entrambi i motori.

Per il momento RustingStrata ha conquistato il posto di motore principale per le mie prove di AI locale.

E pensare che tutto questo gira su una RTX 3060 da 12 GB!

Il coding locale continua a diventare sempre più interessante.

Strata: coding locale con una RTX 3060

Un modello da circa 180 miliardi di parametri, sul mio PC, con una RTX 3060 da 12 GB. È questa la promessa che mi ha incuriosito e mi ha spinto a provare Strata: dopo una prima sessione di coding, la sensazione è di aver fatto un passo avanti concreto rispetto ai modelli che usavo finora in locale.

Non è soltanto una questione di riuscire ad avviare un modello molto grande. Il punto è riuscire a usarlo con velocità accettabili, un contesto ampio e una qualità che lo renda interessante anche per lavorare sul codice.

Che cos’è Strata

Strata è un progetto gratuito e open source che permette di eseguire Qwen3.8-Flash-Next su hardware consumer, distribuendo il lavoro tra GPU, CPU, RAM e SSD. Offre un’interfaccia web e API locali compatibili con OpenAI e Anthropic, così da poter collegare applicazioni e coding agent senza ricorrere a un servizio di inferenza cloud.

Il modello di partenza è notevole: Qwen3.8-Flash-Next conta circa 180 miliardi di parametri complessivi, includendo le componenti n-gram e quelle dedicate alla predizione di più token. Non è però un modello denso di quelle dimensioni: adotta un’architettura Mixture of Experts, che attiva solo una parte degli esperti per ciascun token. Il contesto nativo arriva a 262.144 token.

Strata sfrutta queste caratteristiche per rendere possibile l’esecuzione su un normale PC. La GPU mantiene gli esperti usati più frequentemente, mentre RAM e CPU gestiscono il resto; una grande tabella di lookup risiede invece sull’SSD. Non serve, quindi, far entrare tutto il modello nella VRAM.

I requisiti dichiarati partono da una GPU supportata con almeno 12 GB di VRAM, 32 GB di RAM e circa 80 GB liberi su disco, preferibilmente SSD. Il progetto supporta Windows e Linux e propone diverse varianti del modello in funzione della memoria disponibile.

Il mio PC e il modello

Ho provato Strata su questa configurazione:

ComponenteHardware
CPUAMD Ryzen 5 9600X
RAM32 GB DDR5
ArchiviazioneSSD PCIe Gen4
GPUNVIDIA RTX 3060, 12 GB di VRAM
Modello selezionatoCoder

Con 32 GB di RAM ho scelto la variante Coder, che è anche quella consigliata dal progetto per questa quantità di memoria.

La versione Coder di ISTA-DASLab non è semplicemente una quantizzazione del modello completo: combina la riduzione di precisione dei pesi con il pruning, cioè la rimozione di metà degli esperti. La selezione privilegia le capacità legate al codice e all’uso agentico degli strumenti, accettando una perdita maggiore in altri ambiti.

Il dato interessante è quanto riesca a conservare nei benchmark dichiarati dagli autori: il 91,3% del punteggio del modello originale su SWE-bench Verified e il 98,7% su LiveCodeBench v6. Quindi “oltre il 90% delle capacità” va inteso in relazione a questi test di coding, non come una misura universale dell’intelligenza del modello.

Le prestazioni sul campo

Sul mio PC ho osservato circa 300 token al secondo in prefill, cioè nella lettura del prompt, e circa 30 token al secondo in generazione. Per il modello e l’hardware in gioco, considero queste prestazioni molto buone.

A fine prova, le statistiche erano queste:

MetricaRisultato
Richieste complessive75
Token di prompt elaborati284.200
Velocità media di prefill286 token/s
Token riutilizzati dalla cache4.335.358
Token generati68.865
Velocità media di generazione30,6 token/s

Sono numeri raccolti durante l’utilizzo, non un benchmark controllato. Descrivono però bene la mia esperienza: la velocità di generazione è sufficiente a rendere il modello concretamente utilizzabile, non soltanto interessante da provare.

La cache è uno degli aspetti che mi hanno colpito di più. Nel corso delle 75 richieste, oltre 4,3 milioni di token sono stati riutilizzati, contro circa 284 mila token effettivamente elaborati in prefill.

Dal punto di vista del tempo di rilettura, quei token recuperati dalla cache sono stati praticamente “gratis”. Nella mia sessione questo ha fatto una differenza importante: il contesto poteva crescere senza dover pagare ogni volta il costo di elaborarlo nuovamente per intero.

Coding con OpenCode

Per andare oltre la semplice chat, ho fatto una breve sessione di coding usando OpenCode come harness.

La compressione un po’ si percepisce. Non ho avuto la sensazione di usare il modello originale senza compromessi, e sarebbe prematuro trarre conclusioni definitive da una prova così breve. Detto questo, nella mia esperienza è andato meglio di qualsiasi altro modello locale che abbia usato finora.

Il riferimento precedente era Qwen 3.6 31B, insieme ai relativi fine-tuning e alle diverse quantizzazioni. Rispetto a quella base, Strata con il modello Coder mi è sembrato un netto passo avanti.

Anche il contesto merita attenzione: nella mia configurazione avevo a disposizione 256K token e durante la prova sono arrivato a usarne circa 100K. Non ho quindi verificato il comportamento al limite massimo, ma non ho dovuto ridurre drasticamente la finestra di contesto per rendere il modello utilizzabile sul mio hardware.

Come riferimento cloud uso molto, ultimamente, DeepSeek 4.1 Flash. È il livello di qualità che avevo in mente avvicinandomi a questa prova, ma non ho svolto un confronto diretto e controllato: non considero quindi questa sessione una dimostrazione di equivalenza tra i due.

Un passo avanti concreto

La parte più interessante di questa esperienza è l’insieme: qualità del codice, circa 30 token al secondo in generazione, un contesto ampio e una cache che nella pratica funziona molto bene.

La compressione comporta dei compromessi, e la mia resta una prima prova. Ma il risultato non è più soltanto “un modello enorme che in qualche modo gira sul PC”: è un modello che ho potuto usare dentro un coding agent, con prestazioni convincenti, su una macchina con 32 GB di RAM e una RTX 3060 da 12 GB.

Per il mio utilizzo, Strata rappresenta un salto concreto rispetto a Qwen 3.6 31B e alle varianti che usavo prima. Non significa che abbia già sostituito i modelli cloud nel mio flusso di lavoro; significa però che il coding locale è diventato un’alternativa molto più credibile.

© 2026 b0sh.net

Tema di Anders Noren — Su ↑