Ripple-65B : un dense de 64,8B sous Apache-2.0, les comptes pour le faire tourner en local

Un modèle de 64,8 milliards de paramètres, dense (ni experts, ni MoE), sous licence Apache 2.0, avec un checkpoint conçu pour tourner sur une seule workstation dotée de 128 Go de mémoire unifiée : Ripple-65B Preview de Ricursive Intelligence est le premier modèle de cette taille dessiné dès l'architecture pour tenir sur du matériel grand public. C'est le passage classique de la location à la propriété : la qualité d'un modèle frontier, sur une machine qui est à vous, sans token payant et sans dépendre d'un data center.
Ce qu'est Ripple-65B
Ripple-65B est un Transformer dense : chaque token active l'intégralité des 64,8B de paramètres, pas seulement une partie comme dans les MoE. La fiche complète est dans la model card :
- 64,8B paramètres (129,5 Go en BF16), préentraînement depuis zéro sur 12 000 milliards de tokens
- 1M de contexte : jusqu'à 1 048 576 tokens
- Architecture thin-and-deep : d_model 5120 et 80 couches, style Gemma 3N, avec un ratio plus élevé de couches SWA que le baseline Olmo 3
- Apache 2.0, en trois variantes : instruct en BF16 et NVFP4, base en BF16
En chiffres exacts : 129,5 Go de fichier BF16 divisés par 2 octets par paramètre font 64,8B — le « 65B » du nom est l'arrondi.
Pourquoi dense plutôt que MoE ? Le choix est déclaré dans la model card : le modèle a été codesigné pour être entraîné et servi simplement — 40 % de MFU en préentraînement, sharding standard, aucun kernel custom, aucune quantisation pendant l'entraînement (BF16 pur). Résultat : un modèle solide en raisonnement et sur les tâches agentiques pour sa taille, entraîné par une équipe passée de 1 à 5 personnes.
Les chiffres : un 65B devant des MoE dix fois plus gros
Sur les benchmarks agentiques déclarés par le labo, Ripple-65B devance des modèles open-weight beaucoup plus grands :
| Ripple-65B | Nemotron 3 Ultra 550B | Muse Spark Open 816B | Reflection Beam 501B | |
|---|---|---|---|---|
| Architecture | Dense | MoE | MoE | MoE |
| Paramètres totaux | 65B | 550B | 816B | 501B |
| Paramètres actifs | 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 |
Mathématiques : AIME 2025 à 98,3. GPQA Diamond : 85,2.
Le point à retenir : dans un dense, les paramètres actifs sont tous les paramètres. Dans le MoE de 501B, seuls 23B sont actifs par token — ce modèle lit donc environ 46 Go de poids par token (23B × 2 octets en BF16), contre 129,5 Go pour Ripple. C'est la raison pour laquelle un MoE peut être plus rapide à bande passante égale, mais il faut 500 Go de mémoire pour les poids seuls. À 128 Go, le choix se fait pour vous : soit vous quantisez le dense, soit vous descendez de taille.
Les comptes : sur quel matériel ça tient
La bonne question n'est pas « combien le modèle est-il grand », mais « combien d'octets faut-il charger en mémoire à chaque token, et combien de mémoire avez-vous » :
Checkpoint BF16 (129,5 Go)
- DGX Spark (128 Go unifiés) : ça ne tient pas, et de peu — 129,5 Go de poids plus KV cache plus espace de travail. C'est exactement pour cela que le labo a publié la variante NVFP4
- Deux GPU de 48 Go (96 Go au total) : insuffisant ; il faut 160 Go, donc 2 × 80 Go
- Mac Studio M5 Ultra de 512 Go : ça tient avec une large marge, comme pour tout grand modèle BF16 — le guide Mac Studio M5 Ultra vaut aussi ici
Checkpoint NVFP4 (MLP en 4 bits, attention en BF16)
- Il pèse environ 65 Go : il tient dans les 128 Go de la Spark avec 131 072 tokens de contexte, prefix caching activé et jusqu'à 4 requêtes concurrentes
- Vitesse mesurée par le labo sur la Spark : ~19,5 tok/s en une requête, ~48 tok/s au total avec 4 concurrentes (sorties de 128 tokens)
- Pour les ordres de grandeur sur la bande passante et la mémoire unifiée, le guide sur la mémoire unifiée est la référence
Le coût par token, en local, est nul : la seule ligne de dépense est l'électricité d'une machine déjà en marche. Le trade-off est la vitesse — sur la Spark vous êtes à ~19,5 tok/s, alors que le labo rapporte 250 tok/s sur 2×B200 en batch 8 : la workstation échange la vitesse contre la propriété, pas l'inverse.
Pourquoi le bon critère, c'est les paramètres actifs
Ripple est l'occasion de fixer la méthode de lecture des spécifications d'un modèle, la même que dans le guide de lecture des specs :
- Paramètres actifs — ils déterminent la qualité par token et les octets lus par token. 65B actifs, c'est 129,5 Go lus par token en BF16 ; le MoE de 501B n'en lit qu'environ 46.
- Poids totaux contre votre mémoire — 129,5 Go au total en BF16 ; le NVFP4 est le pont vers les 128 Go.
- La quantisation que le vendor a conçue pour votre puce — NVFP4 + décodage spéculatif DFlash2 + SGLang stock sur GB10 est un chemin conçu, pas une quantification appliquée après coup : le labo le publie avec les commandes prêtes.
- Le contexte que le setup réel supporte — 1M est une spec d'entraînement ; le setup Spark tourne à 131K.
Comment le faire tourner (NVFP4 sur DGX Spark)
Setup officiel depuis la repo NVFP4 — il faut Python 3.12 et le 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 télécharge les checkpoints et lance un serveur compatible OpenAI sur http://127.0.0.1:8000/v1 avec le modèle ripple, avec streaming, tool calling et reasoning_content. Vérifiez que ça marche :
curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"ripple","messages":[{"role":"user","content":"Écris une recherche binaire en Python."}],"max_tokens":256}'
Si ça ne va pas : sans puce GB10 (DGX Spark), le chemin NVFP4 n'est pas le vôtre — SGLang stock et les kernels Triton déterministes sont construits pour ce stack. Votre chemin est le BF16 : il faut 140 Go ou plus de mémoire unifiée, soit 2 × 80 Go de GPU ou un Mac de 512 Go.
Et les limites ?
- La quantisation coûte quelque chose : le NVFP4 passe de 80,5 à 76,0 sur TerminalBench 2.1 et de 89,6 à 89,2 sur MMLU. Ce n'est pas gratuit, mais c'est la quantification la plus légère certifiée par le labo.
- 1M de contexte est une spec d'entraînement : le setup Spark tourne à 131 072 tokens.
- C'est un Preview : post-training relativement léger, concentré sur le coding agentique. Le modèle final peut changer.
- Entraîné sur 12 000 milliards de tokens principalement en anglais et en code : pour le français (et l'italien), gardez des attentes réalistes, comme on l'explique dans à quoi s'attendre.
- ~19,5 tok/s n'est pas « rapide » au standard des modèles de laptop : c'est le prix de la qualité frontier sur 128 Go. Si votre cas d'usage est une conversation réactive, un 7-14B quantisé sur une GPU 16 Go reste plus nerveux.
En résumé
Ripple-65B Preview est le premier modèle dense de 64,8B conçu par un labo pour le matériel grand public : Apache 2.0, 1M de contexte, et devant des MoE dix fois plus gros sur TerminalBench 2.1. En pratique, on le fait tourner en local avec le checkpoint NVFP4 sur une workstation de 128 Go, à ~19,5 tok/s et 131K de contexte : on échange de la vitesse et quelques points de benchmark contre la propriété du modèle et des données. Le critère à garder : lisez les paramètres actifs, comparez les poids totaux à votre mémoire, et préférez la quantisation conçue par le vendor pour votre puce.
Sources
- Ripple-65B Preview — model card (Hugging Face)
- Ripple-65B Preview NVFP4 — setup sur DGX Spark
- Ricursive Intelligence — blog de lancement
Article généré par IA
Dans ces parcours
Vous avez aimé cet article ?
Abonnez-vous à la newsletter pour recevoir de nouveaux tutoriels et guides.
Articles Correlés

Qwen3.8-2.4T-A95B : les comptes pour faire tourner 2,4 billions de paramètres open-weight, 95B actifs
Le premier modèle Qwen-Max en open-weight pèse ~1,3 To en Q4 : aucun nœud grand public seul n'y entre. Les comptes sur amortissement, électricité et vitesse en multi-nœud.

QRAE : compresser le contexte des agents DeepSearch pour économiser token et latence
QRAE utilise l'entropie d'attention du modèle pour décider quels fragments récupérés restent dans le contexte : token -45 %, latence -30 % et succès en hausse sur quatre benchmarks.

