Ripple-65B: un dense da 64,8B in Apache-2.0, i conti per girarlo in locale

Un modello da 64,8 miliardi di parametri, denso (niente esperti, niente MoE), in licenza Apache 2.0, con un checkpoint progettato per girare su una singola workstation da 128 GB di memoria unificata: Ripple-65B Preview di Ricursive Intelligence è il primo modello di questa taglia che è stato disegnato fin dall'architettura per stare sull'hardware di consumo. È il classico passaggio dall'affitto alla proprietà: qualità da modello frontier, ma su una macchina che è tua, senza token a pagamento e senza dipendere da un data center.
Che cos'è Ripple-65B
Ripple-65B è un Transformer denso: ogni token attiva tutti e 64,8B i parametri, non una parte come nei MoE. La scheda completa è nella model card:
- 64,8B parametri (129,5 GB in BF16), pretraining da zero su 12 trilioni di token
- 1M di contesto: fino a 1.048.576 token
- Architettura thin-and-deep: d_model 5120 e 80 layer, stile Gemma 3N, con un rapporto più alto di layer SWA rispetto al baseline Olmo 3
- Apache 2.0, in tre varianti: instruct in BF16 e NVFP4, base in BF16
Nei numeri esatti: 129,5 GB di file BF16 diviso 2 byte per parametro fa 64,8B — il "65B" del nome è l'arrotondamento.
Perché denso e non MoE? La scelta è dichiarata nella model card: il modello è stato codesigned per essere addestrato e servito in modo semplice — 40% di MFU in pretraining, sharding standard, nessun kernel custom, nessuna quantizzazione durante l'addestramento (BF16 puro). Il risultato: un modello forte su reasoning e task agentici per la sua taglia, allenato da un team che è cresciuto da 1 a 5 persone.
I numeri: un 65B davanti a MoE dieci volte più grandi
Sui benchmark agentici dichiarati dal laboratorio, Ripple-65B batte modelli open-weight molto più grandi:
| Ripple-65B | Nemotron 3 Ultra 550B | Muse Spark Open 816B | Reflection Beam 501B | |
|---|---|---|---|---|
| Architettura | Denso | MoE | MoE | MoE |
| Parametri totali | 65B | 550B | 816B | 501B |
| Parametri attivi | 65B | 55B | 42B | 23B |
| TerminalBench 2.1 | 80.5 | 56.4 | 76.4 | 80.1 |
| SWE-bench Verified | 76.5 | 71.9 | 78.7 | 81.6 |
| SWE-bench Pro v2.0 Hard | 79.1 | 30.7 | 72.4 | 76.5 |
| MMLU | 89.6 | 92.0 | 92.6 | 92.4 |
Matematica: AIME 2025 a 98,3. GPQA Diamond: 85,2.
Il punto da tenere a mente: nel denso i parametri attivi sono tutti i parametri. Nel MoE da 501B solo 23B sono attivi per token — quel modello legge circa 46 GB di pesi a token (23B × 2 byte in BF16), contro i 129,5 GB di Ripple. È il motivo per cui un MoE può essere più veloce a parità di banda, ma ha bisogno di 500 GB di memoria per i soli pesi. A 128 GB la scelta è fatta al posto tuo: o quantizzi il denso, o scendi di taglia.
I conti: su quale hardware ci sta
La domanda giusta non è "quanto è grande il modello", ma "quanti byte devo portare in memoria a ogni token e quanta memoria ho":
Checkpoint BF16 (129,5 GB)
- DGX Spark (128 GB unificati): non ci sta, e non di poco — pesi di 129,5 GB più KV cache più spazio di lavoro. È esattamente per questo che il laboratorio ha pubblicato la variante NVFP4
- Due GPU da 48 GB (96 GB totali): insufficienti; servono 160 GB, cioè 2 × 80 GB
- Mac Studio M5 Ultra da 512 GB: ci sta con ampio margine, come per ogni grande modello BF16 — la guida al Mac Studio M5 Ultra vale anche qui
Checkpoint NVFP4 (MLP in 4 bit, attenzione in BF16)
- Pesa circa 65 GB: sta nei 128 GB della Spark con 131.072 token di contesto, prefix caching attivo e fino a 4 richieste concorrenti
- Velocità misurata dal laboratorio sulla Spark: ~19,5 tok/s con una richiesta, ~48 tok/s in totale con 4 concorrenti (uscite da 128 token)
- Per gli ordini di grandezza su banda e memoria unificata, la guida alla memoria unificata è il riferimento
Il costo per token, in locale, è zero: l'unica voce di spesa è l'elettricità di una macchina già in funzione. Il trade-off è la velocità — sulla Spark stai a ~19,5 tok/s, mentre il laboratorio riporta 250 tok/s su 2×B200 in batch 8: con la workstation scambii velocità con proprietà, non il contrario.
Perché il criterio giusto è quello dei parametri attivi
Ripple è l'occasione per fissare il metodo con cui leggi le specifiche di un modello, la stessa della guida alla lettura delle specifiche:
- Parametri attivi — determinano la qualità per token e i byte letti a token. 65B attivi significa 129,5 GB letti a token in BF16; il MoE da 501B ne legge circa 46.
- Pesi totali contro la tua memoria — 129,5 GB totali in BF16; il NVFP4 è il ponte verso i 128 GB.
- La quantizzazione che il vendor ha progettato per il tuo chip — NVFP4 + decodifica speculativa DFlash2 + SGLang stock sul GB10 è un percorso progettato, non una quantizzazione applicata dopo: il laboratorio lo pubblica con i comandi pronti.
- Il contesto che il setup reale supporta — 1M è una spec di addestramento; il setup Spark gira a 131K.
Come farlo girare (NVFP4 su DGX Spark)
Setup ufficiale dalla repo NVFP4 — servono Python 3.12 e il toolkit CUDA 13:
hf download ricursiveAI/Ripple-65B-Preview-NVFP4 --include "inference/local/*" --include chat_template.jinja --local-dir ripple
cd ripple/inference/local
python3.12 -m venv .venv && .venv/bin/pip install -r requirements.txt
CUDA_HOME=/usr/local/cuda-13.0 PATH="$PWD/.venv/bin:/usr/local/cuda-13.0/bin:$PATH" python spark.py
spark.py scarica i checkpoint e alza un server OpenAI-compatible su http://127.0.0.1:8000/v1 con modello ripple, con streaming, tool calling e reasoning_content. Verifica che funzioni:
curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"ripple","messages":[{"role":"user","content":"Scrivi una binary search in Python."}],"max_tokens":256}'
Se non va: senza chip GB10 (DGX Spark) il percorso NVFP4 non è il tuo — SGLang stock e i kernel Triton deterministici sono costruiti per quello stack. La tua strada è il BF16: servono 140 GB o più di memoria unificata, cioè 2 × 80 GB di GPU o un Mac da 512 GB.
E i limiti?
- La quantizzazione costa qualcosa: NVFP4 scende da 80,5 a 76,0 su TerminalBench 2.1 e da 89,6 a 89,2 su MMLU. Non è gratis, ma è la quantizzazione più leggera che il laboratorio certifica.
- 1M di contesto è una spec di addestramento: il setup Spark gira a 131.072 token.
- È un Preview: post-training relativamente leggero, concentrato sull'agentic coding. Il modello finale potrà cambiare.
- Addestrato su 12 trilioni di token prevalentemente in inglese e codice: per l'italiano e il francese parti con le aspettative giuste, come spieghiamo in cosa aspettarsi dall'italiano nei modelli locali.
- 19,5 tok/s non è "veloce" come i modelli da laptop: è il prezzo della qualità frontier su 128 GB. Se il tuo caso d'uso è una chat reattiva, un 7-14B quantizzato su una GPU da 16 GB resta più scattante.
In sintesi
Ripple-65B Preview è il primo modello denso da 64,8B che un laboratorio ha progettato per l'hardware di consumo: Apache 2.0, 1M di contesto, e su TerminalBench 2.1 davanti a MoE con dieci volte i parametri. In locale si gira nella pratica con il checkpoint NVFP4 su una workstation da 128 GB, a ~19,5 tok/s e 131K di contesto: si scambiano velocità e qualche punto di benchmark con la proprietà del modello e dei dati. Il criterio da portarti a casa: leggi i parametri attivi, confronta i pesi totali con la tua memoria e preferisci la quantizzazione che il vendor ha progettato per il tuo chip.
Fonti
- Ripple-65B Preview — model card (Hugging Face)
- Ripple-65B Preview NVFP4 — setup su DGX Spark
- Ricursive Intelligence — launch blog
Articolo generato con IA
In questi percorsi
Ti è piaciuto questo articolo?
Iscriviti alla newsletter per ricevere nuovi tutorial e guide.
Articoli Correlati

Qwen3.8-2.4T-A95B: i conti per girare 2,4 trilioni di parametri open-weight, con 95B attivi
Il primo modello Qwen-Max in open-weight pesa ~1,3 TB in Q4: nessun nodo consumer singolo ci entra. I conti su ammortamento, luce e velocità per il multi-nodo.

QRAE: comprimere il contesto degli agenti DeepSearch per risparmiare token e latenza
QRAE usa l'entropia dell'attenzione del modello per decidere quali frammenti recuperati restano nel contesto: token -45%, latenza -30% e successo in crescita su quattro benchmark.

