---
title: "Qwen 3.6 35B-A3B REAP-48 v2 GGUF"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/303f4298-cc6d-452d-a68a-d4be1ae2a110"
updated: "2026-11-13"
---

# Qwen 3.6 35B-A3B REAP-48 v2 GGUF

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Runs a pruned and quantized Qwen3.6-35B-A3B in an 8.78 GiB GGUF file for llama.cpp, closer to the unquantized weights than the first release. For people with limited memory.

Qwen 3.6 35B-A3B REAP-48 v2 GGUF is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by crucible-labs

## About

### What it is

This is a GGUF build of Qwen3.6-35B-A3B from Crucible. It prunes 48% of the routed experts with REAP and then quantizes the rest with bit sizes chosen by measuring each tensor, not by hand. This is the second release. Its file is the same size as the first, 8.78 GiB, but it sits measurably closer to the f16 weights.

### Who it suits

It suits people who run a large model locally with llama.cpp on limited memory and want a small file that stays close to the original.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software development | Developers with a local coding assistant | Run a code model on a 16 GB machine | The card measured 29.24 tokens per second of decoding on an M4 Mac Mini |
| Local AI hobby | Mac and AMD GPU owners | Pick a small file with less quality loss | The v2 file is closer to f16 than v1 at the same size |
| Research | Quantization researchers | Study measured bit allocation against a hand-written one | The card compares v1 and v2 by KL-divergence |

You can skip it if you use CUDA, Vulkan or a CPU-only build and value speed over fidelity, because the card has not timed the new quant types there.

### Where to use it

- llama.cpp, with the GGUF file
- Windows, macOS or Linux
- Apple Silicon with Metal, where the card timed it on a 16 GB M4 Mac Mini
- AMD GPUs with ROCm, where the card measured accuracy

| Use case | Who | What they get back |
| --- | --- | --- |
| Local coding help | Developers | A code-capable model that fits in a small file |
| Tool-calling tests | Agent builders | A model the card scored on a function-calling benchmark |
| Quality-per-size comparison | Researchers | Measured KL-divergence figures for two releases |

### How to set it up

You need llama.cpp and about 9 GiB of free space for the file.

- A llama.cpp build for your platform
- Python with the Hugging Face tools, to download the file
- A machine with enough memory for an 8.78 GiB model, such as the 16 GB Mac the card used

1. Install the Hugging Face tools with Python.
2. Download the repository files with the second command below.
3. Point llama.cpp at the GGUF file.
4. If speed matters on CUDA, Vulkan or CPU, benchmark before you switch from v1.

```sh
pip install -U huggingface_hub
hf download crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF
```

### How to use it

The card gives no run command. Load the GGUF in llama.cpp and prompt it as you would any chat model. The card used llama-bench to measure prefill and decode speed.

| Tool | What it does |
| --- | --- |
| llama.cpp | Loads the GGUF file and runs the model |
| llama-bench | Measures prefill and decode speed, as in the card's tests |
| hf download | Fetches the repository files |

### Example

You load the GGUF on a 16 GB Mac Mini and start prompting. On that machine the card measured decoding at 29.24 tokens per second for v2, against 26.71 for the first release.

### For newcomers and experts

Think of it as a big model that has been trimmed and compressed to fit a small computer, with the loss measured. A first small try is to load the file and chat with it as usual.

Two steps matter most. Calibration now runs through the model's own chat template, where v1 used flattened text. Bits are then reallocated by measurement, because the shared expert turned out to be much more sensitive than the routed experts for each parameter. v2 also adds i-quants, IQ3\_S and IQ4\_XS among them, while v1 stuck to k-quants. Token generation is limited by memory bandwidth. Each token reads the dense path in full but touches only 8 of 133 experts, so trimming bits on that dense path saves the most time per token.

Prune 48% of the routed experts with REAP → Calibrate with the model's chat template → Measure how sensitive each tensor is → Assign bit sizes per tensor and layer → Write one 8.78 GiB GGUF file

### Good to know

The card compares v2 with v1 against the f16 weights, at the same file size.

Closeness to f16, v1 against v2

| Metric | v1 | v2 | Change |
| --- | --- | --- | --- |
| Mean KL-divergence | 0.034093 | 0.019609 | 42.5% lower |
| Median KL-divergence | 0.002489 | 0.001186 | 52.4% lower |
| 99th-percentile KL-divergence | 0.536331 | 0.327945 | 38.9% lower |
| Excess perplexity over f16 | 0.037205 | 0.022679 | 39.0% lower |
| Top-1 agreement with f16 | 94.678% | 96.199% | 1.52 points higher |

