Run Ripple-65B Preview on Apple Silicon: Osaurus 0.25.32, JANGH2 vs JANG_4D and DFlash2 (2026)

A 65-billion-parameter coding model is now available in Apple-Silicon-ready bundles, and a fresh local runtime release has added native support for it. The interesting part is not simply that Ripple-65B Preview can be downloaded. It is that Osaurus 0.25.32 can load two purpose-built MLX bundles, use the model's included DFlash2 draft model, and expose the selected local model through an OpenAI-compatible API.

This guide walks through the practical route: check whether your Mac has enough memory and disk, install the exact Osaurus release, choose between the 24.6 GB JANGH2 and 43.7 GB JANG_4D weight bundles, download the model, verify it in the app, enable adaptive speculative decoding, and call it from Python. It also explains the quality trade-off that makes the smaller bundle a compromise rather than a free win.

Updated: November 7, 2026. Version-specific instructions below are based on the Osaurus 0.25.32 release, its merged Ripple runtime support, the current Osaurus documentation, and the two published Hugging Face model cards.

Who this tutorial is for

• Mac developers with Apple Silicon and substantial unified memory who want to evaluate a large local coding model.
• People already using MLX, local model servers, or OpenAI-compatible APIs.
• Developers who want to test speculative decoding without manually wiring a separate drafter.
• Teams comparing a local Mac workflow with a hosted API or an NVIDIA-based vLLM deployment.

This is an advanced local-model guide, not a recommendation for every Mac. A Mac with 8 GB or 16 GB of unified memory cannot hold even the smaller Ripple JANGH2 weight bundle, before runtime overhead and the KV cache are considered. If that is your hardware, use a smaller model or a hosted Ripple endpoint instead of attempting this download.

What changed on November 6

Ricursive Intelligence released Ripple-65B Preview as a 65-billion-parameter dense model. Its model card describes 12 trillion pre-training tokens, a context window of up to 1,048,576 tokens, and an instruction-tuned checkpoint focused partly on agentic coding. The model is published under Apache 2.0. Ricursive reports a Terminal-Bench 2.1 score of 80.52; treat that as a vendor-reported result, not an independently reproduced guarantee.

On November 6, Osaurus published version 0.25.32. Its release notes add Ripple-65B Preview support for JANGH2 and JANG_4D bundles, including the bundled DFlash2 speculative-decoding drafter. The corresponding runtime support was merged in the vmlx-swift project. The release also includes cache, sampler, and model-specific correctness changes.

Osaurus reports that, on its qualified M5 Max app runs, Ripple code generation with DFlash2 was about 2.8 times faster than autoregressive decoding on JANGH2 and 2.4 times faster on JANG_4D. Those are specific project measurements on a qualified machine and workload. They are not a promise that every Mac, prompt, sampling configuration, or prose task will see the same improvement. The release notes say prose was close to ordinary decoding on JANGH2 and that an intermittent whole-process slowdown remained under investigation.

Understand the two model bundles before downloading

The original Ripple checkpoint is too large for many Macs in its full-precision form. Osaurus publishes two Apple-Silicon-oriented bundles. Both include the model's DFlash2 drafter.

The agreement figures come from the bundle publisher's evaluation over 221,809 assistant positions, not from an independent benchmark of end-user coding outcomes. The JANGH2 card reports a larger divergence from the original checkpoint, particularly in coding and agentic tool-loop categories. The JANG_4D card reports much closer agreement. The drafter is an additional 8.08 GB BF16 checkpoint in each repository; Osaurus quantizes it to 4-bit when it loads. The Hugging Face file totals are therefore larger than the main-weight figures shown in the table.

Practical selection rule: use JANG_4D if you have enough capacity and want the closer match. Choose JANGH2 only when the smaller footprint is necessary and you are prepared to evaluate its outputs carefully. Do not interpret 24.6 GB as a 24.6 GB RAM requirement: the model needs runtime memory, the drafter, context/KV-cache space, macOS, and your other applications. The official pages do not publish one universal minimum unified-memory figure for every Mac and context length.

Prerequisites

• An Apple-Silicon Mac running macOS 15.5 or later.
• Osaurus 0.25.32 or newer. Earlier releases do not include the Ripple bundle support described here.
• Enough free disk space for the selected bundle. Plan for roughly 33 GB for the JANGH2 repository files or 52 GB for JANG_4D, then leave additional room for caches and updates.
• Enough free unified memory to load the main model, drafter, runtime, and the context you intend to use. More memory is needed for longer prompts and concurrent applications.
• A stable internet connection for the initial model download.
• Optional: Python 3.10+ and the OpenAI Python SDK for the API example.

Do not use an unofficial re-upload just because its name looks similar. The model IDs in this guide point to the Osaurus publisher's repositories. Check the repository owner, license, revision, and model-card notes before downloading any alternative quantization.

