Run Ripple-65B locally: memory, speed and the benchmark gap

Ripple-65B Preview on your own hardware: real download sizes, the first DGX Spark speed figure, llama.cpp and Ollama support, and its disputed scores.

· 9 min read

You can run Ripple-65B locally today, but it needs more memory than its "consumer hardware" billing suggests, and its headline coding score has not held up in the first independent test. Ricursive Intelligence's Ripple-65B Preview is a dense 65-billion-parameter model under Apache 2.0, built for agentic coding. As of 17 November 2026, Ollama's own 4-bit builds of it are 39 GB and 46 GB (Ollama library), llama.cpp has supported it since 5 November, and the first speed figure on a desktop machine, from Ricursive itself, is about 19.5 tokens per second on an NVIDIA DGX Spark (NVFP4 model card, updated 16 November 2026).

This piece gathers what has been verified since release: what to download, what it needs, how fast it goes, which runtimes support it, and how far to trust the benchmarks. It is for anyone with a large-memory Mac, a DGX Spark or a multi-GPU workstation who is deciding whether to point a coding agent at it.

What is Ripple-65B Preview?

Ripple-65B Preview is a 65B dense Transformer pretrained from scratch on 12 trillion tokens, with context of up to 1,048,576 tokens, according to its Hugging Face card. Ricursive's launch post describes it as a general-purpose variant of the proprietary model behind the company's chip-design platform, and says the full research and development cost was $32 million.

"Dense" is the important word for anyone running it at home. Most recent large open models are mixtures of experts, which read only a fraction of their weights for each token. Ripple reads all 65B parameters for every token: the card lists 65B total and 65B active parameters, with 80 layers and a model width of 5,120 (model card). That makes it far smaller to store than the 501B-to-975B-parameter models it is compared with, but slower per token than a mixture-of-experts model of similar file size, because generation speed on a desktop is mostly limited by how fast the machine can read weights from memory.

The release has four parts on Hugging Face, all Apache 2.0:

Repository What it is Size on Hugging Face
Ripple-65B-Preview Instruction-tuned model, BF16 129.6 GB
Ripple-65B-Preview-NVFP4 Same model, MLP layers in NVFP4, attention in BF16 57.2 GB
Ripple-65B-Preview-DFlash2 4.04B draft model for speculative decoding 8.1 GB
Ripple-65B-Base-Preview Pretrain-only base model —

Sizes are the sum of each repository's files as listed by Hugging Face on 17 November 2026.

How much memory does Ripple-65B need?

Ricursive does not publish a memory requirement. Its card says only that the model "can fit on consumer hardware such as the NVIDIA DGX Spark" (model card), a machine with 128 GB of unified memory. The download sizes are the most reliable guide to the floor:

Build Runtime Download Source
ripple-preview:65b-q4_K_M Ollama (GGUF) 39 GB Ollama library
ripple-preview:65b-nvfp4 Ollama (MLX) 46 GB Ollama library
Red Hat NVFP4 + FP8 vLLM 43.8 GB RedHatAI card
Ricursive NVFP4 SGLang, vLLM 57.2 GB Ricursive card
ripple-preview:65b-gguf-bf16 Ollama (GGUF) 130 GB Ollama library

Those figures are the weights alone. The conversation and the files your agent reads (the context, held in the KV cache) come on top, and so does the drafter if you use speculative decoding: another 8.1 GB at BF16 (DFlash2 card). No maintainer or lab has yet published how much memory Ripple's context takes at a given length, so we will not put a number on it.

Our reading, as an opinion rather than a measurement: a 48GB machine holds the 4-bit weights with very little left for context and the operating system, so 64GB is the realistic starting point for a Mac, and 96GB or 128GB is where long coding sessions become comfortable. A single 24GB graphics card cannot hold any of the builds above. For how this compares with smaller models at each memory size, see the best local LLM by memory.

How fast is Ripple-65B on a desktop machine?

The only published speed on desktop hardware so far is Ricursive's own. On 16 November 2026 the company added a DGX Spark bundle to its NVFP4 card, and states that on a DGX Spark at temperature 1.0 it "reaches about 19.5 tok/s for one request and 48 tok/s in total with four, on representative prompts with 128-token outputs".

