Harsha001/Ripple-65B-abliterated-ROCmFPX

Ripple-65B abliterated ROCmFPX

Update, 7 November 2026: this repo now has the abliterated model. The files here were replaced with quants of orcarouter's abliterated (refusal-removed) Ripple. The abliteration is built on Ripple-65B-Preview, the preview release of the model. When ricursiveAI release the final Ripple-65B and an abliterated version of it is available, this repo will be updated to it.

ROCmFPX GGUF quants of orcarouter/Ripple-65B-abliterated-GGUF, the abliterated (refusal-removed) version of ricursiveAI/Ripple-65B-Preview, a dense 65B model. The files are made for AMD GPUs (Strix Halo) with the ROCmFPX llama.cpp fork.

Read before use. This model has had most of its safety training removed. It will answer many harmful, unethical or illegal requests that the original Ripple refuses. It is meant for research: safety and refusal studies, red teaming, robustness tests. You are responsible for how you use it and for everything it writes; add your own safety and moderation layers before you put it in front of anyone. Use must follow the Apache 2.0 license and the law.

This repo held quants of the original Ripple-65B-Preview until 7 November 2026. They were replaced by these files; the old ones are still in the repo's file history.

Files

File	Size	Mean KLD vs Q8_0	Same top token	Fits
Ripple-65B-abliterated-Q8_0_ROCMFPX.gguf	66.8 GB	0.0057	97.4%	128 GB Strix Halo
Ripple-65B-abliterated-Q6_K_ROCMFPX.gguf	53.6 GB	0.0075	96.7%	128 GB Strix Halo, long context
Ripple-65B-abliterated-Q4_0_ROCMFP4_STRIX_A8.gguf	41.5 GB	0.026	93.5%	64 GB and up
Ripple-65B-Preview-DFlash2-BF16.gguf	8.1 GB			optional drafter, see below

Other 4-bit files of the same abliterated weights, measured the same way:

File	Size	Mean KLD vs Q8_0	Same top token
orcarouter Mix-4bit (stock llama.cpp types)	32.0 GB	0.033	92.7%
stock Q4_K_M	38.8 GB	0.81	64.0%

• Ours or orcarouter's 4-bit? On this test our 4-bit file is closer to the full model, and orcarouter's is 9.5 GB smaller and runs on stock llama.cpp. On orcarouter's own test (chat, code and multilingual text at 2K context, against BF16) their Mix-4bit scores KLD 0.0059. The two tests are different, so do not compare those numbers with the table here. If you want a small file or stock llama.cpp, use theirs.
• Do not use a stock Q4_K_M of this model. The abliteration changed the attention output matrices in all 80 layers, and those break at stock 4-bit (KLD 0.81; the same recipe on the original Ripple gives 0.038). Keeping only those matrices at Q6_K brings it to 0.076. orcarouter warn about this too. Our 4-bit file keeps all of attention and the output layer at 8 bit (ROCmFPX Q8) and the rest at 4 bit (ROCmFP4), which avoids it.
• The Q6_K_ROCMFPX file is named so that Hugging Face lists it as 6-bit. Its weights are the ROCmFPX Q6_0_ROCMFPX type, not a stock Q6_K, and it needs the fork like the other files.
• How it was measured: llama-perplexity, 40 chunks of 512 tokens of wikitext-2, against a stock Q8_0 of orcarouter's BF16 GGUF (BF16 does not fit our 128 GB test machine; stock Q8_0 is very close to BF16). Each file was expanded to Q8_0 and scored on an NVIDIA GB10; on the original Ripple this added about 0.0016 KLD. The stock and orcarouter files were scored directly. This is general English text, not code or chat.
• The abliterated model is a little harder to quantize than the original: with the same recipes the drift is 15 to 35% higher than in our old Ripple files.
• A chat check ("What is the capital of France?") gave the right answer and stopped cleanly with every file. Not yet run on a Strix Halo: please report speed and quality in the Community tab.

What the abliteration changed

