Overview

Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V9-GGUF is a 35-billion parameter mixture-of-experts language model created by LuffyTheFox that applies a proprietary post-training tensor repair technique called Genesis to reduce accumulated training noise and improve output consistency. The model runs 3 billion parameters active per forward pass through 256 experts (8 routed + 1 shared per token) and uses a hybrid architecture combining Gated DeltaNet linear attention with full softmax attention in a 3:1 ratio across 40 layers. It supports 262,000 native context tokens (extendable to 1 million with YaRN), handles 248,000 vocabulary tokens across 201 languages, and includes native multimodal capabilities for text, image, and video. The critical distinction is that Genesis does not retrain or finetune—instead, it performs "numerical surgery" on GGUF-format model weights to eliminate saturated weights, scale mismatches, mean drift, zero blocks, and training noise without removing learned knowledge or gradients. Built on the HauhauCS uncensored base (0 refusals on 465 test cases) and combining Hermes agent instruction-following capabilities, this model runs on GGUF-compatible runtimes including llama.cpp, LM Studio, and koboldcpp and is ready to use at the recommended V8 APEX quantization.

Best use cases

Long-context reasoning and extended analysis. This model maintains 128K minimum context for thinking capabilities and extends to 262K natively, making it suited for analyzing lengthy documents, research papers, codebases, and multi-turn conversations requiring memory of earlier context. The noise reduction from Genesis improves clarity and reduces hallucinations during extended generations where accumulated errors typically compound. Practical examples include summarizing 50-page technical specifications, maintaining conversational coherence across 20+ turns, and analyzing long source files for code review or refactoring suggestions.

Instruction-following and agentic tasks. The Hermes dataset transfer enables the model to handle function calling, structured JSON output, and multi-step tool use. The model works with system prompts that specify JSON schemas and responds reliably with properly formatted agentic responses. Use this for building autonomous agents that must call APIs, return structured data, or follow specific output formats—the model's instruction-following is more consistent due to Genesis noise reduction making training signal clearer.

Uncensored creative and roleplay content. Built on the HauhauCS uncensored base with zero refusals, this model generates content without safety guardrails typically found in commercial models. If you need creative writing without content restrictions, roleplay scenarios, or experimental text generation free from refusal patterns, this model delivers without the pause and reluctance found in censored alternatives. The Genesis repair improves creative consistency by reducing the internal noise that causes repetition or incoherence in longer generations.

Coding tasks with extended thinking. Recommended settings for coding include temperature 0.6, top_p 0.95, top_k 20, min_p 0, and disabled penalties. The hybrid attention architecture and MoE design provide good balance between speed and reasoning depth. Use this for code generation, debugging, code review, and technical explanation where you need both creativity (multimodal thinking) and precision (low temperature, controlled sampling).

Multimodal understanding without external encoders. Native support for text, image, and video input means you can provide images and video alongside text queries without separate vision modules—the model handles this internally. Examples include analyzing screenshots with code, understanding diagrams in technical documentation, or processing video frames for visual reasoning tasks.

Limitations

Uncensored model carries responsibility. This model has zero refusal patterns by design. It will generate content others refuse—offensive material, explicit content, harmful instructions. Using it requires judgment and responsibility. This is not a limitation of capability but a design choice that makes it unsuitable for user-facing applications where safety policies are required.

Context length requires careful management. While supporting 262K tokens natively, the documentation explicitly states you must keep "at least 128K context to preserve thinking capabilities." Shorter contexts may degrade the model's reasoning. For applications with small prompts and short responses, you may waste VRAM and hit unnecessary overhead.

Quantization and hardware demands. The V8 APEX quantization is recommended but requires specific cache settings: K and V cache quantization at Q8_0, 40 layers forced to CPU, GPU offload of 15 layers, and 8 active experts. Tuning these settings incorrectly breaks performance. The MoE architecture with 256 experts means full precision versions consume substantial VRAM. Exact VRAM requirements are not stated, but 35B parameter MoE models typically require 70+ GB for full precision or 20-30 GB quantized.

Hermes training transfer is limited scope. Only "around 2k blocks from two FFN expert tensors" transferred Hermes dataset knowledge. This means instruction-following and agentic capabilities are present but narrower in scope than models fully fine-tuned on Hermes. The agentic features work but do not match models specifically trained as Hermes implementations.

Vision requires explicit mmproj file. The model is natively multimodal, but the documentation states "vision support requires the mmproj file alongside the main GGUF." Without it, vision features fail silently. You must download and place the correct mmproj file or lose multimodal capability.

Benchmark data is sparse. The README links to HermesBench results but does not provide actual numbers or comparisons. No throughput metrics (tokens/second), latency numbers, or quality benchmarks appear in the documentation. You cannot evaluate actual performance before deployment.