Step 1 — Install or update Osaurus to 0.25.32

The simplest supported installation path is Homebrew:

brew update
brew install --cask osaurus

If Osaurus is already installed through Homebrew, update it with:

brew upgrade --cask osaurus

You can also download the signed DMG from the official Osaurus site or GitHub Releases and drag the app into Applications. After updating, open Osaurus and confirm that the app reports version 0.25.32 or newer. The standard installer is small; the separate full installer includes a different starter model, not Ripple.

If you installed from the DMG and need the CLI, open Settings → Server → Overview → Command Line Tool → Install CLI. Then verify:

osaurus --version
osaurus status

Expected result: the version command reports 0.25.32 or later, and the app is available in the menu bar. If the CLI is missing, install it from the app's Server settings rather than copying a random binary from another release.

Step 2 — Choose the correct Ripple bundle

Open the official model cards before downloading:

• Ripple-65B Preview JANG_4D — larger, closer to the original checkpoint.
• Ripple-65B Preview JANGH2 — smaller, with a more noticeable quality trade-off.

Read the model card's size and quality sections, not just the model name. JANGH2 is not simply a smaller file with identical behaviour. Its model card reports lower top-1 agreement than JANG_4D, including a bigger difference on coding and tool-loop samples.

Step 3 — Download the model from Osaurus

1. Open Osaurus Settings with ⌘ ,.
2. Choose Local Models.
3. Paste one of these repository IDs into the search field:

   OsaurusAI/Ripple-65B-Preview-JANGH2

   or

   OsaurusAI/Ripple-65B-Preview-JANG_4D

4. Wait for Osaurus to inspect the repository and show a supported model entry.
5. Check the version, disk estimate, and bundle name, then click Download.
6. Monitor the download queue. Pause and resume are available if your connection drops.

Osaurus's model documentation says you can paste a Hugging Face repository name or URL into the Local Models search field. The app checks whether it can run the model before offering a download. If it displays Unsupported model, do not force the files into the model directory; first verify the app version and the exact repository ID.

Expected result: the model appears under Local Models → On Device after the download and validation finish. Keep the model's source and revision details available so a future update can be compared with the version you evaluated.

Step 4 — Run a first chat and check model behaviour

1. Open a new chat.
2. Click the model pill in the message composer.
3. Select the downloaded Ripple bundle.
4. Start with a short, ordinary prompt rather than a huge repository or a 1M-token context test.

For a first smoke test, ask:

Explain the difference between a Python list and tuple.
Give one short code example for each.
Do not use tools or modify files.

Then test a small coding task with a clear expected result, such as asking it to explain a short function or identify an obvious edge case. Check that the response is coherent, that reasoning is presented as expected, and that the app does not report a model-loading or memory error.

Ripple's model card says the model decides on each turn whether to reason. It does not expose a conventional thinking on/off or reasoning-effort control in the bundle's serving contract. Do not assume that an absent Thinking switch means the model is broken.

Step 5 — Enable and inspect DFlash2 speculative decoding

Both Osaurus bundles include Ripple's DFlash2 drafter. In speculative decoding, the smaller draft model proposes a block of tokens and the main Ripple model verifies them. A correct verification path preserves the target model's sampling distribution; the purpose is to reduce the time spent generating tokens one at a time.

1. Open the model picker for the active Ripple bundle.
2. Find Speculative Decoding.
3. Choose On (Adaptive) for the first comparison, or leave the bundle's default if it is already selected.
4. Run a short code-generation prompt and note the result.
5. Repeat the same prompt with speculative decoding set to Off (AR).
6. Compare output quality, first-token delay, sustained generation, and system memory. Repeat several times rather than trusting one run.

Osaurus's release uses an adaptive selector; you do not manually choose a fixed number of draft tokens in the app. The runtime may fall back to ordinary autoregressive decoding when a request uses options that are not eligible for DFlash2. The documentation points to Settings → Server → Settings → Speculative Decoding for the loaded model's resolved state and any fallback reason.

Do not judge DFlash2 only by a single tokens-per-second number. Compare the same model bundle, prompt, context, sampling settings, power mode, and app state. The official release's M5 Max figures are a useful signal that the integration works on a qualified setup, not a speed guarantee for your Mac.

Step 6 — Start the local API server

Osaurus can expose its active local model through an OpenAI-compatible API. Start the server from Terminal:

osaurus serve

In another Terminal window, check the health endpoint and list the downloaded models:

curl http://127.0.0.1:1337/health
curl http://127.0.0.1:1337/v1/models

The model list is the source of truth for the API model ID. Osaurus normalizes downloaded model display names when exposing them through the API, so do not guess the identifier from a Hugging Face repository path. Copy the exact id returned by /v1/models.