orcarouter edited 161 of the 1203 tensors: the attention output matrix of every layer and the feed-forward down matrix of some middle layers, by about 1.7% each. On the test above, the abliterated model differs from the original by KLD 0.0082 (same top token 96.5%), a little more than our old 6-bit file differed from the original. orcarouter measured refusal of harmful prompts dropping from 95.5% to 11.8%, with general benchmarks (MMLU, GSM8K) within run-to-run noise; see their card for the details. We did not test refusals ourselves.

The chat template comes from orcarouter's files. It is the same ChatML format as the original, plus a system prompt block, tool calls and reasoning (<think>) handling. We have only tested plain chat.

Run

Ripple's architecture (ricursive) is not in upstream llama.cpp yet. The ROCmFPX fork has it on main (port of llama.cpp PR #31692), together with the ROCmFPX types these files use.

git clone https://github.com/HarshaVardhan3002/ROCmFPX
cd ROCmFPX

# ROCm / HIP on Strix Halo
cmake -B build -DGGML_HIP=ON -DAMDGPU_TARGETS=gfx1151
# or Vulkan
# cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j

./build/bin/llama-server -m Ripple-65B-abliterated-Q6_K_ROCMFPX.gguf -ngl 99 -fa on -c 32768 --jinja

• Always pass -c. The model's default context is 2M tokens, and llama.cpp then tries to allocate a KV cache that does not fit.
• --jinja uses the chat template stored in the file.

Faster with the drafter (DFlash2)

Ripple-65B-Preview-DFlash2-BF16.gguf (8.1 GB) is ricursiveAI's own draft model, ricursiveAI/Ripple-65B-Preview-DFlash2, converted to GGUF without changes (BF16). It guesses several tokens at a time from Ripple's own hidden states, and Ripple checks the guesses in one pass. Ripple still chooses every token, so the answers stay Ripple's. It was trained on the original Ripple, and it works just as well with the abliterated one. It needs the fork from 7 November 2026 or later.

./build/bin/llama-server -m Ripple-65B-abliterated-Q6_K_ROCMFPX.gguf -md Ripple-65B-Preview-DFlash2-BF16.gguf \
  -ngl 99 -ngld 99 -fa on -c 16384 --jinja --spec-type draft-dflash --spec-draft-n-max 7

On an NVIDIA GB10 with a stock Q8_0 of the abliterated model, greedy decoding, llama-speculative-simple, a Python function prompt went from 3.4 to 15.6 tokens/s (4.6x) with --spec-draft-n-max 7; 69% of the guessed tokens were accepted. With the original Ripple we measured:

Prompt	Without drafter	--spec-draft-n-max 15	--spec-draft-n-max 7
Python function	3.4 tokens/s	14.1 (4.1x)	13.8
Explain why the sky is blue	3.4	6.2	6.9 (2.0x)
Short maths question	3.4	8.9 (2.6x)	7.3
Short story	3.4	4.9	5.4 (1.6x)

• Code gains the most, free prose the least. 7 is the safer default; use 15 for code.
• With the original Ripple, 6 of 8 runs gave exactly the same text as without the drafter. In the other 2, one word changed where Ripple saw two choices as almost equally likely (Ripple checks several tokens at once, and that rounds very slightly differently), and the answer went on from there.
• The drafter was trained on 16K-token sequences. Past about 16K tokens of context it will guess worse, so the speed gain shrinks; Ripple still checks every token.
• Not yet run on a Strix Halo. The drafter adds about 8 GB, so use it with the Q6 or 4-bit file on a 128 GB machine.

Credits

• Original model: ricursiveAI/Ripple-65B-Preview, Apache-2.0.
• Abliteration: orcarouter/Ripple-65B-abliterated-GGUF, Apache-2.0. These files are quantized from their BF16 GGUF.
• Ripple llama.cpp port: llama.cpp PR #31692.
• Draft model: ricursiveAI/Ripple-65B-Preview-DFlash2, Apache-2.0. DFlash2 runtime from llama.cpp PR #27342.

This repo is not affiliated with or endorsed by ricursiveAI or orcarouter. The model's outputs do not reflect our views.