---
title: "Can You Run Ripple 65B Locally? Hardware and Comparison"
url: "https://goremy.ai/blog/articles/ripple-65b-preview-run-locally"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-12T12:40:15.148Z"
updated: "2026-11-12T12:40:15.148Z"
topic: Local AI
description: Ripple 65B Preview is a dense 65B open-weight model with 1M context. See memory needs, DGX Spark fit, API pricing and how it compares to peers.
---

# Can You Run Ripple 65B Locally? Hardware and Comparison

> Ripple 65B Preview is a dense 65B open-weight model with 1M context. See memory needs, DGX Spark fit, API pricing and how it compares to peers.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-12

## Can you run Ripple 65B locally?

Yes, if you have enough memory. Ripple-65B Preview is a 65 billion parameter open-weight model released under the Apache 2.0 license. Its developer, Ricursive Intelligence (also spelled "Recursive" in some coverage), says it can fit on consumer hardware such as the NVIDIA DGX Spark, and provides a 4-bit NVFP4 checkpoint to make that practical. Coverage of the launch also mentions a MacBook. The full-precision version needs roughly 130 GB of memory, so most laptops and gaming PCs are out unless you use the smaller checkpoint.

## TL;DR

- **Ripple-65B Preview is a dense 65B model**, meaning all 65 billion parameters are used for every token, with a context window of up to 1,048,576 tokens.
- It scores **80.5 on Terminal-Bench 2.1**, a test of agentic coding in a terminal, which is ahead of several open-weight models with 8 to 15 times more total parameters, according to the developer's own comparison.
- The official model card names the **DGX Spark** as the consumer target and provides an **NVFP4 (4-bit) checkpoint** plus a Colab notebook.
- Hosted API pricing reported at launch is **20 cents per million input tokens and 60 cents per million output tokens**.
- The results are **self-reported and the release is a "Preview"** with light post-training, so test it on your own work before changing anything.
- It is not the best at everything. Larger rivals beat it on several knowledge, tool-use and software engineering tests.

## What is Ripple 65B Preview?

Ripple is the first model from Ricursive Intelligence, a US-based company. The Preview release includes an instruction-tuned model in BF16 (full precision), the same model in NVFP4 (a compressed 4-bit format), and a BF16 base model that has only been pretrained.

The model was pretrained on 12 trillion tokens of mostly English text and code. It has no image input. The company started from the open Olmo 3 recipe and changed the architecture, data and training stack. Its notes say a team that grew from one to five people trained it.

Two design choices matter to you as a user:

- **Dense, not Mixture-of-Experts (MoE).** Many large open models are MoE, which splits the model into "experts" and activates only some per token. Ripple activates everything. The developer says this simplified training.
- **Thin and deep.** It has 80 layers and a fairly narrow internal width (5120).

The post-training was, in the company's words, relatively light, with a focus on agentic coding. Agentic coding means the model works through a task step by step in a terminal or code environment, running commands and fixing its own errors, instead of answering a single question.

## How much memory does Ripple 65B need?

Memory use is mostly arithmetic. Each parameter stored at 16 bits takes 2 bytes. At 4 bits it takes about half a byte. These are my estimates, not figures from the developer:

| Version | Approximate weight size | Realistic target |
|---|---|---|
| BF16 (full precision) | about 130 GB | Datacenter GPUs, multi-GPU servers |
| NVFP4 (4-bit) | about 33 to 40 GB, plus working memory | DGX Spark, high-memory workstations |

Three caveats:

1. **Context costs memory.** The model supports 1M tokens, but the working memory for a very long conversation grows on top of the weights. Plan for a much shorter context locally unless you have headroom.
2. **The DGX Spark has 128 GB of unified memory**, which is why a 4-bit 65B model fits comfortably. A BF16 copy would not.
3. **MacBooks are less certain.** The model card names the DGX Spark, not a MacBook. NVFP4 is an NVIDIA format. The card lists only BF16 and NVFP4 checkpoints, so a Mac user would likely depend on conversions into other formats. I could not confirm that any exist. A Mac with a large amount of unified memory is plausible, but check for a compatible build before buying anything.

The model card says Ripple reaches 250 tokens per second on two B200 datacenter GPUs at batch size 8, before quantization or custom kernels. That is a datacenter number. Expect much slower generation on a desktop box.

## How does Ripple 65B compare with other open-weight models?

The developer compares Ripple against four US open-weight models, all much larger in total parameters. Here are the main numbers from its model card:

| Benchmark | Ripple 65B | Reflection Beam 501B | Muse Spark Open 816B | Inkling 975B | Nemotron 3 Ultra 550B |
|---|---|---|---|---|---|
| Terminal-Bench 2.1 (self-reported) | 80.5 | 80.1 | 76.4 | 63.8 | 56.4 |
| SWE-bench Verified | 76.5 | 81.6 | 78.7 | 77.6 | 71.9 |
| SWE-bench Pro v2.0 Hard | 79.1 | 76.5 | 72.4 | 39.6 | 30.7 |
| MMLU-Pro | 84.2 | 76.5 | 87.9 | 87.3 | 86.8 |
| GPQA Diamond | 85.2 | 90.6 | 89.0 | 87.2 | 87.0 |
| MCP Atlas | 71.67 | 80.8 | 89.2 | 76.0 | 62.2 |