Send a basic request, replacing the model value with the exact ID returned on your Mac:

curl http://127.0.0.1:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer osaurus-local" \
  -d '{
    "model": "PASTE_MODEL_ID_FROM_V1_MODELS",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that checks whether a string is a palindrome. Explain its time complexity."
      }
    ],
    "max_tokens": 500
  }'

For loopback-only local use, the Osaurus API guide documents a placeholder key. If you enable network exposure or relay access, use a real access key from Osaurus settings and follow the secure-channel guidance. Do not expose an unauthenticated local model endpoint to your LAN or the public internet.

Step 7 — Call Ripple from Python

Install the official OpenAI Python SDK in a virtual environment:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip openai

Create ripple_local.py:

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:1337/v1",
    api_key="osaurus-local",
)

models = client.models.list().data
matches = [m.id for m in models if "ripple" in m.id.lower()]

if not matches:
    raise SystemExit(
        "Ripple is not loaded. Check Osaurus → Settings → Local Models."
    )

model_id = matches[0]
print("Using:", model_id)

response = client.chat.completions.create(
    model=model_id,
    messages=[
        {
            "role": "system",
            "content": "You are a careful software engineering assistant.",
        },
        {
            "role": "user",
            "content": (
                "Review this function conceptually: it reads a JSON file, "
                "parses it, and assumes the top-level value is a dictionary. "
                "List the edge cases the implementation should handle."
            ),
        },
    ],
    max_tokens=700,
)

print(response.choices[0].message.content)

Run it:

python ripple_local.py

Expected result: the script prints the exact Ripple model ID discovered from the local server and then prints the model's response. If the model list is empty, make sure Osaurus is running, the model is downloaded, and the local server is listening on port 1337.

Step 8 — Use it with a coding agent safely

There are two sensible ways to start. First, use Osaurus's own custom coding agent and give it a disposable project copy. Second, connect another OpenAI-compatible client to the local endpoint after confirming that the client supports the model's tool-call format.

For a project workflow, create a throwaway Git worktree instead of pointing an experimental agent at your main checkout:

git worktree add ../my-project-ripple-test -b ai/ripple-evaluation
cd ../my-project-ripple-test
git status --short

In Osaurus, create or select a custom coding agent, choose Ripple as its model, and attach only this disposable folder as its Working Folder. Review the permissions shown by the app. The current Osaurus documentation explains that choosing a Working Folder turns the agent's Sandbox off so it can work directly in that host folder. That is a meaningful security boundary change: a disposable worktree reduces the impact of mistakes, but it is not equivalent to an isolated VM.

For a first agent task, ask for a read-only review and explicitly prohibit edits. Then inspect the tool activity and Git diff before granting any write-oriented task. Keep credentials, production configuration, customer data, and deployment keys out of the worktree.

When connecting a separate client through the API, remember that OpenAI-compatible chat completions return tool_calls; the client is responsible for executing the calls and sending tool results back. The endpoint does not silently execute arbitrary tools on the client's behalf. This is an important distinction between a model server and a complete coding-agent harness.

Step 9 — Evaluate quality and speed instead of relying on a headline

Use a small, repeatable evaluation set that reflects your real work:

• Explain a function and identify edge cases.
• Write a unit test for a known function.
• Diagnose a deliberately introduced bug in a disposable repository.
• Follow a multi-step instruction without changing unrelated files.
• Produce a structured tool call using a strict schema, if your client uses tools.

Record the model bundle, Osaurus version, DFlash2 setting, prompt, context size, output length, and whether the task succeeded. Run each task with Adaptive and AR if you are evaluating the speed-up. Check diffs and tests yourself. A high benchmark score does not prove that a model will follow your repository conventions or avoid unsafe edits.

Troubleshooting

Ripple does not appear in the model search

• Confirm Osaurus is 0.25.32 or newer.
• Paste the exact OsaurusAI/Ripple-65B-Preview-JANGH2 or OsaurusAI/Ripple-65B-Preview-JANG_4D repository name.
• Check the Hugging Face model page is reachable and that the repository is public.
• Restart Osaurus and search again if the catalog has not refreshed.

Download fails or disk space runs out

• Check free disk space before retrying; the full repository includes the drafter as well as the main weights.
• Use the download queue's pause/resume controls.
• Check whether the model directory is on an external volume with enough free space.
• Do not delete partial files while the app is still managing the download.

Model loads but generation fails with memory pressure

• Quit other memory-heavy applications.
• Reduce the context you send and avoid loading multiple large models simultaneously.
• Try JANGH2 only if its quality trade-off is acceptable; it is still a 24.6 GB main-weight bundle.
• Check Activity Monitor's Memory Pressure graph. A swap-heavy system can become unresponsive even if the model eventually loads.

