Ogni tanto su GitHub spunta un progetto che ti fa fermare e rileggere la descrizione due volte. Colibrì è uno di questi: un motore di inferenza scritto in C puro, zero dipendenze, che fa girare GLM-5.2 (un modello da 744 miliardi di parametri) su una macchina consumer con circa 25 GB di RAM. Senza GPU. Senza Python a runtime. Senza nemmeno una libreria BLAS.
Il progetto, pubblicato dallo sviluppatore JustVugg con licenza Apache 2.0, è esploso su Hacker News ed è già oltre le 13.400 stelle su GitHub. E il nome non è un caso: il colibrì pesa pochi grammi ma visita mille fiori al giorno. Motore minuscolo, modello immenso.
Ho passato la serata sul repository e sulla documentazione, e in questa guida ti spiego come funziona il trucco, come si installa passo-passo (evitando l'errore che sta fregando mezza community) e, con i numeri veri alla mano, per chi ha davvero senso Colibrì.
Cos'è Colibrì e perché tutti ne parlano
Colibrì è un runtime per modelli Mixture-of-Experts che tratta VRAM, RAM e disco come un'unica gerarchia di memoria gestita. Tutto il motore sta in un singolo file C di circa 2.400 righe (c/glm.c) più qualche header. Si compila con gcc e OpenMP, e a runtime non serve nient'altro.
Il modello che fa girare è GLM-5.2 di Z.ai (pesi rilasciati sotto MIT), oggi tra i modelli open-weight più forti sui benchmark di coding. Un modello di classe frontier che normalmente richiederebbe un cluster di GPU da decine di migliaia di euro. Colibrì lo fa rispondere, lentamente ma correttamente, su una macchina che, come scrive l'autore, costa meno di una ventola di un H100.
Come funziona il trucco: gli esperti restano su disco
Il segreto sta nell'architettura Mixture-of-Experts di GLM-5.2. Dei 744 miliardi di parametri totali, solo ~40 miliardi si attivano per ogni token. E di questi, solo circa 11 GB cambiano davvero da un token all'altro: sono gli "esperti" instradati dal router del modello.
Colibrì sfrutta questa sparsità dividendo il modello in due parti:
- La parte densa (attention, esperti condivisi, embedding: ~17 miliardi di parametri): resta residente in RAM quantizzata a int4, e occupa solo 9,9 GB;
- I 19.456 esperti instradati (~19 MB l'uno a int4): vivono su disco, circa 370 GB in totale, e vengono caricati in streaming solo quando il router li richiede, con una cache LRU per layer e la page cache del sistema operativo come secondo livello gratuito.
In pratica: invece di comprare 400 GB di VRAM, usi l'NVMe come memoria lenta e paghi il prezzo in velocità. È lo stesso principio che rende sostenibili i modelli open in azienda, di cui ho parlato nell'articolo sui prezzi AI in aumento e come difendersi: quando il fornitore cloud alza i listini, sapere che un'alternativa locale esiste cambia il tuo potere negoziale.
Ci sono anche due chicche che rendono il motore più furbo di quanto sembri: la learning cache registra quali esperti usa davvero il tuo carico di lavoro (file .coli_usage) e all'avvio blocca in RAM i più caldi: Colibrì letteralmente diventa più veloce più lo usi. E la persistenza della KV-cache (.coli_kv) fa riaprire le conversazioni "calde" anche dopo un riavvio: zero re-prefill, validato byte-identico a una sessione mai interrotta.
Requisiti: cosa ti serve davvero
Prima di partire, ecco la lista onesta:
- Sistema operativo: Linux, WSL2, macOS oppure Windows 11 nativo (via MinGW-w64, port recente);
- CPU: x86-64 con AVX2 (su Apple Silicon c'è un backend Metal sperimentale);
- RAM: minimo 16 GB, consigliati 25+ (più ne hai, più esperti restano in cache);
- Disco: ~370-400 GB liberi su un NVMe locale (ext4 o NTFS, mai un mount di rete);
- Toolchain: gcc con OpenMP. Python serve solo per la conversione una tantum del modello.
Nota rassicurante sull'SSD: lo streaming di Colibrì è in sola lettura, e le letture non usurano il drive in modo significativo. I veri rischi sono lo swap (se sfori la RAM) e le temperature su drive economici sotto carico prolungato: monitora le termiche.
Come si installa Colibrì (guida rapida)
Due strade: la conversione fai-da-te o il modello pre-convertito. Ti consiglio la seconda, con un avvertimento importante che vediamo tra poco.
1. Compila il motore
Clona il repository e lancia il setup, che verifica gcc/OpenMP, compila e fa il self-test:
git clone https://github.com/JustVugg/colibri && cd colibri/c && ./setup.sh
2. Scarica il modello giusto (attento alla trappola MTP)
Qui casca l'asino, ed è l'errore più segnalato nelle issue del progetto. Esistono due mirror del modello int4 pre-convertito su Hugging Face, e uno dei due ti dimezza le prestazioni in silenzio.
Colibrì usa lo speculative decoding nativo di GLM-5.2 (la testa MTP, multi-token prediction) per generare 2,2-2,8 token per forward invece di uno. Ma la testa MTP deve essere quantizzata a int8: a int4 l'accettazione dei draft crolla allo 0-4% e la speculazione non si attiva mai. Il mirror originale (jlnsrk) ha le teste int4; usa invece il clone con le teste int8 già corrette: mateogrgic/GLM-5.2-colibri-int4-with-int8-mtp. Con quello l'accettazione misurata è del 39-59%.
Scaricalo su un percorso NVMe veloce e punta la variabile d'ambiente:
COLI_MODEL=/nvme/glm52_i4 ./coli chat
3. In alternativa: conversione fai-da-te
Se preferisci convertire da zero, un solo comando scarica GLM-5.2-FP8 shard per shard, converte in int4 e sistema la testa MTP: il checkpoint FP8 da 756 GB non deve mai esistere per intero su disco, e il processo è ripristinabile:
./coli convert --model /nvme/glm52_i4
4. Verifica e primo avvio
Prima di caricare il modello, due comandi diagnostici ti dicono se la configurazione regge: coli plan mostra la gerarchia di memoria pianificata (disco/RAM/VRAM) e coli doctor fa un check di prontezza in sola lettura. Poi si parte: il caricamento richiede circa 30 secondi, con 9,9 GB residenti e un picco di ~20 GB durante la chat, auto-limitato per non svegliare mai l'OOM killer.
API OpenAI-compatibile e dashboard web
Colibrì non è solo una chat da terminale. Con coli serve esponi un'API HTTP compatibile con il protocollo OpenAI (chat completions, streaming SSE, coda FIFO delle richieste): qualsiasi strumento che parla con OpenAI può parlare con il tuo GLM-5.2 locale, dagli agenti ai tool interni. Se hai già flussi n8n o script che chiamano l'API di OpenAI, cambi l'endpoint e funzionano.
E con coli web ottieni una dashboard nel browser con metriche live (tok/s, time-to-first-token, coda) e la pagina Brain: gli esperti del modello visualizzati come una corteccia vivente, dove il colore indica il tier di memoria e ogni esperto instradato lampeggia in bianco. Guardi letteralmente il modello pensare. Da sviluppatore, è la demo più bella che ho visto quest'anno.
Quanto va veloce davvero: i numeri onesti
L'autore è il primo a dirlo: non è veloce. Sulla sua macchina di sviluppo (12 core, 25 GB RAM, NVMe da ~1 GB/s dietro WSL2) un token a freddo costa ~11 GB di letture da disco, quindi 0,05-0,1 token al secondo. Ma i benchmark della community su hardware migliore raccontano una scala interessante:
- MacBook M5 Max, 128 GB unificati: 1,06 tok/s di base, fino a 2,06 tok/s con backend Metal e pin degli esperti caldi;
- EPYC con 430 GB di RAM: 1,00 tok/s con il 98% di cache hit, e il disco sparisce dall'equazione;
- Ryzen 9950X3D2 + NVMe PCIe 5.0: 1,23 tok/s, il dato x86 più veloce;
- 6× RTX 5090 con tutti gli esperti residenti: fino a 6,84 tok/s in decode.
Due leve gratuite da conoscere: --topp 0.7 riduce del 30-40% le letture da disco, e la learning cache migliora i numeri sessione dopo sessione (su un Framework 13 la community è passata da 0,29 a 0,40 tok/s solo scaldando la cache).
Sulla qualità: una prima misura community dà il container int4 al 62,5% medio su HellaSwag/ARC/MMLU, sotto il punteggio full-precision, ma la misura è confusa dallo scoring 0-shot che penalizza i modelli reasoning, quindi per ora è un dato, non un verdetto.
Per chi ha senso Colibrì (e per chi no)
Te lo dico chiaro: a 0,1-2 token al secondo non sostituisce ChatGPT per la chat quotidiana. Ha però senso concreto in questi casi:
- Privacy assoluta: dati medici, legali o aziendali che non possono uscire dalla macchina: un modello frontier che risponde senza una singola chiamata di rete;
- Elaborazioni batch notturne: riassunti di corpora, analisi documentali, estrazione strutturata (c'è persino il supporto alle grammatiche GBNF per output JSON vincolato) lanciate la sera e pronte al mattino;
- Sperimentazione e ricerca: capire le architetture MoE su un codebase C leggibile di 2.400 righe è oro, e il progetto accoglie benchmark da hardware diversi;
- Strategia anti-rincaro: come dicevo nell'articolo sui prezzi, avere un piano B locale su hardware che possiedi già è potere negoziale verso i fornitori cloud.
Non ha senso invece se cerchi reattività immediata: per quello, meglio modelli open più piccoli, oppure gli agenti open source come SERA su hardware adeguato. E per l'uso aziendale generalista restano validi i criteri del confronto GPT-5.6 vs Claude per le PMI.
La mia lettura da sviluppatore
Colibrì è un progetto di una sola persona, sviluppato su un portatile con 25 GB di RAM, che dimostra una cosa importante: la sparsità dei modelli MoE rende possibile ciò che sembrava impossibile. Quando solo il 5% dei parametri è attivo per token, non ti serve tutto il modello in memoria veloce: ti serve una gerarchia intelligente. E con gli NVMe PCIe 5.0 che spingono oltre i 10 GB/s, questo approccio può solo migliorare.
C'è anche una lezione di ingegneria: niente framework, niente dipendenze, un file C che chiunque può leggere e capire. In un ecosistema dove ogni progetto AI trascina gigabyte di librerie Python, è una boccata d'aria. Se ti interessa il mondo dell'AI self-hosted, ho raccontato un'altra storia di questo ecosistema nel pezzo su Clawdbot/Moltbot e l'open source.
Leggi anche
- Prezzi AI +90%: perché paghi di più e come difenderti
- SERA: Gli Agenti AI Open Source che Rivoluzioneranno il Coding
- GPT-5.6 vs Claude: quale AI conviene alla tua PMI nel 2026
- Agenti AI per Aziende: Guida Completa e Pratica
- Intelligenza Artificiale per PMI: 10 Strumenti Pratici 2026
Conclusione: il modello immenso sul motore minuscolo
Colibrì non vincerà nessuna gara di velocità, ma sposta un confine: un modello da 744 miliardi di parametri che risponde correttamente in italiano sul tuo PC, con 25 GB di RAM e un NVMe capiente, gratis e con licenza Apache 2.0. Cinque anni fa era fantascienza; oggi è un git clone e una serata di download.
Se stai valutando l'AI in locale per la tua azienda (per privacy, per costi o per indipendenza dai fornitori) e vuoi capire se un modello self-hosted regge il tuo caso d'uso, contattami: analizzo con te hardware, volumi e alternative. E se il progetto richiede un'integrazione su misura, dai un'occhiata al mio servizio di sviluppo web app.
Sul tema privacy dei modelli in locale ho scritto anche di Chat Control e del voto europeo.
