Ripple-65B: a 64.8B dense in Apache-2.0, the math of running it locally

A 64.8-billion-parameter model, dense (no experts, no MoE), under an Apache 2.0 license, with a checkpoint designed to run on a single 128 GB unified-memory workstation: Ricursive Intelligence's Ripple-65B Preview is the first model of this size designed from the architecture up to fit consumer hardware. It is the classic move from renting to owning: frontier-class quality on a machine that is yours, no paid tokens, no dependency on a data center.
What Ripple-65B is
Ripple-65B is a dense Transformer: every token activates all 64.8B parameters, not just a slice like in MoE models. The full spec is in the model card:
- 64.8B parameters (129.5 GB in BF16), pretrained from scratch on 12 trillion tokens
- 1M context: up to 1,048,576 tokens
- Thin-and-deep architecture: d_model 5120 and 80 layers, Gemma 3N-like, with a higher share of SWA layers than the Olmo 3 baseline
- Apache 2.0, in three variants: instruction-tuned in BF16 and NVFP4, base in BF16
In exact numbers: 129.5 GB of BF16 file divided by 2 bytes per parameter gives 64.8B — the "65B" in the name is the rounding.
Why dense instead of MoE? The choice is stated in the model card: the model was codesigned to be trained and served simply — 40% MFU through pretraining, standard sharding, no custom kernels, no quantization during training (pure BF16). The result: a strong model on reasoning and agentic tasks for its size, trained by a team that grew from 1 to 5 people.
The numbers: a 65B ahead of MoE ten times its size
On the agentic benchmarks the lab reports, Ripple-65B beats much larger open-weight models:
| Ripple-65B | Nemotron 3 Ultra 550B | Muse Spark Open 816B | Reflection Beam 501B | |
|---|---|---|---|---|
| Architecture | Dense | MoE | MoE | MoE |
| Total parameters | 65B | 550B | 816B | 501B |
| Active parameters | 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: AIME 2025 at 98.3. GPQA Diamond: 85.2.
The point to keep: in a dense model, active parameters are all parameters. In the 501B MoE, only 23B are active per token — that model reads about 46 GB of weights per token (23B × 2 bytes in BF16), against Ripple's 129.5 GB. That is why an MoE can be faster at equal bandwidth, while needing 500 GB of memory for weights alone. At 128 GB the choice is made for you: either you quantize the dense, or you go smaller.
The math: what hardware fits it
The right question is not "how big is the model" but "how many bytes must you pull from memory per token, and how much memory do you have":
BF16 checkpoint (129.5 GB)
- DGX Spark (128 GB unified): it does not fit, and not by much — 129.5 GB of weights plus KV cache plus workspace. This is exactly why the lab shipped the NVFP4 variant
- Two 48 GB GPUs (96 GB total): not enough; you need 160 GB, i.e. 2 × 80 GB
- Mac Studio M5 Ultra with 512 GB: it fits with room to spare, as with any large BF16 model — the Mac Studio M5 Ultra guide applies here too
NVFP4 checkpoint (MLP at 4-bit, attention in BF16)
- Weighs about 65 GB: it fits in the Spark's 128 GB with 131,072 tokens of context, prefix caching on, up to 4 concurrent requests
- Speed measured by the lab on the Spark: ~19.5 tok/s single request, ~48 tok/s total with four concurrent (128-token outputs)
- For orders of magnitude on bandwidth and unified memory, the unified memory guide is the reference
The per-token cost, locally, is zero: the only line item is the electricity of a machine already running. The trade-off is speed — on the Spark you are at ~19.5 tok/s, while the lab reports 250 tok/s on 2×B200 at batch 8: the workstation trades speed for ownership, not the other way around.
Why active parameters are the right criterion
Ripple is the chance to fix the method for reading a model's specs, the same one in the specs reading guide:
- Active parameters — they set the quality per token and the bytes read per token. 65B active means 129.5 GB read per token in BF16; the 501B MoE reads only about 46.
- Total weights against your memory — 129.5 GB total in BF16; NVFP4 is the bridge to 128 GB.
- The quantization the vendor designed for your chip — NVFP4 + DFlash2 speculative decoding + stock SGLang on GB10 is a designed path, not an after-the-fact quant: the lab ships it with ready commands.
- The context the real setup supports — 1M is a training spec; the Spark setup runs at 131K.
How to run it (NVFP4 on DGX Spark)
Official setup from the NVFP4 repo — you need Python 3.12 and the CUDA 13 toolkit:
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 downloads the checkpoints and starts an OpenAI-compatible server at http://127.0.0.1:8000/v1 with model name ripple, with streaming, tool calling and reasoning_content. Verify it works:
curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"ripple","messages":[{"role":"user","content":"Write a binary search in Python."}],"max_tokens":256}'
If it does not work: without a GB10 chip (DGX Spark), the NVFP4 path is not yours — stock SGLang and the deterministic Triton kernels are built for that stack. Your path is BF16: you need 140 GB or more of unified memory, i.e. 2 × 80 GB GPUs or a 512 GB Mac.
And the limits?
- The quantization costs something: NVFP4 drops from 80.5 to 76.0 on TerminalBench 2.1 and from 89.6 to 89.2 on MMLU. Not free — but it is the lightest quantization the lab certifies.
- 1M context is a training spec: the Spark setup runs at 131,072 tokens.
- It is a Preview: relatively light post-training, focused on agentic coding. The final model may change.
- Trained on 12T tokens predominantly in English and code: for non-English languages, keep realistic expectations, as explained in what to expect from local models.
- 19.5 tok/s is not "fast" by laptop-model standards: it is the price of frontier quality on 128 GB. If your use case is quick chat, a quantized 7-14B on a 16 GB GPU stays more responsive.
In summary
Ripple-65B Preview is the first 64.8B dense model a lab has designed for consumer hardware: Apache 2.0, 1M context, and ahead of ten-times-larger MoE on TerminalBench 2.1. In practice you run it locally with the NVFP4 checkpoint on a 128 GB workstation, at ~19.5 tok/s and 131K of context: speed and a few benchmark points traded for ownership of the model and your data. The criterion to take home: read the active parameters, compare total weights against your memory, and prefer the quantization the vendor designed for your chip.
Sources
- Ripple-65B Preview — model card (Hugging Face)
- Ripple-65B Preview NVFP4 — DGX Spark setup
- Ricursive Intelligence — launch blog
Article generated with AI
In these reading paths
Enjoyed this article?
Subscribe to the newsletter for new tutorials and guides.
Related Articles

Qwen3.8-2.4T-A95B: the math of running 2.4T open-weight parameters, 95B active
The first Qwen-Max-class open-weight model weighs ~1.3 TB at Q4: no single consumer node fits it. The math on amortization, power, and speed for multi-node.

QRAE: compressing DeepSearch agent context to save tokens and latency
QRAE uses the model's own attention entropy to decide which retrieved chunks stay in the context: tokens -45%, latency -30% and higher success across four benchmarks.