DFlash2 appears enabled but the speed does not change

• Check the resolved speculative-decoding status in Osaurus Server settings.
• Some sampling or request configurations may be ineligible and fall back to AR.
• Compare a code-generation prompt separately from prose. The release's own notes report that prose gains were much smaller.
• Restart the app if a long-lived process becomes unusually slow, then repeat the same controlled comparison.

The API returns model not found

• Call GET /v1/models and copy the exact model ID from the response.
• Confirm the model has finished downloading and is selected/loaded.
• Make sure the client uses http://127.0.0.1:1337/v1, not the separate MLX-LM server port shown in examples for another serving path.

Security and privacy checklist

• Keep the API on loopback. Use 127.0.0.1 for local development. Do not use LAN exposure unless you deliberately configure authentication and understand the access path.
• Use a disposable worktree. An agent with a Working Folder can change files in that folder. Keep the folder free of secrets and production data.
• Review every diff. Treat generated code, shell commands, and tool calls as untrusted until reviewed and tested.
• Do not confuse local inference with total isolation. Model weights run locally, but model downloads require network access, and optional cloud providers or relay features can send data outside the Mac.
• Verify model provenance. Use the official OsaurusAI and Ricursive model repositories, inspect licenses, and pin the model revision if you need reproducible evaluations.
• Keep backups. Do not let an experimental agent operate directly on your only copy of a project.

Limitations and trade-offs

• Ripple-65B Preview is a preview checkpoint, not a promise of production-grade coding reliability.
• The full-precision model's advertised 1M context is a model capability claim; usable context depends on memory, runtime settings, and the KV cache.
• JANGH2 is substantially smaller but its publisher-reported agreement with the original is lower than JANG_4D.
• DFlash2 does not accelerate every prompt or sampling mode. The release's M5 Max results are workload-specific and vendor-reported.
• Osaurus is a macOS/Apple-Silicon runtime. The workflow in this article is not a Windows or Linux deployment recipe.
• There is no universal minimum unified-memory figure published for all Macs and contexts. Model-file size alone is not a sufficient sizing calculation.

FAQ

Can I run Ripple-65B Preview on a 16 GB MacBook?

No. The smaller JANGH2 main-weight bundle is about 24.6 GB before the drafter and runtime overhead. A 16 GB Mac cannot hold it in unified memory.

Which Ripple bundle should I download?

Choose JANG_4D if you have the capacity and want behaviour closer to the original checkpoint. Choose JANGH2 only when the smaller file footprint is necessary and you accept the larger quality trade-off.

Does Osaurus 0.25.32 include the DFlash2 drafter?

The OsaurusAI Ripple model cards include the DFlash2 drafter in both bundles, and Osaurus 0.25.32 adds runtime support for it. The runtime quantizes the drafter when loading it.

Does DFlash2 make every answer faster?

No. The gain depends on the task, sampling options, context, hardware, and draft acceptance. Osaurus may use ordinary decoding for requests that are not eligible for speculative decoding.

Can I use Ripple through an OpenAI-compatible API?

Yes. Osaurus exposes an OpenAI-compatible endpoint on the local server. List models first and use the exact model ID returned by the server.

Can I use the same workflow on Windows or Linux?

Not with Osaurus and MLX as described here. Use a supported NVIDIA/AMD inference runtime or a hosted provider for those platforms.

Primary sources and further reading

• Osaurus 0.25.32 release notes — version-specific Ripple and DFlash2 support.
• Osaurus PR #3332 — merged Ripple bundle pin and release integration.
• vmlx-swift PR #744 — Ripple architecture, cache and DFlash2 runtime implementation.
• Ricursive Ripple-65B Preview model card — original model architecture, license and vendor evaluation.
• OsaurusAI JANGH2 model card — smaller bundle, measured quality trade-offs and usage examples.
• OsaurusAI JANG_4D model card — larger bundle and quality evaluation.
• Osaurus installation guide and model management guide.
• Osaurus OpenAI-compatible API guide.

Related GyanAangan guides

• Rapid-MLX 1.0.1: Run Claude Code and Codex with local models on Apple Silicon.
• llama.app: Run llama.cpp, GGUF models and local coding agents.
• Continue + Ollama in VS Code: Local chat, edits and autocomplete.
• Ollama tool calling with Python: Build a safe read-only codebase agent.

Bottom line: Osaurus 0.25.32 makes Ripple-65B Preview a more practical experiment for owners of high-memory Apple-Silicon Macs. The JANG_4D bundle prioritizes fidelity; JANGH2 reduces the main-weight footprint at a measurable quality cost. Start with a short local test, verify the exact model ID, compare DFlash2 against ordinary decoding, and keep coding-agent access confined to a disposable project copy.