Speed on an M4 Mac Mini, 16 GB, Metal

| Test | v1 | v2 |
| --- | --- | --- |
| Prefill, tokens per second | 411.29 | 417.18 |
| Decode, tokens per second | 26.71 | 29.24 |

Accuracy of v2 in the card's own test setup

| Label | Value |
| --- | --- |
| HumanEval+ | 90.9% |
| MBPP+ | 75.7% |
| BFCL-simple | 93.2% |

- Untested backends: the card did not time the i-quants on CUDA, Vulkan or CPU-only builds, so benchmark first if speed matters
- Accuracy runs: temperature 0, one attempt per problem, measured on ROCm, and deliberately not compared with v1
- Size: 19.2B parameters, about 9.6 GB at 4-bit, which is an estimate
- Language: English
- License: Apache 2.0
- Cost to run: none named
- Data it reaches: the files you download and the prompts you run locally
- Not for: non-English work, since the card lists English only

## README

````markdown
# Qwen 3.6 35B-A3B REAP-48 v2 GGUF

Runs a pruned and quantized Qwen3.6-35B-A3B in an 8.78 GiB GGUF file for llama.cpp, closer to the unquantized weights than the first release. For people with limited memory.

Made by crucible-labs on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: This is a GGUF build of Qwen3.6-35B-A3B from Crucible. It prunes 48% of the routed experts with REAP and then quantizes the rest with bit sizes chosen by measuring each tensor, not by hand. This is the second release. Its file is the same size as the first, 8.78 GiB, but it sits measurably closer to the f16 weights.

Who it suits: It suits people who run a large model locally with llama.cpp on limited memory and want a small file that stays close to the original.

```table
Industry | Who uses it | How they use it | Example
Software development | Developers with a local coding assistant | Run a code model on a 16 GB machine | The card measured 29.24 tokens per second of decoding on an M4 Mac Mini
Local AI hobby | Mac and AMD GPU owners | Pick a small file with less quality loss | The v2 file is closer to f16 than v1 at the same size
Research | Quantization researchers | Study measured bit allocation against a hand-written one | The card compares v1 and v2 by KL-divergence
```

You can skip it if you use CUDA, Vulkan or a CPU-only build and value speed over fidelity, because the card has not timed the new quant types there.

Where to use it:

- llama.cpp, with the GGUF file
- Windows, macOS or Linux
- Apple Silicon with Metal, where the card timed it on a 16 GB M4 Mac Mini
- AMD GPUs with ROCm, where the card measured accuracy

```table
Use case | Who | What they get back
Local coding help | Developers | A code-capable model that fits in a small file
Tool-calling tests | Agent builders | A model the card scored on a function-calling benchmark
Quality-per-size comparison | Researchers | Measured KL-divergence figures for two releases
```

How to set it up: You need llama.cpp and about 9 GiB of free space for the file.

- A llama.cpp build for your platform
- Python with the Hugging Face tools, to download the file
- A machine with enough memory for an 8.78 GiB model, such as the 16 GB Mac the card used

1. Install the Hugging Face tools with Python.
2. Download the repository files with the second command below.
3. Point llama.cpp at the GGUF file.
4. If speed matters on CUDA, Vulkan or CPU, benchmark before you switch from v1.

```sh
pip install -U huggingface_hub
hf download crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF
```

How to use it: The card gives no run command. Load the GGUF in llama.cpp and prompt it as you would any chat model. The card used llama-bench to measure prefill and decode speed.

```table
Tool | What it does
llama.cpp | Loads the GGUF file and runs the model
llama-bench | Measures prefill and decode speed, as in the card's tests
hf download | Fetches the repository files
```

Example: You load the GGUF on a 16 GB Mac Mini and start prompting. On that machine the card measured decoding at 29.24 tokens per second for v2, against 26.71 for the first release.

For newcomers and experts: Think of it as a big model that has been trimmed and compressed to fit a small computer, with the loss measured. A first small try is to load the file and chat with it as usual.

