Runtime: Osaurus 0.25.32 or newer.

OsaurusAI/Ripple-65B-Preview-JANGH2

Ripple-65B Preview in 24.6 GB, with 90.3% top-1 agreement with the full-precision model. It fits Macs that cannot hold the 43.7 GB JANG_4D. The model's DFlash2 speculative-decoding drafter is included.

This is a JANGH bundle of ricursiveAI/Ripple-65B-Preview: a 65B dense transformer with 80 layers. Every fifth layer is full attention without positional rotation and the others are sliding-window attention (1,024 tokens), with gated attention and a value residual.

• Feed-forward (gate/up/down, 78% of the weights): JANGH 2-bit, our Hadamard-32 codebook format with one fp16 scale per output row. All 240 projections are GPTQ-rounded with activation ordering on the rotated Hessians, and the row scales carry a measured gain correction.
• Attention, embeddings and lm_head: the same affine 6-8-bit modules as JANG_4D, GPTQ-rounded (embeddings plain-rounded).
• Size: 24.62 GB of model shards, 3.04 bits per weight over the 64.8B source parameters.
• Drafter (dflash2/): ricursiveAI/Ripple-65B-Preview-DFlash2, unmodified BF16 (8.08 GB). Osaurus quantizes it to 4-bit when it loads.

If 44 GB fits, use JANG_4D: it is much closer to the original (KL 0.0024 vs 0.084).

Quality vs the original model

The test set is 221,809 assistant positions, 30,000 or more in each of 7 domains, scored against the BF16 release run on the original code, with top-128 KL. The assistant turns were written by Ripple itself. None of these conversations were used for calibration; the choice between rounding methods per module did look at their input rows, so the scores may be slightly optimistic.

	mean KL ↓	p99 KL ↓	top-1 ↑
BF16 on this runtime (measurement floor)	0.00017	0.0016	99.48%
Ripple-65B-Preview-JANGH2 (24.6 GB)	0.0841	0.939	90.28%
for reference: Ripple-65B-Preview-JANG_4D (43.7 GB)	0.00239	0.0263	98.30%

Change in negative log-likelihood of the held-out tokens: +0.082 (JANG_4D: +0.002).

By domain (mean KL · top-1):

domain	positions	JANGH2	JANG_4D
Osaurus app tasks	30,026	0.052 · 93.3%	0.0016 · 98.8%
terminal	32,049	0.057 · 91.3%	0.0017 · 98.6%
reasoning / math	31,341	0.060 · 91.1%	0.0018 · 98.5%
agentic tool loops	30,839	0.066 · 91.3%	0.0018 · 98.6%
coding	36,021	0.081 · 89.8%	0.0026 · 97.9%
cybersecurity	31,076	0.122 · 88.3%	0.0032 · 98.0%
multilingual, science, creative	30,457	0.153 · 86.9%	0.0041 · 97.7%

App tasks, terminal, reasoning and agentic loops hold up best. Multilingual and creative text lose the most.

Tool decisions and reasoning

• Starting a tool call: at 250 points where the original model starts a tool call, JANGH2's top choice matches at 233 (93.2%; JANG_4D 99.2%).
• Closing reasoning: at all 256 points where the transcript closes the model's reasoning (</think>), JANGH2's top choice is </think>.
• First answer token: matches at 96.2% of 364 turns; end of turn at 98.5% of 336.

Speculative decoding

dflash2/ holds the model's own DFlash2 drafter, which proposes up to 15 tokens per step for the main model to verify. Every drafted token is verified by the main model, so output follows the main model's distribution. Osaurus picks the draft length on the fly. On the capture GPU with the full-precision model, the drafter's first token was accepted 68-83% of the time and it got 2.0-5.0 drafted tokens accepted per step, depending on the domain. Acceptance with this 2-bit model has not been measured, and speed on a Mac depends on the machine.

Serving contract

• Reasoning: the model decides on each turn whether to think. The chat template ends at the assistant header and never opens <think>. There is no thinking switch and there are no effort levels. Earlier reasoning stays in the history by default (clear_thinking=false).
• Tool calls: JSON inside <tool_call> ({"name": ..., "arguments": {...}}); tool results go back as <tool_response> blocks in a user turn. For tool_choice: "required", use strict tools ("strict": true, additionalProperties: false), as the original model card recommends.
• Sampling: temperature 1.0, top-p 0.95 (generation_config.json), the model's distribution unchanged. The original release ships no sampling defaults.
• EOS: <|im_end|>, <|endoftext|>. No BOS token in chat.
• Context: the original card states up to 1M tokens. Only the 16 full-attention layers keep a KV cache that grows with the context.

What's in the bundle

All bit widths below were measured from the shard bytes.

• gate_proj / up_proj / down_proj: JANGH 2-bit, Hadamard-32 rotation, odd-cubic codebook, fp16 row scales (×80 each).
• q / k / attention-gate projections: affine 6-bit (×80 each). v_proj: 8-bit ×57, 6-bit ×23. o_proj: 6-bit ×74, 8-bit ×6.
• lm_head affine 8-bit, embeddings 6-bit. Norms and per-layer value-residual weights bf16.
• dflash2/: the drafter (model.safetensors, config.json, its README.md, LICENSE, provenance.json with the source revision and sha256).

Build details

• Calibration: 1.52M tokens of Ripple's own outputs and real tool loops. The mix is coding across many languages, multi-turn agentic tool loops, reasoning/math, terminal sessions, cybersecurity, and multilingual/science/creative text. Long rows up to 30k tokens. Held-out conversations were split off first by source.
• Hessians: per-linear input statistics from a layer-streamed run of the BF16 model in its original code, in the Hadamard-rotated basis for the 2-bit projections.
• GPTQ vs plain rounding: chosen per projection on held-out input rows; GPTQ won on all 240. For example, layer 0 down_proj: relative output error 0.08 with GPTQ vs 0.54 with plain rounding.
• Row-scale gain correction: each row scale is multiplied by <w,w>/<w,q>. It raises per-row error but lowered end-to-end KL (0.092 vs 0.123 on the development set), so it is kept.
• Layer check: every layer was scored with its feed-forward swapped back to the JANG_4D layer. Layers 0 and 1 carry the model's very large down_proj outliers, but with GPTQ they cost only 0.0003 and 0.0012 KL. The loss is spread across depth rather than concentrated in a few layers, so no layer needed to stay affine.
• Verification: every tensor file is aligned, there is one index, every module's bits and format match the config, and every source tensor is accounted for. The bundle loaded through the runtime scores within 0.00004 KL of the offline measurement.