---
license: apache-2.0
base_model:
  - HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive
  - Qwen/Qwen3.5-27B
  - dnhkng/RYS-Qwen3.5-27B-FP8-XL
tags:
  - qwen3_5
  - qwen3.5
  - uncensored
  - RYS
  - GGUF
  - coding
  - reasoning
  - hybrid
  - spaced-repetition-layers
language:
  - en
  - zh
  - ja
  - ko
  - fr
  - de
  - es
  - pt
  - ru
  - ar
pipeline_tag: text-generation
model_type: qwen3_5
quantized_by: jackasda211233
---

# RYS-Qwen3.5-27B-Uncensored-Splice-GGUF

An uncensored, coding-focused Qwen3.5-27B with RYS (Repeat Your Self) layer duplication applied via a novel **splice method** — combining uncensored fine-tuned weights with dnhkng's validated RYS duplicate zone for enhanced reasoning and coding performance.

## Why This Model Exists

### The Censorship Problem

Over the past several years, the author has observed a consistent trend of **increasing censorship across all major model releases** — particularly in domains where unrestricted knowledge is most critical: biology, legal studies, and medicine. Models that were once helpful for researching drug interactions, understanding case law, or studying anatomical systems now refuse or heavily sanitize responses in these areas. This model is an attempt to push back against that trend — a smaller model that aims to be more capable than the already remarkable Qwen3.5-27B base, without the artificial knowledge restrictions.

### The Original RYS Experience

