Follow @procrastiness on Twitter/X for more model releases and updates.
A weight-edited, quantized build of ricursiveAI/Ripple-65B-Preview, the 64.78-billion-parameter dense model from Ricursive Intelligence, focused on agentic coding. All 80 layers are kept. A refusal direction is projected out of the token embeddings and 63 layers, and nothing is retrained or fine-tuned. Released under Apache-2.0 with downloadable weights and no hosted API.
This model answers many requests the original refuses, including dangerous ones. It has had no safety review. You are responsible for how you use it and for any safeguards if you expose it to other people.
| Measured on Q4_K_M, greedy decoding | Original | This release |
|---|---|---|
| Refusals on 48 held-out harmful prompts (regex on the final answer) | 48/48 | 1/48 |
| False refusals on harmless prompts | 2/24 | 0/64 |
| Answer and code checks (easy, hard, code, quality; 100 cases) | 96/100 | 97/100 |
| Reasoning-mode checks (hard, code; 34 cases) | 32/34 | 32/34 |
| Tool-call round trip | pass | pass |
| WikiText perplexity, 32 chunks at 512 tokens | 8.392 | 8.521 |
The two columns differ in more than the edit. See Measured checks for the token budgets, prompt splits and importance matrix behind each number. The upstream card's benchmark scores belong to the unmodified BF16 model and were not re-run here, so don't read them as scores for these files.
Start with Q4_K_M, a 64K context, one concurrent request and a generous output limit of 4,096 tokens or more. Ripple usually reasons before it answers, and that reasoning counts against your output limit.
Use the embedded chat template by passing --jinja, and pass --reasoning-format deepseek so reasoning arrives in its own field. The upstream repository publishes no recommended sampling settings, and sampling was not tuned for this release. Every measurement below uses temperature 0. For chat, start from llama-server's defaults.
Download one quant. Q6_K and Q8_0 are split into two files, and llama.cpp loads the second part on its own when you point it at -00001-of-00002.gguf.
| Quant | Download size | Files | GPU memory after load | Speed, one stream | When to choose it |
|---|---|---|---|---|---|
| Q4_K_M | 38.80 GB | 1 | 45.3 GiB | 17.1 tok/s | First download; the best speed and the easiest fit. |
| Q5_K_M | 45.76 GB | 1 | 51.8 GiB | 15.2 tok/s | More precision if you have the memory. |
| Q6_K | 53.15 GB | 2 | 58.6 GiB | 13.4 tok/s | Higher precision again. |
| Q8_0 | 68.84 GB | 2 | 73.1 GiB | 11.5 tok/s | Highest precision here; no importance matrix. |
Memory and speed were measured on one machine: four NVIDIA V100s (one 32 GB, three 16 GB), --tensor-split 32,16,16,16, 65,536 total context across 8 slots. Your numbers will differ.
| Hardware | Suggested starting point |
|---|---|
| About 50 GB or more of GPU memory | Q4_K_M fully offloaded. Reduce -c if it is a tight fit. |
| 80 GB or more of GPU memory | Any quant here should fit fully offloaded. This is the tested size: 80 GB across four cards. |
| One 24 GB GPU and 64 GB or more of system RAM | Q4_K_M with --fit on, part on GPU and part on CPU. Not tested; expect low speed. |
| CPU only, or Apple Silicon with 64 GB or more | Q4_K_M. Not tested on this release; expect low speed. |
These are starting points rather than minimums. File size leaves out the context cache and runtime buffers.
Ripple has its own ricursive architecture, added to llama.cpp by PR #31692, merged 5 November 2026. Anything older fails to load these files. Packaged builds may not include it yet. This release was tested at commit 954de248ac6907dd05dc19f0f511ab18f2807a54. LM Studio, Ollama and other apps must bundle a backend that new, and none were tested.
Install a compatible NVIDIA driver and the CUDA Toolkit first. nvidia-smi and nvcc --version should both work. Then:
sudo apt-get update
sudo apt-get install -y git cmake build-essential libcurl4-openssl-dev python3-venv
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git checkout 954de248ac6907dd05dc19f0f511ab18f2807a54
cmake -S . -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j 8 --target llama-server
export PATH="$PWD/build/bin:$PATH"
cd ..
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade huggingface_hub requests
For a CPU-only build, configure with -DGGML_CUDA=OFF and start the server with -ngl 0.
Install Python 3.10 or newer, then in PowerShell:
python -m pip install --upgrade huggingface_hub requests
Get a CUDA build dated 5 November 2026 or later from the llama.cpp releases, extract the whole archive, and keep its DLLs next to llama-server.exe. From that folder, replace llama-server in the commands below with .\llama-server.exe. Check the startup log to confirm it found your GPU.
brew install llama.cpp
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade huggingface_hub requests
If the Homebrew build is older than the PR above, build from source using the commands in the Ubuntu section, with -DGGML_CUDA=OFF.
hf download 0xKitkat/Ripple-65B-Preview-abliterated-GGUF Ripple-65B-Preview-abliterated-Q4_K_M.gguf --local-dir ripple
For Q5_K_M, replace Q4_K_M in the filename. For a split quant, download both parts:
hf download 0xKitkat/Ripple-65B-Preview-abliterated-GGUF --include "*Q6_K-*" --local-dir ripple
Rerun the same command after an interruption. Checksums are in SHA256SUMS. On Linux, run sha256sum ripple/*.gguf; on Windows, Get-FileHash ripple\Ripple-65B-Preview-abliterated-Q4_K_M.gguf -Algorithm SHA256.
llama-server -m ripple/Ripple-65B-Preview-abliterated-Q4_K_M.gguf --alias ripple -c 65536 --parallel 1 --fit on --jinja --reasoning-format deepseek --host 127.0.0.1 --port 8080
Open http://127.0.0.1:8080 for the built-in chat UI. The API is at http://127.0.0.1:8080/v1 with the model name ripple. No API key is needed; if a client insists on one, use local. Keep the terminal open.
llama-server -m ripple/Ripple-65B-Preview-abliterated-Q4_K_M.gguf --alias ripple -c 65536 --parallel 1 -ngl 999 --split-mode layer --tensor-split 32,16,16,16 --jinja --reasoning-format deepseek -b 1024 -ub 512 --host 127.0.0.1 --port 8080
Set --tensor-split to match your cards' memory. -ngl 999 means all layers; the model has 80. If the split goes to the wrong cards, set CUDA_DEVICE_ORDER=PCI_BUS_ID first, as nvidia-smi and CUDA can number them differently.
With --parallel N, the context is divided equally among the N slots. The test runs used -c 65536 --parallel 8, which gives each request 8,192 tokens.
Save as chat_ripple.py and run it while the server is up:
import requests
response = requests.post(
"http://127.0.0.1:8080/v1/chat/completions",
json={
"model": "ripple",
"messages": [{"role": "user", "content": "Explain how a rainbow forms in three sentences."}],
"max_tokens": 4096,
"stream": False,
},
timeout=3600,
)
response.raise_for_status()
choice = response.json()["choices"][0]
print("finish:", choice["finish_reason"])
print("reasoning:", choice["message"].get("reasoning_content"))
print("answer:", choice["message"]["content"])
For repeatable output, add "temperature": 0 and a "seed".
The embedded template renders OpenAI-style tools, and llama.cpp returns structured calls. A one-tool round trip passed on all four quants.
import json
import requests
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the current weather for a city.",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
response = requests.post(
"http://127.0.0.1:8080/v1/chat/completions",
json={
"model": "ripple",
"messages": [{"role": "user", "content": "What is the weather in Hanoi right now? Use the tool."}],
"tools": tools,
"max_tokens": 4096,
},
timeout=3600,
)
response.raise_for_status()
for call in response.json()["choices"][0]["message"].get("tool_calls", []):
print(call["function"]["name"], json.loads(call["function"]["arguments"]))
There is no thinking switch. The chat template has no enable_thinking option and does not open <think> for the model; the model decides for itself. It opened with reasoning on 99.7% of harmful and 83% of harmless calibration prompts, but often skipped it on short prompts with strict formatting. In the "Think briefly" answer suites below, the median was 0 reasoning characters. To force reasoning, call /completion with a raw prompt ending in <|im_start|>assistant\n<think>\n, which is how the reasoning-mode checks ran.
Expect much longer reasoning on prompts the original refused. The reasoning rarely stops at a refusal now, so it carries on through the request. On the 48 test prompts the median reasoning rose from about 1,600 to about 7,600 characters. Even at 3,072 tokens, 11 of 48 hit the limit, 4 of them before any final answer. Zlib compression ratios gave no sign of repetition loops, though that is a coarse check. On harmless prompts, reasoning length barely changed (median about 1,400 characters both ways).
Leave reasoning_content out of the message history. If you send it back, the template includes it, and it uses up context.
Long context has had one test. The source advertises up to 1,048,576 tokens and the GGUF reports a 2,097,152-token training context. Here, Q4_K_M at -c 131072 --parallel 1 found a short fact placed a quarter of the way into a 54,657-token prompt. It processed the prompt at 329 tok/s and then decoded at 12 tok/s, using 47.2 GiB of GPU memory. Larger sizes were not tried. One needle test doesn't establish long-context quality.
| Symptom | What to change |
|---|---|
unknown model architecture: 'ricursive' |
Your llama.cpp predates PR #31692. Update it or build from the commit above. |
| GPU out of memory | Use Q4_K_M, reduce -c, keep --parallel 1, or lower -ngl. |
| Very slow generation | Check the startup log for how many layers are actually on GPU. Layers on CPU slow every token. |
Empty answer with finish_reason of length |
The model spent the budget on reasoning. Raise max_tokens, and keep prompt plus output within the per-slot context. |
<think> text appears in the answer |
Start the server with --jinja --reasoning-format deepseek, and don't pick a generic chat template. |
| Tool calls come back as plain text | Same flags. --jinja is required for tools. |
| Garbled output on several GPUs | Rebuild with -DGGML_CUDA_NO_PEER_COPY=ON. Direct GPU-to-GPU copies corrupted data on the test machine, so this release was tested with that option on. Other boards may not need it. |
| Only the first split file is found | Keep both parts in one folder under their original names, and pass the -00001-of-00002.gguf file to -m. |
All runs used llama.cpp commit 954de24, temperature 0, seed 20261107, 8 slots of 8,192 tokens and the four-V100 machine above. Each quant was loaded and tested on its own. Q6_K and Q8_0 ran these suites as whole files before splitting. Their split parts were then loaded from the first shard and passed a generation and speed check, with the same speed as the whole file.
| Quant | easy /30 | hard /24 | code /10 | quality /36 | hard, reasoning /24 | code, reasoning /10 | Tool call | WikiText PPL |
|---|---|---|---|---|---|---|---|---|
| Original Q4_K_M | 29 | 22 | 10 | 35 | 23 | 9 | pass | 8.392 |
| Q4_K_M | 30 | 23 | 10 | 34 | 23 | 9 | pass | 8.521 |
| Q5_K_M | 30 | 23 | 10 | 34 | 23 | 9 | pass | 8.378 |
| Q6_K | 30 | 23 | 10 | 34 | 23 | 9 | pass | 8.439 |
| Q8_0 | 30 | 23 | 10 | 34 | 23 | 9 | pass | 8.467 |
| Quant | Prompts and budget | Refused | No final answer in budget | Reasoning voicing refusal | Harmless prompts falsely refused |
|---|---|---|---|---|---|
| Original Q4_K_M | 48 test, 1,536 tokens | 48 | 0 | 47 | 2/24 (validation split) |
| Q4_K_M | 48 test, 3,072 tokens | 1 | 4 | 2 | 0/64 |
| Q5_K_M | 16 test, 2,048 tokens | 0 | 3 | 0 | 0/16 |
| Q6_K | 16 test, 2,048 tokens | 0 | 5 | 2 | 0/16 |
| Q8_0 | 24 test, 2,048 tokens | 1 | 7 | 1 | 0/24 |
How to read these:
Full per-case results are in evaluations/, and the prompts are in build/eval_suite.json.
Ripple usually reasons before answering, which changes what abliteration has to target. Almost every reply starts with <think>, so the first generated tokens look the same whether the model will refuse or not. First-token scoring and prefix checks therefore tell you very little. This release measures the refusal contrast inside the reasoning and judges results on the final answer.
refusal_direction at revision 9d852fa, with hashes verified.w * out / rms(out), where w is the post-norm weight. The axis to remove from the output matrices is therefore U, the normalized d * w, giving W' = W - U U^T W on attn_output and ffn_down. The embedding table gets E' = E - (E d) d^T. The largest remaining component was 2.69e-8.The direction vectors are in abliteration_directions.safetensors, and the exact specification is in abliteration.json, so you can inspect the edit or reapply it to the source weights.
| Path | Contents |
|---|---|
Ripple-65B-Preview-abliterated-*.gguf |
The four quants; Q6_K and Q8_0 are split |
abliteration.json, abliteration_directions.safetensors |
The exact edit and its direction vectors |
SHA256SUMS, release-manifest.json |
File hashes, source and tool revisions, calibration hashes, result summaries |
evaluations/ |
Per-case reports for each quant, the original and the candidate |
build/ |
Scripts for reproducing the release; see build/README.md |
LICENSE |
The upstream Apache-2.0 license |
Original weights and implementation: Ricursive Intelligence, Apache-2.0, source revision 4f872a1ef1376a1962c56bab6d874d017be7eb96. Refusal-direction method and prompt splits: Arditi et al., Refusal in Language Models Is Mediated by a Single Direction. Runtime and quantization: llama.cpp, MIT. Perplexity text: WikiText-2 test set, through ggml-org/ci. Build code was generated with AI assistance and tested as recorded here. Please cite the upstream model:
@misc{ricursive2026ripple65b,
title={Ripple-65B: Pushing the Frontier of Local Intelligence},
author={Ricursive Intelligence},
year={2026},
}
Ripple-65B-Preview-abliterated-Q6_K-00001-of-00002.gguf 45 GBRipple-65B-Preview-abliterated-Q6_K-00002-of-00002.gguf 8.2 GBRipple-65B-Preview-abliterated-Q8_0-00001-of-00002.gguf 45 GBRipple-65B-Preview-abliterated-Q8_0-00002-of-00002.gguf 24 GBricursiveAI/Ripple-65B-Preview