Two steps matter most. Calibration now runs through the model's own chat template, where v1 used flattened text. Bits are then reallocated by measurement, because the shared expert turned out to be much more sensitive than the routed experts for each parameter. v2 also adds i-quants, IQ3_S and IQ4_XS among them, while v1 stuck to k-quants. Token generation is limited by memory bandwidth. Each token reads the dense path in full but touches only 8 of 133 experts, so trimming bits on that dense path saves the most time per token.

```flow
Prune 48% of the routed experts with REAP
Calibrate with the model's chat template
Measure how sensitive each tensor is
Assign bit sizes per tensor and layer
Write one 8.78 GiB GGUF file
```

Good to know: The card compares v2 with v1 against the f16 weights, at the same file size.

```table
Title: Closeness to f16, v1 against v2
Metric | v1 | v2 | Change
Mean KL-divergence | 0.034093 | 0.019609 | 42.5% lower
Median KL-divergence | 0.002489 | 0.001186 | 52.4% lower
99th-percentile KL-divergence | 0.536331 | 0.327945 | 38.9% lower
Excess perplexity over f16 | 0.037205 | 0.022679 | 39.0% lower
Top-1 agreement with f16 | 94.678% | 96.199% | 1.52 points higher
```

```table
Title: Speed on an M4 Mac Mini, 16 GB, Metal
Test | v1 | v2
Prefill, tokens per second | 411.29 | 417.18
Decode, tokens per second | 26.71 | 29.24
```

```chart
Title: Accuracy of v2 in the card's own test setup
HumanEval+: 90.9%
MBPP+: 75.7%
BFCL-simple: 93.2%
```

- Untested backends: the card did not time the i-quants on CUDA, Vulkan or CPU-only builds, so benchmark first if speed matters
- Accuracy runs: temperature 0, one attempt per problem, measured on ROCm, and deliberately not compared with v1
- Size: 19.2B parameters, about 9.6 GB at 4-bit, which is an estimate
- Language: English
- License: Apache 2.0
- Cost to run: none named
- Data it reaches: the files you download and the prompts you run locally
- Not for: non-English work, since the card lists English only

## On Hugging Face, 13 November 2026

- Task: text generation
- Library: llama.cpp
- Parameters: 19.2B
- Weights: about 9.6 GB at 4-bit (estimate)
- Formats: GGUF
- Downloads in the last 30 days: 2,427
- Likes: 34
- License: apache-2.0
- Languages: en
- Based on: Qwen/Qwen3.6-35B-A3B
- Tags: llama.cpp, gguf, pruning, reap, quantized, coding, tool-calling, text-generation, model-index, imatrix, conversational

## Links

- Model: https://huggingface.co/crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF
- Files: https://huggingface.co/crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF on Hugging Face](https://huggingface.co/crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen 3.6 35B-A3B REAP-48 v2 GGUF (this page) | 2,427 | 34 | 19.2B | apache-2.0 | 2026-08-25 |
| [Qwen3.6-35B-A3B-coding-reap50-GGUF](https://mindket.com/p/621f09f3-06cf-48a3-836b-eea19489d58b) | 3,898 | 16 | 18.5B | apache-2.0 | 2026-10-18 |
| [Sharp-Spark-X2.5-4B-GGUF](https://mindket.com/p/d4d90f81-4886-4de3-ab95-d64c344a708c) | 875,346 | 164 | 4.1B | apache-2.0 | 2026-11-04 |
| [Sharp-Spark-X2.6-4B-GGUF](https://mindket.com/p/53fa23e7-b10e-483c-98d5-0a11d507575f) | 5,044 | 23 | 4.1B | apache-2.0 | 2026-11-04 |
| [dale-0.8b-GGUF](https://mindket.com/p/6fbea688-a5e2-4613-9a8f-f004c4cb29ab) | 2,163 | 44 | 752M | apache-2.0 | 2026-11-08 |
| [askmdb-9b-GGUF](https://mindket.com/p/867806d8-1d95-4280-b990-c2b1211598b6) | 351 | 5 | 9B | apache-2.0 | 2026-11-08 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-08-25
- First published: 2026-08-25
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF on Hugging Face](https://huggingface.co/crucible-labs/Qwen3.6-35B-A3B-REAP-48-v2-GGUF)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/303f4298-cc6d-452d-a68a-d4be1ae2a110)
- [Its page on Mindket](https://mindket.com/p/303f4298-cc6d-452d-a68a-d4be1ae2a110)