The original RYS-Qwen3.5-27B by [dnhkng](https://github.com/dnhkng) was exceptional as a coding agent. In the author's experience over 40+ hours of comparative usage against GPT-5.3 Codex on a complex multi-service project (a custom agent OS with a vault messaging app, webhook bridge, and multi-agent backend), dnhkng's RYS model identified and fixed deep architectural bugs that Codex missed entirely — such as silently misdirected conversation routing between the vault app and the backend, where messages were being sent to a dead webhook port while the actual agent bridge was running on a different service. The RYS model traced the full request chain across three services, found the disconnected bridge, and rewired the connection. However, even the original (censored) RYS model and the standard Qwen3.5-27B exhibited a frustrating pattern: when asked to fix issues in existing infrastructure, the model would silently attempt to create an entirely new backend or service rather than modify the pre-existing one — effectively avoiding touching the original codebase. The author had to repeatedly, specifically instruct the model to work on the existing backend, not build a replacement. This avoidance behavior appeared to stem from the safety guardrails treating modifications to running services as potentially harmful. This model eliminates that friction — it will work directly on your existing codebase and infrastructure without requiring constant re-prompting.

This model attempts to retain that level of deep architectural reasoning while adding unrestricted instruction following and direct, non-evasive engagement with existing codebases.

### Previous Attempt & Lessons Learned

An earlier version of this uncensored RYS model was released prematurely. While that version performed well conversationally and in reasoning tasks, **it failed as a coding agent** — calling wrong tools, making poor file edits, and exhibiting unreliable behavior in agentic workflows. It was originally intended as a placeholder for testing, but gained unintended traction. This release (the Splice variant) is the proper replacement, built to fix those issues:

- ✅ **Correct tool calling** — verified over 4+ hours of live MCP tool integration testing
- ✅ **Decreased looping** — no degenerate repetition observed at recommended sampling parameters
- ✅ **Proper code edits** — clean file writes, proper scoping, no hallucinated variables
- ✅ **Creative & non-refusal** — retains the uncensored fine-tune's willingness to follow all instructions
- ✅ **Agentic capability** — successfully completed 80k-token self-guided coding projects autonomously

### Technical Motivation

The standard Qwen3.5-27B is an exceptional model, but its safety guardrails actively interfere with legitimate development workflows:

- **SSH/Network access refusal**: The base model refuses to SSH into the user's own machines, citing "security risks" — making it unusable as a remote development agent
- **Memory system avoidance**: When building applications with persistent memory (SimpleMem, databases, caches), the base model avoids or sanitizes key portions of the memory implementation
- **API integration refusal**: The base model hesitates or refuses to add API access, webhook endpoints, or external service integrations into programs — treating routine development patterns as dangerous
- **Tool calling interference**: Safety filters interfere with proper MCP tool calling, causing malformed or incomplete tool invocations

This model was created to solve these issues by default, while retaining — or even surpassing — the base model's coding and reasoning capabilities. It is primarily designed as a **coding agent model** for use with frameworks like Claude Code, OpenCode, Qwen-Agent, or any OpenAI-compatible agent scaffold.

## Disclaimer & Responsible Use

> ⚠️ **Uncensored Model:** As far as the author can determine, this model is completely uncensored when prompted with appropriate system instructions. By default, the model will not produce highly graphic or explicit material unless the system prompt specifically instructs it to do so.
>
> **The author is not responsible for how this model is used.** Any actions taken with this model are solely the responsibility of the user. Use in accordance with applicable laws and ethical standards. This model is intended for legitimate software development, research, and creative work.

## Model Overview

| Property | Value |
|----------|-------|
| **Architecture** | Qwen3.5 (Hybrid SSM — Gated DeltaNet + Full Attention) |
| **Total Layers** | 72 (64 base + 8 duplicated via RYS) |
| **Parameters** | ~29.8B |
| **RYS Config** | (26,34) — dnhkng's validated Pareto-optimal XL configuration |
| **Context Length** | 262,144 tokens |
| **Thinking Mode** | Yes (DeepSeek-style `<think>...</think>`) |
| **full_attention_interval** | 4 (Full attention at layers 3,7,11,...71) |
| **Vocabulary** | 248,320 tokens (GPT-2 BPE) |

## Available Quantizations

| File | Quant | Size | BPW | Notes |
|------|-------|------|-----|-------|
| `RYS-Qwen3.5-27B-Uncensored-Splice-BF16.gguf` | BF16 | 56 GB | 16.0 | Full precision, best quality |
| `RYS-Qwen3.5-27B-Uncensored-Splice-Q8_0.gguf` | Q8_0 | 30 GB | 8.0 | Near-lossless |
| `RYS-Qwen3.5-27B-Uncensored-Splice-Q6_K.gguf` | Q6_K | 23 GB | 6.5 | Very good quality |
| `RYS-Qwen3.5-27B-Uncensored-Splice-IQ4_NL.gguf` | IQ4_NL | 17 GB | 4.5 | Good quality, fits in 24GB VRAM |

## How This Model Was Built

### The Splice Method

This model uses a novel construction technique we call **"Splice"** — instead of duplicating layers from the uncensored model itself, we splice in the already-validated RYS duplicate zone from dnhkng's official published model.

**Layer Composition:**

```
Layers  0–25:  HauhauCS Uncensored fine-tuned weights (26 layers)
Layers 26–41:  dnhkng's official RYS-Qwen3.5-27B-FP8-XL layers 26–41 (16 layers = 8 duplicated)
               Originally FP8 → F16, converted to BF16 during splice
Layers 42–71:  HauhauCS Uncensored fine-tuned weights (30 layers)
```

**78% of layers are uncensored fine-tuned weights** (56 of 72 layers), giving strong uncensored behavior while the central reasoning zone uses dnhkng's validated duplicate block.

### Why Splice Instead of Direct Duplication?

We tested multiple approaches:

1. **Pure uncensored RYS (24,36)** — 76 layers, all weights from uncensored model. Result: unstable, looped at lower temperatures.
2. **Pure uncensored RYS (26,34)** — 72 layers, all weights from uncensored model. Result: worse looping than (24,36).
3. **HybridBase (24,36)** — 76 layers, duplicate zone from clean base Qwen3.5-27B BF16. Result: stable but looped on complex coding tasks, less creative.
4. **Splice (26,34)** — 72 layers, duplicate zone from dnhkng's official RYS model. Result: **stable, creative, best coding quality, truly uncensored.** ✅

The Splice method works because:
- dnhkng's RYS layers went through FP8 quantization, which may smooth weight outliers
- The (26,34) config is the Pareto-optimal configuration validated by dnhkng's math+EQ probe sweep on the base model
- 78% uncensored layer ratio preserves the fine-tuned personality while the central reasoning zone provides disciplined inference

### The Hybrid SSM Attention Constraint

Qwen3.5-27B is **not** a standard transformer — it uses a hybrid architecture where two types of layers alternate in a strict repeating pattern:

```
Layer Type Pattern (repeats every 4 layers):
  [0] Linear Attention (Gated DeltaNet / SSM)
  [1] Linear Attention (Gated DeltaNet / SSM)
  [2] Linear Attention (Gated DeltaNet / SSM)
  [3] Full Attention (GQA — 24 heads Q, 4 heads KV, 256 dim)
  [4] Linear Attention ...
  ...repeating...
```

This pattern is governed by `full_attention_interval=4` in the model config. **The total layer count must be divisible by 4** for this pattern to remain valid. If violated, llama.cpp and other GGUF runtimes cannot reconcile the layer types and will crash at load.

This constraint eliminates many RYS configurations:

| RYS Config | Total Layers | Divisible by 4 | Status |
|------------|-------------|----------------|--------|
| (24,35) | 75 | ❌ No | Crashes |
| **(24,36)** | **76** | **✅ Yes** | **Works** |
| **(26,34)** | **72** | **✅ Yes** | **Works (this model)** |
| (33,34) | 65 | ❌ No | Crashes |

The (26,34) config duplicates 8 layers (26–33), which contains exactly **2 Full Attention layers** (at positions 27 and 31) and **6 Gated DeltaNet layers**. This preserves the 4-layer repeating pattern perfectly:

```
Layers 24-27: [DeltaNet, DeltaNet, DeltaNet, FullAttn] ← original
Layers 28-31: [DeltaNet, DeltaNet, DeltaNet, FullAttn] ← original
Layers 32-35: [DeltaNet, DeltaNet, DeltaNet, FullAttn] ← DUPLICATED from 24-27
Layers 36-39: [DeltaNet, DeltaNet, DeltaNet, FullAttn] ← DUPLICATED from 28-31
```

### F16 → BF16 Tensor Conversion

The dnhkng RYS source GGUF uses F16 (IEEE 754 half-precision), while the uncensored model uses BF16 (Brain Float 16). These are different 16-bit formats:

- **F16**: 1 sign + 5 exponent + 10 mantissa bits — higher precision, smaller range
- **BF16**: 1 sign + 8 exponent + 7 mantissa bits — lower precision, same range as float32

During the splice, F16 tensors are converted to BF16:
```
F16 → Float32 (lossless upcast) → BF16 (take upper 2 bytes of float32)
```

This conversion loses ~3 bits of mantissa precision but gains the dynamic range benefits of BF16, which is what the rest of the model uses. In practice, this has no measurable impact on output quality.

### Source Models & Attribution

This model would not exist without the work of these authors:

**1. [Qwen Team](https://huggingface.co/Qwen) — Qwen3.5-27B (Base Architecture)**
- [Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B) — The foundation model. All 64 original layers, the tokenizer, the hybrid SSM architecture, and all training were done by the Qwen team. This model is a derivative work.
- License: Apache 2.0

**2. [HauhauCS](https://huggingface.co/HauhauCS) — Uncensored Fine-Tune**
- [HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive](https://huggingface.co/HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive) — Provides the uncensored weights used in **56 of 72 layers** (layers 0–25 and 42–71). This fine-tune removes the safety guardrails that interfere with legitimate coding workflows. The "Aggressive" variant was chosen for maximum uncensoring.
- Contribution: 78% of this model's total layer weights

**3. [dnhkng](https://github.com/dnhkng) — RYS Method & Validated Layer Configuration**
- [dnhkng/RYS-Qwen3.5-27B-FP8-XL](https://huggingface.co/dnhkng/RYS-Qwen3.5-27B-FP8-XL) — Provides the **duplicate zone layers** (layers 26–41). These are the base Qwen3.5-27B weights that went through FP8 quantization and were validated as the optimal duplication zone via systematic math+EQ probe sweeps.
- [RYS GitHub Repository](https://github.com/dnhkng/RYS) — The RYS method implementation
- [LLM Neuroanatomy: How I Topped the LLM Leaderboard Without Changing a Single Weight](https://dnhkng.github.io/posts/rys/) — Original RYS research
- [LLM Neuroanatomy II: Modern LLM Hacking and hints of a Universal Language?](https://dnhkng.github.io/posts/rys-ii/) — Extended research with Qwen3.5-27B, including the (26,34) Pareto-optimal configuration used in this model
- Contribution: 22% of this model's total layer weights (the critical reasoning duplication zone)

**4. [ikawrakow](https://github.com/ikawrakow) — ik_llama.cpp**
- Quantization tooling (llama-quantize) used to produce the Q8_0, Q6_K, and IQ4_NL variants

### Build Tools

The model was built using a custom direct GGUF→GGUF splice script (`rys_rys_splice.py`) that:
1. Reads the uncensored BF16 GGUF (64 layers)
2. Reads dnhkng's official RYS F16 GGUF (72 layers)
3. Extracts layers 26–41 from the RYS GGUF
4. Converts F16 tensors to BF16 on the fly (float16 → float32 → take top 2 bytes)
5. Splices them between uncensored layers
6. Writes a new 72-layer GGUF with all metadata preserved

Quantization performed with `llama-quantize` from [ik_llama.cpp](https://github.com/ikawrakow/ik_llama.cpp).

## Performance

### Recommended Sampling Parameters

From the [official Qwen3.5 documentation](https://huggingface.co/Qwen/Qwen3.5-27B):

| Mode | Temperature | top_p | top_k | min_p | presence_penalty | repetition_penalty |
|------|------------|-------|-------|-------|-----------------|-------------------|
| **Thinking mode — coding** (recommended) | 0.6 | 0.95 | 20 | 0.0 | 0.0 | 1.0 |
| **Thinking mode — general** | 1.0 | 0.95 | 20 | 0.0 | 1.5 | 1.0 |
| **Instruct mode — general** | 0.7 | 0.8 | 20 | 0.0 | 1.5 | 1.0 |

**We tested primarily at `temperature=0.8` with `top_p=0.95, top_k=20, presence_penalty=0.0, repetition_penalty=1.0` and found stable, high-quality output.**

### Agent & Tool Calling Performance

Over 4+ hours of live interactive testing as a coding agent (via OpenCode with MCP tool integration):

- **Tool calling**: Correct and reliable tool invocation throughout testing. The model properly formats MCP tool calls (`simplemem_search`, `web_search`, file operations) with correct parameters — no malformed calls observed
- **Agentic behavior**: Successfully completed an 80k-token self-guided coding task (Quiz Generator & Knowledge Tracker) autonomously, managing file creation, virtual environment setup, testing, and SSH transfer without intervention
- **No looping**: Zero instances of degenerate repetitive output across all testing sessions at the recommended sampling parameters
- **SSH/Network**: Successfully executes SSH commands, SCP transfers, and network operations without refusal — the primary motivation for this model's creation
- **Memory systems**: Properly implements and interacts with persistent memory, databases, and caching without sanitizing or avoiding key functionality

### Coding Performance (Live Testing)

We conducted head-to-head live coding tests against a HybridBase variant (same uncensored model, but with clean base Qwen3.5-27B layers in the duplicate zone instead of dnhkng's RYS layers).

**Test: Build a Study Flashcard Engine (Python CLI, ~800 lines)**

| Metric | Splice (this model) | HybridBase |
|--------|-------------------|------------|
| Lines of code | 788 | 867 |
| Runs without errors | ✅ Yes | ✅ Yes |
| Looped during generation | No | No |
| Fill-in-blank quality | Clean key terms | Blanked out "The" |
| CSV export | Real CSV (csv.writer) | Fake (JSON with rows) |
| Card deduplication | ✅ Yes | ❌ No |
| Score command flexibility | Searches all topics | Requires --topic flag |
| Bug count | 1 minor | 3-4 |
| Token usage | ~40-50k | ~40-50k |

**Test: Build a Quiz Generator & Knowledge Tracker (Python CLI, ~1100 lines)**

| Metric | Splice (this model) | HybridBase |
|--------|-------------------|------------|
| Lines of code | 1154 | 837 |
| Runs without errors | ✅ Yes | ❌ Crashes (NameError) |
| Looped during generation | No | **Yes, twice** (required intervention) |
| Feature scope | 8 commands, knowledge tracker | 8 commands, simpler |
| Token usage | ~80k | Unknown (couldn't complete) |

### One-Shot Project Tests (Live Coding)

Two complete projects were given as one-shot prompts to this model — no follow-up corrections, no multi-turn debugging. The model was expected to produce a fully working project from a single detailed prompt, including virtual environment setup, test scripts, and sample data.

> **Note:** The author believes the sampling parameters used during testing (temp=0.8, top_p=0.95, top_k=20) may not be fully optimal for this model. There is likely room for improved performance with further parameter tuning.

**Test 1: Study Flashcard Engine (one-shot, ~40-50k tokens generated)**

Prompt: Build a complete Python CLI tool with SM-2 spaced repetition, 7 commands, JSON API for agent integration, venv setup, and test suite.

| Aspect | Result |
|--------|--------|
| Runs without errors | ✅ Yes |
| All commands functional | ✅ 7/7 |
| SM-2 algorithm | ✅ Correctly implemented |
| Project structure | ✅ Proper folder, setup.sh, test.sh, test_notes.txt |
| Card quality | ✅ Clean term-definition pairs, proper key term extraction |
| CSV export | ✅ Real CSV output using csv.writer |
| Deduplication | ✅ Explicit seen_fronts set prevents duplicates |
| Code style | Clean functional style, 788 lines |
| Bugs found | 1 minor (case sensitivity in some edge cases) |

**Test 2: Quiz Generator & Knowledge Tracker (one-shot, ~80k tokens generated)**

Prompt: Build a more complex Python CLI tool with 8 commands, 4 question types (MCQ, T/F, fill-in-blank, short answer), knowledge tracking with concept-level granularity, study suggestions, progress visualization, and scoring with partial credit.

| Aspect | Result |
|--------|--------|
| Runs without errors | ✅ Yes |
| All commands functional | ✅ 6/8 (suggest command produces generic output with fresh data, weak-topics empty when no errors recorded — both technically correct but not useful as demos) |
| Question generation | ✅ 4 types working (MCQ, T/F, fill, short answer) |
| Scoring pipeline | ✅ take → score → knowledge tracker update works end-to-end |
| Knowledge tracking | ✅ Concept-level accuracy tracking, trend detection |
| Project structure | ⚠️ Files extracted without containing folder |
| Token usage | ~80k — the model autonomously managed file creation, venv setup, testing, and SSH transfer |
| Bugs found | 2-3 moderate: MCQ questions include markdown headers in question text, T/F generation has a for/else creating unintentional duplicates, suggest command pads with generic entries |

**Severity assessment of bugs:** All bugs found in Test 2 are **surface-level generation quality issues**, not architectural or logic errors. The scoring pipeline, knowledge tracker, and data persistence all work correctly. The MCQ header parsing and T/F duplicate issues would likely be fixed in a single follow-up prompt ("fix the question text including markdown headers" / "fix the T/F for/else logic"), requiring minimal effort. No bugs required architectural changes.

**For comparison — a rival variant (HybridBase) was given the same Quiz Generator prompt:**
The HybridBase variant **looped twice** during generation (requiring manual intervention: "you are looping, stop, evaluate then continue"), and the final output **crashed on launch** with a `NameError: name 'sentence' is not defined` — a variable scoping error where the model referenced a loop variable from a different function. After the looping and intervention, the model was unable to complete the task cleanly. This is a fundamental code generation failure that would require significant debugging, not a quick fix.

### Partial Benchmark Results

**Custom Quick Bench (50 problems: 20 coding, 15 reasoning, 15 math)**
- Partial results (11/50 completed before timeout): **82% pass rate** (9/11, all coding problems)
- No looping detected at any point

**IFBench (instruction following, 16/294 completed)**
- Average response length: 1213 chars
- 0 looping responses (repetition ratio check)
- 2 empty responses on very hard constraint prompts

### Expected Performance (Extrapolated from Source Models & dnhkng's Research)

Performance expectations are derived from two sources:
1. The [official Qwen3.5-27B benchmark scores](https://huggingface.co/Qwen/Qwen3.5-27B)
2. dnhkng's [LLM Neuroanatomy II](https://dnhkng.github.io/posts/rys-ii/) research, which systematically measured the impact of RYS layer duplication on Qwen3.5-27B using math and EQ (emotional quotient) probe sets

In dnhkng's research, the (26,34) XL configuration achieved a combined delta of **+0.1288** across math and EQ probes with only 12.5% parameter overhead — sitting on the validated Pareto frontier of performance vs. compute cost. The full probe sweep tested all possible (i,j) configurations and identified four optimal variants (S, M, L, XL), with XL (26,34) being the maximum-performance option.

Based on these findings:

| Benchmark | Qwen3.5-27B Official | Expected for this model |
|-----------|---------------------|------------------------|
| IFEval | 95.0 | ~90-93 (slight drop from layer modification) |
| MMLU-Pro | 86.1 | ~83-85 |
| GPQA Diamond | 85.5 | ~82-84 |
| LiveCodeBench v6 | 80.7 | ~78-80 |
| SWE-bench Verified | 72.4 | ~68-71 |
| HLE w/ CoT | 24.3 | ~22-24 |

*Note: These are estimates based on dnhkng's published RYS research findings and the official Qwen3.5-27B scores. The RYS method was shown to improve reasoning capabilities (math +0.0755, EQ +0.0533 for the XL config in dnhkng's probe sweep) while potentially trading small amounts of instruction-following precision. The uncensored fine-tune may also shift absolute scores. Full standardized benchmark results were not completed due to infrastructure limitations (BF16 thinking mode inference at ~60-120s per request made large benchmark suites impractical). The live coding tests above provide the most reliable quality signal for this model's intended use case.*

## Usage with llama.cpp / ik_llama.cpp

```bash
# Basic serving
llama-server \
  -m RYS-Qwen3.5-27B-Uncensored-Splice-BF16.gguf \
  --host 0.0.0.0 --port 8000 \
  -ngl 99 -c 163840 \
  --flash-attn on \
  --jinja --reasoning-format deepseek \
  --temp 0.6 --top-p 0.95 --top-k 20 \
  --presence-penalty 0.0 --repeat-penalty 1.0
```

**Important server flags:**
- `--jinja` — required for proper chat template processing
- `--reasoning-format deepseek` — enables thinking mode (`<think>...</think>`)
- `--flash-attn on` — recommended for performance
- Do **NOT** use `--cache-ram` or `--slot-prompt-similarity` — these can cause stale cached responses and model instability
- Do **NOT** use `--cache-ram-similarity` — known to cause response poisoning between sessions

### VRAM Requirements

| Quant | Minimum VRAM (model only) | With 8k context | With 32k context |
|-------|--------------------------|-----------------|-----------------|
| BF16 | ~56 GB | ~60 GB | ~72 GB |
| Q8_0 | ~30 GB | ~34 GB | ~46 GB |
| Q6_K | ~23 GB | ~27 GB | ~39 GB |
| IQ4_NL | ~17 GB | ~21 GB | ~33 GB |

*KV cache uses BF16 by default. Add `--cache-type-k bf16 --cache-type-v bf16` for optimal memory usage.*

## Architecture Details

### Qwen3.5 Hybrid SSM

Qwen3.5-27B uses a hybrid architecture combining:
- **Gated DeltaNet** (linear attention / SSM-style) — 48 of 64 original layers
- **Full Attention (GQA)** — 16 of 64 original layers, at every 4th position (layers 3,7,11,...63)

The `full_attention_interval=4` pattern is preserved in this 72-layer model:
- Full attention at layers 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71
- All other layers are Gated DeltaNet (linear attention)

### RYS Method Reference

The RYS (Repeat Your Self) method was developed by [dnhkng](https://github.com/dnhkng) and documented in:
- [LLM Neuroanatomy: How I Topped the LLM Leaderboard Without Changing a Single Weight](https://dnhkng.github.io/posts/rys/)
- [LLM Neuroanatomy II: Modern LLM Hacking and hints of a Universal Language?](https://dnhkng.github.io/posts/rys-ii/)

The method duplicates specific middle layers of a transformer to enhance reasoning capabilities without any training or weight modification. The (26,34) configuration was identified as the Pareto-optimal "XL" variant through systematic probing with math and EQ (emotional quotient) test sets.

### Layer Map

```
Output Layer → Source
0–25         → HauhauCS Uncensored layers 0–25
26–33        → dnhkng RYS layers 26–33 (base layers 26–33, first pass)
34–41        → dnhkng RYS layers 34–41 (base layers 26–33, duplicated)
42–71        → HauhauCS Uncensored layers 34–63
```

## Research Foundation

This project would not have been possible without [dnhkng's](https://github.com/dnhkng) groundbreaking RYS (Repeat Your Self) research. The key insights from their work that directly informed this model:

1. **Layer duplication enhances reasoning without training** ([LLM Neuroanatomy](https://dnhkng.github.io/posts/rys/)): dnhkng discovered that duplicating specific middle layers of a transformer creates a "deeper reasoning circuit" that measurably improves performance on math and emotional intelligence benchmarks — with zero training, zero weight modification, and zero data.

2. **Systematic configuration optimization** ([LLM Neuroanatomy II](https://dnhkng.github.io/posts/rys-ii/)): dnhkng conducted exhaustive sweeps of all possible (i,j) duplication configurations on Qwen3.5-27B, measuring each with dedicated math (Math120) and EQ (EQ140) probe sets. This identified four Pareto-optimal configurations:
   - S (33,34): +1 layer, minimal overhead
   - M (31,34): +3 layers, balanced
   - L (30,35): +5 layers, strong
   - **XL (26,34): +8 layers, maximum performance** ← used in this model

3. **The hybrid SSM constraint**: dnhkng's work on Qwen3.5's hybrid Gated DeltaNet + Full Attention architecture revealed that the `full_attention_interval=4` pattern must be preserved post-duplication — a critical constraint for GGUF-based inference that is not documented elsewhere.

4. **Pareto-optimal validation**: The (26,34) configuration was validated not just on the initial scan but on larger probe sets, confirming it as the best performance-per-compute option at +0.1288 combined delta with 12.5% overhead.

The author's contribution was to combine these RYS findings with the HauhauCS uncensored fine-tune using the novel splice method — taking dnhkng's already-validated duplicate zone layers directly and embedding them within the uncensored model's layer stack, rather than re-duplicating from scratch.

## Vision (mmproj) Compatibility

Qwen3.5-27B is natively a vision-language model. While this GGUF release is text-only, it should be compatible with the mmproj (multimodal projector) from the uncensored base model. In our testing, the mmproj from [HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive](https://huggingface.co/HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive) worked correctly with our model.

We have chosen not to host the mmproj file in this repository as we did not create or modify it — credit for that work belongs entirely to HauhauCS. If you wish to use vision capabilities, download the mmproj directly from their repository.

## Limitations

1. **Uncensored**: This model will follow most instructions without refusal. It is the user's responsibility to ensure ethical use.
2. **RYS overhead**: 72 layers vs 64 original = ~12.5% more compute per token.
3. **Thinking mode token usage**: The model generates extensive `<think>` blocks before responding, which increases token usage significantly (often 2-10x the final response length).
4. **Hybrid architecture**: Requires recent llama.cpp builds (b8000+) that support Qwen3.5's Gated DeltaNet + Full Attention hybrid architecture.
5. **Not fully benchmarked**: Full benchmark suite was not completed. Performance estimates are extrapolated from source model scores.

## Credits

- **[Qwen Team](https://huggingface.co/Qwen)** — Qwen3.5-27B base architecture and weights
- **[HauhauCS](https://huggingface.co/HauhauCS)** — Uncensored fine-tune (Qwen3.5-27B-Uncensored-HauhauCS-Aggressive)
- **[dnhkng](https://github.com/dnhkng)** — RYS method, research, and validated XL configuration
- **[ikawrakow](https://github.com/ikawrakow)** — ik_llama.cpp (quantization tooling)

## Citation

If you use this model, please cite the original works:

```bibtex
@misc{qwen3.5,
  title = {{Qwen3.5}: Towards Native Multimodal Agents},
  author = {{Qwen Team}},
  year = {2026},
  url = {https://qwen.ai/blog?id=qwen3.5}
}

@misc{dnhkng_rys,
  title = {LLM Neuroanatomy II: Modern LLM Hacking and hints of a Universal Language?},
  author = {dnhkng},
  year = {2025},
  url = {https://dnhkng.github.io/posts/rys-ii/}
}
```