Skip to main content
ModelsIntermediate7 min read

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

i
iaLocale Team
•
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-65BNemotron 3 Ultra 550BMuse Spark Open 816BReflection Beam 501B
ArchitectureDenseMoEMoEMoE
Total parameters65B550B816B501B
Active parameters65B55B42B23B
TerminalBench 2.180.556.476.480.1
SWE-bench Verified76.571.978.781.6
SWE-bench Pro v2.0 Hard79.130.772.476.5
MMLU89.692.092.692.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:

  1. 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.
  2. Total weights against your memory — 129.5 GB total in BF16; NVFP4 is the bridge to 128 GB.
  3. 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.
  4. 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

Article generated with AI

In these reading paths

Share:

Enjoyed this article?

Subscribe to the newsletter for new tutorials and guides.

After signing up you receive a confirmation email (double opt-in). Without confirmation we send nothing. No spam, we promise.

Related Articles

Related resources

Tools and resources from the iaLocale archive relevant to this content.

🌊

Ripple-65B Preview

Models

64.8B-parameter dense model from Ricursive Intelligence, Apache 2.0: pretrained from scratch on 12T tokens, up to 1M context, thin-and-deep architecture (d_model 5120, 80 layers). Aimed at agentic coding: 80.5 on TerminalBench 2.1, ahead of open-weight MoE up to 10x larger. NVFP4 checkpoint (MLP 4-bit, attention BF16) designed for a single 128 GB unified-memory workstation (DGX Spark), ~19.5 tok/s single request.

🖥️

AMD Ryzen AI Max+ 395 (Strix Halo)

Hardware

La APU AMD con la massima memoria unificata su x86: fino a 128GB di LPDDR5X condivisa tra CPU (16 core Zen 5), GPU integrata (40 CU RDNA 3.5) e NPU. Fino a 96GB allocabili alla GPU: modelli fino a 100B+ a 4 bit senza GPU dedicata, su mini-PC o laptop. Bandwidth 256 GB/s.

🖥️

Mac Studio (M5 Max)

Hardware

La workstation Apple di fascia alta: M5 Max con 18 core CPU, GPU fino a 40 core con Neural Accelerator e fino a 128GB di memoria unificata a 614 GB/s. Modelli fino a ~120B in 4 bit (e i MoE a bassa attivazione come gpt-oss-120b in tempo quasi reale), con MLX e llama.cpp. 10GbE di serie, Thunderbolt 5, fino a 8 display.

🖥️

Mac Studio (M5 Ultra)

Hardware

Il Mac più potente di Apple: M5 Ultra, primo chip a quattro die (due M5 Max uniti da UltraFusion), fino a 36 core CPU, 80 core GPU e 512GB di memoria unificata a 1,2 TB/s. Pensato per modelli frontier-class in locale: MoE da centinaia di miliardi di parametri e RAG su corpora enormi, senza cloud. Il clustering RDMA di più unità porta fino a 3× l'inferenza distribuita.