The conditions matter, and the card gives them. That figure uses the NVFP4 checkpoint with the DFlash2 draft model, through stock SGLang 0.5.19, with Ricursive's bundled kernels doing experimental speculative tree decoding (32 verification nodes from a 16-token draft), a 131,072-token context and prefix caching on. It is the vendor's measurement on its own setup, with short outputs, not an independent benchmark. There is no published figure yet for the same machine without speculative decoding, for a Mac, or for llama.cpp or Ollama.

The other speed on Ricursive's card, 250 tokens per second, was measured on two NVIDIA B200 data-centre GPUs at batch size 8 (model card) and tells you nothing about a desktop.

What speculative decoding with DFlash2 does

A draft model guesses several tokens ahead and the big model checks them in one pass, so when the guesses are right you get several tokens for the price of one read of the weights. For a dense model limited by memory bandwidth, that is the main lever on speed. Ricursive's drafter proposes blocks of 16 tokens and keeps 32 candidates per position, and its configured maximum position is 131,072 tokens (DFlash2 card). Ricursive says a serving implementation with correct rejection sampling preserves the main model's output distribution, so the speed-up should not change what the model writes.

Which runtimes run Ripple-65B?

As of 17 November 2026, three runtimes support it, each reached differently.

Ollama

Ollama v0.40.16 added Ripple to its MLX runner, including per-layer NoPE support in DFlash drafts (commit d63b702, PR #19592). Ollama's library page says that on its MLX engine Ripple uses DFlash 2 speculative decoding (Ollama library). Pull a specific build rather than latest, so you know which one you have:

ollama pull ripple-preview:65b-nvfp4     # 46 GB, MLX
ollama pull ripple-preview:65b-q4_K_M    # 39 GB, GGUF
ollama run ripple-preview:65b-nvfp4

The library lists the model with tools and thinking support, which is what a coding agent needs.

llama.cpp

llama.cpp added the Ripple architecture in PR #31692, merged on 5 November 2026; the first numbered build that contains it is b12158, and llama.cpp 1.0 (13 November) lists it among its new models. Support for Ricursive's DFlash2 drafter followed in PR #31904, first in build b12416 (15 November), and a fix to how the converter writes the drafter's NoPE metadata in PR #32363, first in build b12429 (16 November). We checked each build against the project's git history on 17 November 2026.

llama.cpp's speculative decoding documentation gives the general pattern for a DFlash2 draft: convert it with the target model's directory so it inherits the tokenizer and embeddings, then pass it to llama-server with -md:

python convert_hf_to_gguf.py Ripple-65B-Preview-DFlash2 \
    --target-model-dir Ripple-65B-Preview --outtype bf16 --outfile Ripple-DFlash2.gguf

llama-server -m Ripple-65B-Preview-Q4_K_M.gguf -md Ripple-DFlash2.gguf \
    --spec-type draft-dflash2 --spec-draft-n-max 7 -fa on --jinja

The file names are placeholders and the --spec-draft-n-max value is the documentation's generic example, not a Ripple-tuned setting; the documentation says it is clamped to the draft's trained block size.

There is still no GGUF or MLX build of Ricursive's instruct model from ggml-org, Unsloth, bartowski, mlx-community or lmstudio-community (Hugging Face search, 17 November 2026). Several community quantisations exist; check that one is of Ricursive's own model and not a third-party fine-tune before downloading it.

vLLM and SGLang

Red Hat's NVFP4 + FP8 build is made for vLLM and documents a vllm serve command with Ripple's own reasoning and tool-call parsers. Ricursive's DGX Spark bundle runs on stock SGLang 0.5.19 and exposes an OpenAI-compatible server on 127.0.0.1:8000 with streaming, tool calls and reasoning content (NVFP4 card). NVFP4 is NVIDIA's 4-bit format, so these two paths are for NVIDIA hardware.

Does Ripple-65B's coding score hold up?

Ricursive's card reports 80.5 on Terminal-Bench 2.1 for the BF16 model, ahead of the 501B-to-975B open models it compares against (model card). The card is candid about the caveats: competitors' missing scores were filled in with Ricursive's own in-house evaluations, and it calls the comparison "a best-effort attempt at a fair comparison". Its NVFP4 card, updated 16 November, reports 76.0 for the 4-bit build (NVFP4 card).

The first independent number is lower. Red Hat ran Terminal-Bench 2.1 on Ricursive's NVFP4 checkpoint and got 68.54, and 67.42 on its own smaller build, over all 89 tasks at pass@1 (RedHatAI card, release dated 6 November 2026).

Terminal-Bench 2.1 Score Who ran it Harness Source
Ripple-65B BF16 80.5 Ricursive Terminus 2 model card
Ripple-65B NVFP4 (Ricursive) 76.0 Ricursive Terminus 2 NVFP4 card
Ripple-65B NVFP4 (Ricursive) 68.54 Red Hat Inspect ReAct agent RedHatAI card
Ripple-65B NVFP4 + FP8 (Red Hat) 67.42 Red Hat Inspect ReAct agent RedHatAI card
Qwen3.8 27B 73.0 Qwen Terminus Qwen card

Read the table carefully. Red Hat used a generic agent rather than the Terminus 2 harness, with a 131,072-token context and a two-hour limit per task, and says itself that its numbers "are not directly comparable" to Terminus 2 results or to Ricursive's score. It also gives a standard error of about ±4.9 points for a single 89-task run. So the gap between 76.0 and 68.54 does not prove Ricursive's figure wrong; it shows that the score depends heavily on the harness, which Ricursive's own card concedes. The Qwen row is Qwen's own number on its own setup, included because Qwen3.8 27B is the obvious smaller alternative, not as a like-for-like comparison.

What a reader can take from it: the only independent result we found is about 7.5 points below Ricursive's own figure for the same checkpoint, on a different harness. Until more independent runs exist, judge it on your own repository.

Ripple-65B or Qwen3.8 27B for a coding agent?

In our view, on a 64GB-to-128GB machine the choice comes down to speed against breadth of support. Qwen3.8 27B is less than half the size, with a 19.40 GB Q4_K_M file and a 28.60 GB Q8_0 file from ggml-org (ggml-org), so it reads far fewer bytes per token and leaves much more memory for context. It also has llama.cpp's own builds and drafters. Ripple is newer, larger and less tested: the case for it is the hope that a 65B dense model reasons better on long agentic tasks, which is exactly what has not yet been independently shown.

If you have the memory, both are worth a try on your own work: same agent, same task, side by side. That test tells you more than either lab's table.

Use Ripple-65B from your laptop with Corewire

A model this size belongs on the big machine, but the coding usually happens on a laptop at a café or on a train. Corewire connects the Ollama on your Mac Studio or workstation to your other devices over your own encrypted network, and gives the model one name, computer/model, that coding agents use. After pulling Ripple on the desktop, from the laptop:

corewire models
corewire launch claude-code -model mac-studio/ripple-preview:65b-nvfp4

Use the name corewire models lists for your machine. Claude Code needs a runtime that speaks the Anthropic Messages API, which Ollama does from version 0.14; the Claude Code guide covers the launch and a permanent setup, and sharing Ollama takes a minute. The OpenCode guide works the same way. Corewire is free for your own devices (pricing), and the apps are on the download page.

Questions people ask

Can I run Ripple-65B on a 24GB GPU?

Not on its own. The smallest build Ollama offers is 39 GB (Ollama library), so a 24GB card would have to leave a large part of the model in system memory, which slows a dense model badly. In our view, two 24GB cards together, or a machine with 64GB or more of unified memory, are the practical options.

Is Ripple-65B open source?

The weights are released under Apache 2.0, which allows commercial use (model card). The card does not link the training data or the training code, so it is best described as an open-weight model.

Which runtimes support Ripple-65B?

As of 17 November 2026: Ollama from v0.40.16, llama.cpp from build b12158 (and 1.0), vLLM through Red Hat's build, and SGLang through Ricursive's DGX Spark bundle. There is no lmstudio-community build on Hugging Face yet (search).

What sampling settings should I use?

Ricursive added recommended defaults to the model on 16 November 2026: temperature 1.0 and top-p 0.95 (generation config). Its DGX Spark bundle applies the same defaults when a request leaves them out.

More in New models

Corewire shares the models on your computers with every device you own, and with the coding agents you already use. Download it free or read the guides.