A settembre mi è passato davanti un video: 744 miliardi di parametri su un portatile, senza scheda video. Il motore esiste, si chiama Colibrì ed è open source. Il video si fermava al momento in cui il modello parte; a me interessava sapere se vale la pena scaricare decine di giga per provarci sul mio PC.
Ho preso il candidato più ragionevole per la mia macchina, DeepSeek V4 Flash potato a 150 miliardi di parametri, 84,7 GB contro i circa 372 del modello del video, e l’ho fatto girare solo sul processore. Gira, a meno di un token al secondo: per spiegare in tre frasi cos’è un reverse proxy ci ha messo tre minuti, fermandosi a metà della terza. E nelle quattro prove che gli ho fatto, su questa versione potata, non ha mai risposto in italiano, nemmeno col ragionamento acceso.
Per accelerarlo verrebbe da pensare a più RAM o a un disco più veloce. Le misure dicono altro: durante la generazione processore e disco lavorano a metà, e il motore aspetta.
Un modello da 85 GB ci sta in 32 GB di RAM perché gran parte resta sul disco
DeepSeek V4 Flash è un modello a esperti: 43 strati, in questa versione 132 «esperti» per strato, e per ogni token ne lavorano 6. Colibrì tiene in RAM la parte che serve sempre, 6,7 GB, e lascia sul disco gli esperti, 75,9 GB in blocchi da 13,4 MB, tenendo in RAM i più usati. Il conto che spiega il resto: 6 esperti per 43 strati fa 258 esperti per token, cioè 3,4 GB da prendere se nessuno è già in RAM.
| Componente | Cosa |
|---|---|
| Processore | Intel i7-11700K, 8 core / 16 thread |
| RAM | 31,8 GB |
| Disco | Samsung 980 PRO 1 TB NVMe |
| Scheda video | GTX 970, non usata |
La GTX 970 resta fuori: l’archivio di Colibrì per Windows non ha la libreria per le NVIDIA, e il motore lo scrive all’avvio.
[DSV4 CUDA] no usable backend DLL (coli_cuda_dsv4_dg.dll / coli_cuda_dsv4.dll); GPU tier disabled (CPU path remains active).Il README chiede comunque una NVIDIA «dalla serie GTX 10 in su», e la 970 è di una generazione prima. Il server del 2013 della serie sull’IA locale non ci arriva nemmeno: ha 8 GB di RAM, il README ne chiede almeno 16.
Quanto va: meno di un token al secondo
| Prova | Token | Tempo totale | Attesa del primo token | Token/s sul totale | Token/s dopo il primo |
|---|---|---|---|---|---|
| Domanda breve, prima prova | 16 | 40,5 s | 19,1 s | 0,40 | 0,70 |
| Domanda breve, 4 ripetizioni | 16 | 38,0-40,5 s | 19,2-20,7 s | 0,40-0,42 | 0,76-0,80 |
| Reverse proxy | 120 | 182,3 s | 24,0 s | 0,66 | 0,75 |
| Container che si riavvia | 120 | 190,8 s | 27,4 s | 0,63 | 0,73 |
Il tempo si divide in due: una ventina di secondi per leggere la domanda, poi tre quarti di token al secondo. Sono le due fasi, prefill e decode, che avevo misurato sull’homeserver nell’articolo sul processore per un’IA locale. I tre minuti del reverse proxy valgono per una risposta incompleta: si è fermata a «making your hom» perché il limite di 120 token l’avevo messo io. La conseguenza pratica è che anche una risposta di tre frasi si aspetta per minuti.
Il piano diceva di no: non fermarti ai valori predefiniti
Prima di partire, coli plan stima quanti esperti riuscirà a tenere in RAM:
| RAM concessa al motore | Residenza prevista dal piano |
|---|---|
| predefinita (9 GB) | 0% |
| 15 GB | 1% |
| 24 GB | 13% |
Alla prova, con 15 GB, gli esperti trovati in RAM sono stati il 34,5%, e il 38-39% nelle ripetizioni. Il motore si dimensiona da solo: trova 12 posti per strato, 6,9 GB di cache, dove il piano ne prevedeva zero, perché conta la parte fissa a 6,7 GB e il piano a 8,8. In più ricorda gli esperti usati nelle esecuzioni precedenti: per questo le ripetizioni ne trovano di più in RAM, pur senza finire prima.
A 9 GB non ho lanciato nessuna generazione: la lezione riguarda il piano, che prometteva zero. È la stessa dell’auto-fit di Ollama che spreca la GPU: un motore provato coi valori predefiniti può sembrare rotto senza esserlo.
Due giga di RAM in più: meno disco, stesso tempo
Quattro prove con la stessa domanda e gli stessi parametri, alternando 15 e 17 GB per non regalare la cache di Windows a una sola delle due:
| Prova | RAM | Posti in cache per strato | Esperti trovati in RAM | Dati letti | Tempo |
|---|---|---|---|---|---|
| 1 | 15 GB | 12 | 38,4% | 48,7 GB | 40,4 s |
| 2 | 17 GB | 16 | 43,9% | 44,3 GB | 40,5 s |
| 3 | 15 GB | 12 | 39,0% | 48,2 GB | 38,0 s |
| 4 | 17 GB | 16 | 44,2% | 44,1 GB | 39,6 s |
Media: 39,2 secondi a 15 GB, 40,0 a 17 GB. Cinque punti di esperti in RAM in più, il 9% di dati in meno da leggere, zero secondi guadagnati, stesso testo generato. Due giga in più non hanno cambiato niente; sopra i 17 non ho dati, perché Windows non mi ha lasciato andare oltre. Anche in quanta RAM serve per un’IA locale più memoria non accelerava, ma per un motivo diverso.
Su Windows il tetto lo mette la memoria impegnata
Con 21,6 GB di RAM libera, Colibrì rifiutava 18 GB. Conta la memoria che Windows può ancora concedere (RAM più file di paging, meno quanto i programmi hanno già prenotato): sul mio PC 17,7 GB, con un paging di 2 GB. Allargarlo alzerebbe il tetto; non l’ho fatto.
Processore e disco a metà: il motore aspetta
Durante le due risposte lunghe ho campionato processore e disco ogni 3 secondi circa. Sul reverse proxy il campionamento è partito 36 secondi dopo il lancio, a domanda già letta; sul container include la lettura della domanda, quindi i due massimi non si confrontano.
| Cosa | Reverse proxy (50 campioni) | Container (65 campioni) |
|---|---|---|
| CPU usata dal motore, media / massimo | 37,4% / 54% | 37,5% / 64% |
| CPU totale del PC, media | 51% | 49% |
| Lettura dal disco, media / mediana / massimo | 893 / 928 / 1.452 MB/s | 1.012 / 965 / 2.643 MB/s |
| Coda del disco, mediana / massimo | 0 / 3 | 0 / 3 |
Il motore ha 13 thread di calcolo su 16 e ne usa in media l’equivalente di sei. Il disco legge in media intorno a 1 GB/s con la coda quasi sempre vuota, e prima del primo token della seconda prova ha toccato 2,6 GB/s. Nessuna delle due risorse è al limite. Sull’homeserver era il processore a stare al massimo.
Cosa lo frena, allora? L’ipotesi più probabile, non dimostrata, è che il motore lavori uno strato alla volta: sceglie gli esperti, li carica, calcola, passa oltre. Così attesa del disco e calcolo si sommano invece di sovrapporsi, e la leva starebbe nel motore. È coerente con l’A/B: meno letture, stesso tempo. Io non ho trovato un componente al limite.
E le risposte? Quattro prove, nessuna in italiano
Reverse proxy. Risposta corretta e in tre frasi come chiesto, ma in inglese:
A reverse proxy is a server that sits in front of backend services and forwards client requests to the appropriate internal server, acting as a single entry point for external traffic.Container che si riavvia, con «Rispondi in italiano» scritto nella domanda: nessuna risposta. Il modello ripete la domanda storpiata, «Il meu container Docker si riavvia in continuazione…», quattro volte intere più l’inizio di una quinta, finché finiscono i 120 token.
La domanda breve della prima prova: un titolo che ricopia la domanda, «Homeserver Docker Services – Elenca in una Riga», e poi «Aquí está».
La stessa domanda sul container, col ragionamento acceso. Il comando lo tiene spento di partenza: l’ho riacceso, con lo stesso file e la stessa RAM, e un tetto di 800 token. Risultato: «Il», e poi la parola «eloquer», che non esiste né in italiano né in inglese, ripetuta fino al tetto. Diciannove minuti e mezzo, alla stessa velocità delle altre prove (0,70 token al secondo dopo il primo), per nessuna risposta. Se la colpa sia del checkpoint potato o di come il motore imposta il ragionamento su questo modello, non lo so: so solo che acceso non ha aiutato.
Quattro prove sono un campione minuscolo, tre col ragionamento spento e una acceso, tutte su un checkpoint potato con 132 esperti su 256. Il verdetto «in italiano non risponde» vale per questo file e per queste domande; il modello completo potrebbe comportarsi diversamente. Un indizio c’è: secondo la scheda del checkpoint, gli esperti da tenere sono stati scelti su un campione «30% math / 70% code», e il risultato è misurato solo su matematica e codice. Che l’italiano sia stato sacrificato così è un’ipotesi, non verificata.
Gira davvero, e serve a vederlo girare
150 miliardi di parametri girano su un PC di casa senza scheda video: a meno di un token al secondo e, nelle mie quattro prove su questa versione potata, mai in italiano. Due giga di RAM in più non hanno cambiato il tempo, e disco e processore non sono al limite.
Lo stesso modello, intero, si usa davvero, ma su un’altra macchina. DwarfStar, il motore scritto da Salvatore Sanfilippo, l’autore di Redis, tiene tutti i 256 esperti e li comprime a circa 2 bit, dove il checkpoint che ho provato io ne toglie quasi metà. Il file pesa circa 87 GB, poco più del mio. Secondo la pagina delle prestazioni del progetto, su un M5 Max da 128 GB, con un contesto di 2.048 token, legge il testo in ingresso a 790 token al secondo e scrive a 39; a 65.536 token di contesto scende a 28. Su un DGX Spark, il piccolo computer per l’IA di NVIDIA, sempre da 128 GB, scrive a 18. Sono misure del progetto, io non le ho rifatte. Su quelle macchine il modello sta tutto in una memoria che processore e GPU condividono, e a fare i conti è la GPU; sul mio PC c’erano 32 GB di RAM e il solo processore.
Se hai visto quel video e ti chiedi se scaricare 85 GB: sì se vuoi vederlo girare, no se vuoi usarlo, almeno su un PC come il mio. Con l’hardware che ho in casa, la strada resta un modello piccolo in una scheda video piccola, come la GTX 750 Ti che avevo dimenticato nel case: la trovi nella serie sull’IA locale su hardware di recupero.
Domande frequenti
Si può far girare un LLM enorme senza GPU?
Sì, se è un modello a esperti e il motore legge gli esperti dal disco man mano che servono. Su questo PC, meno di un token al secondo.
Aggiungere RAM lo fa andare più veloce?
Fra 15 e 17 GB no: il 9% di letture in meno, stesso tempo. Oltre non l’ho provato, perché Windows non concedeva di più.
Serve un disco NVMe?
Ho misurato solo su NVMe, e non era saturo. Su SSD SATA o disco meccanico non l’ho provato, quindi non ti do numeri.
Nota: misure raccolte fra il 22 e il 24 settembre 2026 sul mio PC fisso, con Colibrì v1.12.0 e la GTX 970 montata ma non usata. README e scheda del checkpoint riletti il 24 settembre 2026: il progetto cambia quasi ogni giorno. Pagina delle prestazioni di DwarfStar letta il 4 ottobre 2026.