Chat template is critical. The model requires the provided chat_template.jinja file and the --jinja flag with llama.cpp for proper operation. Using it without the correct template breaks chat formatting. This is not documented prominently and easy to miss.

Limited active maintenance signals. While a Discord exists for updates, this is a third-party modification released by an individual, not an organization with production support infrastructure. Long-term maintenance, security updates, and bug fixes depend on one person's capacity.

How it compares

Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V7-GGUF is the previous Genesis version. V9 includes improved tensor repair and better handling of noise in attention and FFN layers. Choose V9 for newer refinements; V7 if you need proven stability on specific hardware configurations you've already validated.

Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V6-GGUF offers an intermediate checkpoint between V5 and V7. The progression shows incremental Genesis improvements; V9 represents the furthest development of the noise-reduction technique. V6 is a checkpoint you would use only if V9 compatibility issues arise.

Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V5-GGUF is an earlier iteration with less refined tensor repair. If you require backward compatibility or have verified performance on V5 in your infrastructure, staying on V5 is reasonable; however, V9 should provide cleaner outputs and fewer hallucinations due to more aggressive noise reduction.

Qwen3.6-35B-A3B-Uncensored-Claude-Genesis-GGUF transfers Chain of Thought from Claude Opus and applies different tensor repair priorities. Choose Claude-Genesis if you need reasoning-focused behavior and chain-of-thought output; choose Hermes-V9 if you need agentic function-calling and instruction-following, or if you prefer a model trained on Hermes datasets rather than Claude distillation.

Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V3-GGUF includes data reconstruction in different tensors (ssm_out, attn_output, attn_gate, attn_q, etc.) than later versions. V3 represents an earlier approach; V9 has refined the technique. Use V9 unless you have specific compatibility requirements with V3.

Technical specifications

Architecture and parameters:

  • 35 billion total parameters with ~3 billion active per forward pass via mixture of experts

  • 256 experts total: 8 routed experts + 1 shared expert per token (9 experts active per token)

  • 40 layers in a repeating pattern: 3 DeltaNet-MoE layers followed by 1 Attention-MoE layer (10 repetitions)

  • Hybrid attention: Gated DeltaNet linear attention and full softmax attention in 3:1 ratio

  • 248,000 vocabulary size

  • 201 languages supported

  • Multimodal: native support for text, image, and video inputs

Context and extensions:

  • 262,000 tokens native context window

  • Extendable to 1,000,000 tokens using YaRN (Yet Another RoPE extension)

  • Minimum 128K context recommended to preserve thinking and reasoning capabilities

Genesis tensor repair method:

  • Post-training numerical optimization (not retraining or fine-tuning)

  • Three-stage process: (1) scan and repair balance in ssm_conv1d tensors for long context memory, (2) custom SVD-based noise detection and reduction while preserving 99% signal and learned gradients, (3) chunk scanning and replacement of broken zero blocks

  • Excludes from repair: token_embd.weight, output.weight, ffn_gate_inp_shexp.weight, 1D tensors, biases, and normalization layers

  • Addresses saturated weights, scale mismatches (up to 10× differences), mean drift in weight distributions, zero block corruption, and accumulated training noise

Training data sources:

  • Base: HauhauCS/Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive (0 refusals on 465 test cases)

  • Hermes dataset transfer: ~2,000 blocks from two FFN expert tensors for instruction-following and agentic capabilities

Model format and compatibility:

  • GGUF format (Generalized GPT-Unified Format)

  • Compatible runtimes: llama.cpp, LM Studio, koboldcpp, and other GGUF-compatible inference engines

  • Recommended quantization: V8 APEX quant

  • Requires chat_template.jinja file and --jinja flag with llama.cpp for proper chat formatting

  • Vision capability requires mmproj (multimodal projection) file alongside GGUF

Quantization and optimization settings:

  • K Cache Quantization Type: Q8_0

  • V Cache Quantization Type: Q8_0

  • GPU offload: 15 layers

  • Number of active experts: 8

  • Layers forced to CPU: 40 (all MoE weights)

Recommended inference hyperparameters by task:

Thinking mode (coding/reasoning):

  • Hermes agent: temperature 0.6, top_p 0.95, top_k 20, min_p 0.05, repeat_penalty 1.08

  • Coding/precise tasks: temperature 0.6, top_p 0.95, top_k 20, min_p 0, repeat_penalty disabled

  • General: temperature 1.0, top_p 0.95, top_k 20, min_p 0.05, repeat_penalty disabled

Non-thinking mode (creative):

  • General: temperature 0.7, top_p 0.85, top_k 20, min_p 0.015, repeat_penalty disabled