Some scores for rivals come from the company's own testing rather than official model cards, so read the table as one lab's view.

What the table suggests:

- **Strong on terminal-based coding.** That matches the focus of its training.
- **Behind on tool use and some knowledge tests.** MCP Atlas (tool-calling), GPQA Diamond (graduate-level science questions) and DeepSWE 1.1 (44.3 against 60.0 for Muse Spark Open) show clear gaps.
- **Mixed on math.** It posts scores in the high 90s on AIME 2024 and 2025 but trails the top rival on most math tests.

There is a point about size that people often miss. MoE models list fewer "active" parameters (Reflection Beam shows 23B), but you still have to store all 501B parameters to run them. For local use, total size decides what fits. That makes a 65B dense model far easier to host than a 500B+ MoE model, even though Ripple does more computation per token.

## Should you trust the Ripple benchmark scores?

Treat them as promising, not settled. The model card is unusually candid about why:

- The company says replicating agentic benchmark scores is hard, because results shift with the test harness (the software that runs the model through the tasks).
- It says Terminal-Bench 2.1 scores were generally lower for the other models when using the official Terminus 2 harness at 128K sequence length with summarization. Ripple scored 80.5 under both setups.
- Some comparison scores were produced by the company's own evaluation flow, and these are marked in the table.
- The comparison only includes open-weight models. It says nothing about how Ripple stacks up against closed frontier models. One reviewer who covered the launch noted that the latest closed models are in another tier on real-world use, and that benchmarks can mislead.

None of this means the numbers are wrong. It means you should run a handful of your own tasks before you commit.

## How much does the Ripple 65B API cost?

The reported price is 20 cents per million input tokens and 60 cents per million output tokens. A token is a chunk of text, roughly three-quarters of a word. The sources I have do not say which provider hosts the API, so check the Ricursive launch page for where it is available.

A worked example: an agent run that reads 10 million tokens of code and context and writes 2 million tokens of output would cost $2.00 for input plus $1.20 for output, or $3.20. Agentic coding tends to be input-heavy, because the model rereads files and logs on every step, so the input price matters most.

Running locally has no per-token fee, but you pay for the hardware and electricity. If your usage is light, the API is cheaper. If you process sensitive code or run constant workloads, local hosting starts to make sense.

## What does this mean for you?

**If you are a developer or technical lead:** Try the NVFP4 checkpoint or the API on a real task from your own backlog, like fixing a failing test or writing a script. Compare it with whatever model you use now. The Apache 2.0 license is permissive, but read it yourself before shipping anything commercial.

**If you manage a team with privacy limits:** A model that fits on one desktop-class machine means code and documents can stay in-house. That was hard to do with 500B+ parameter models. Ask your IT group what a DGX Spark class machine would cost against your current AI spend.

**If you are not technical:** You probably will not run this yourself. The takeaway is that capable coding models keep getting smaller and cheaper, and open weights keep narrowing the gap. Tools built on them tend to get cheaper over time.

**A sensible test plan:**

1. Pick three tasks you have actually done in the last month.
2. Run each through the API first, which takes minutes.
3. Score the results against your current tool for correctness and time spent fixing the output.
4. Only buy hardware if the API results justify it.

## Could you build a tool around a local model like this?

If your team does adopt a self-hosted model, the next question is where it plugs in. With [Remy](https://goremy.ai), you describe an internal app in plain English, such as a code-review request form, a ticket triage dashboard or a document summarizer with a history log, and it builds and deploys the full-stack app. Remy supports registering custom or self-hosted models and reaching local models over a secure tunnel, so a tool like that could call your own model instead of a paid API. Whether Ripple specifically works that way is something you would need to test.

## Frequently Asked Questions

### Is Ripple 65B really open source?
The weights are released under the Apache 2.0 license, which permits commercial use. "Open-weight" is the more precise term, since the company has published the model files and a detailed model card but not necessarily all training data. Read the license file on the Hugging Face page for the exact terms.

### Can Ripple 65B run on a MacBook?
The model card names the NVIDIA DGX Spark, not a MacBook, although launch coverage mentioned both. The 4-bit weights are around 33 to 40 GB by my estimate, so a Mac with plenty of unified memory could hold them. The official 4-bit file is in NVIDIA's NVFP4 format, so you may need a converted version, and I could not confirm one exists.

### What is the difference between the Preview, NVFP4 and Base versions?
The BF16 Preview is the full-precision instruction-tuned model. NVFP4 is the same model compressed to 4 bits so it fits in less memory. The Base model is only pretrained, with no instruction tuning, and is mainly useful for researchers who want to fine-tune it.

### Does the 1M context window work on a local machine?
The model supports up to 1,048,576 tokens, but the working memory needed grows with context length. On a 128 GB machine running the 4-bit model, expect to use far shorter contexts than the maximum.

### Is Ripple 65B better than the larger open models?
On terminal-based coding tests, the developer's numbers put it level with or ahead of much larger models. On tool use, some knowledge tests and certain software engineering benchmarks, larger models score higher. Test it on your own work.