All modes: presence_penalty disabled, seed 42 for reproducibility

Model inputs and outputs

Inputs

  • Text prompts: Natural language instructions and queries

  • Images: Alongside text queries for visual reasoning (requires mmproj file)

  • Video frames: Natively supported for multimodal understanding

  • System prompts: Custom instructions defining model behavior and output format

  • Chat history: Full conversation context preserved up to 262K tokens

  • JSON schemas: For structured output in agentic tasks (specify in system prompt)

Outputs

  • Text: Generated responses in natural language, default or custom format

  • JSON: Structured output when specified via system prompt and schema (for function calling and agentic tasks)

  • SVG: Can generate vector graphics (examples provided in documentation)

  • Code: Python, JavaScript, and other programming languages

  • Long-form content: Extended generations up to context limit with reduced hallucination due to Genesis noise reduction

Getting started

To use this model with llama.cpp:

```

Download the model and chat template

wget "https://huggingface.co/LuffyTheFox/Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V9-GGUF/resolve/main/model.gguf"
wget "https://huggingface.co/LuffyTheFox/Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V9-GGUF/resolve/main/chat_template.jinja"

Run with proper settings

./llama-cli -m model.gguf \
--jinja \
-c 128000 \
--gpu-layers 15 \
--temp 0.6 \
--top-p 0.95 \
--top-k 20 \
-p "You are Qwen, a large language model created by Tongyi Lab team from Alibaba Group. You are a helpful assistant."
```
For LM Studio:

  1. Load the GGUF model in LM Studio

  2. Set K Cache and V Cache quantization to Q8_0

  3. Set GPU offload to 15 layers

  4. Set number of active experts to 8

  5. Force all 40 MoE layers to CPU

  6. Use the provided chat template

  7. Apply recommended temperature and sampling settings based on your task

For Python with a compatible library (e.g., ctransformers or similar GGUF-compatible bindings):

from ctransformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained( "LuffyTheFox/Qwen3.6-35B-A3B-Uncensored-Genesis-Hermes-V9-GGUF", model_file="model.gguf", gpu_layers=15 ) prompt = "You are Qwen, a large language model created by Tongyi Lab team from Alibaba Group. You are a helpful assistant.\n\nUser: What is your name?\nAssistant:" response = model( prompt, temperature=0.6, top_p=0.95, top_k=20, max_new_tokens=512 ) print(response)

Frequently asked questions

Q: Can I use this model commercially?

A: The model is licensed under Apache 2.0, which permits commercial use, modification, and distribution. However, verify compliance with the base model license (HauhauCS) and ensure you follow Apache 2.0 terms requiring license attribution and liability disclaimers.

Q: What hardware do I need to run this model?

A: At V8 APEX quantization, you need approximately 20-30 GB VRAM for GPU inference, or you can offload most weights to CPU (slower). A GPU with at least 12-16 GB VRAM is practical for reasonable speeds. Full precision (non-quantized) requires 70+ GB VRAM. CPU-only inference is possible but very slow.

Q: How does this model compare to Claude for coding tasks?

A: This model includes Hermes agent capabilities and explicit coding-focused temperature settings (0.6 with specific sampling), but it is not trained directly on Claude data like some alternatives. For complex reasoning and multi-step coding tasks, Claude (commercial) likely outperforms it; for uncensored coding examples and function-calling with structured output, this model is competitive and open-source.

Q: What is Genesis and why does it matter?

A: Genesis is a post-training tensor repair technique that reduces accumulated training noise, saturated weights, and scale mismatches without retraining. It improves output consistency, reduces hallucinations in long context, and clarifies instruction-following. It does not increase model knowledge—it makes the existing knowledge clearer and more stable.

Q: Can I fine-tune this model further?

A: The documentation does not explicitly address fine-tuning. Since it is a GGUF-quantized model, you would need to convert it back to full precision format (not straightforward) before fine-tuning. Use the original HauhauCS model for fine-tuning if you need that capability.

Q: Do I need the mmproj file for vision?

A: Yes, vision support requires the mmproj (multimodal projection) file downloaded alongside the main GGUF model. Without it, image and video inputs either fail silently or are ignored. Verify the file is in the same directory as your GGUF model.

Q: How fast is inference with this model?

A: The documentation does not provide throughput metrics (tokens/second). Speed depends on quantization, GPU VRAM availability, batch size, and context length. Inference will be noticeably slower than smaller 7B models but faster than full 35B models due to MoE (only ~3B parameters active). Test on your hardware before production deployment.

Q: Is this model actively maintained?

A: Maintenance depends on LuffyTheFox. A Discord community exists for updates, and the model has progressed through nine versions. However, this is an individual project without organizational backing. For production use, consider the maintenance risk and have fallback models identified.