license: other
license_name: minimax-community-license
license_link: LICENSE
language:

• en
• zh
  pipeline_tag: text-generation
  library_name: gguf
  base_model: MiniMaxAI/MiniMax-M3.1-Flash
  base_model_relation: quantized
  tags:
• gguf
• llama.cpp
• local
• minimax
• minimax-m3
• minimax-m3.1-flash
• moe
• mixed-precision
• imatrix
• abliterated
• uncensored
• ai-red-team
• reasoning

MiniMax-M3.1-Flash-abliterated GGUF

The 426B uncensored MiniMax-M3.1-Flash, in 128 GB of RAM.

112 GB in memory · fits a 128 GB machine · llama.cpp

OrcaRouter AI Gateway · X · Discord · GitHub · All Models

The full MiniMax-M3.1-Flash, run locally.

These are GGUF builds of the abliterated (refusal-removed)
MiniMax-M3.1-Flash.
It is a 426B-parameter MoE with 128 routed experts (top-4) and one shared expert. It uses MiniMax
Sparse Attention on all 60 layers and has a 1M-token context.

Routed experts are 97% of the weights, so that is where the bits were spent. Each group of
expert layers got its own precision from measured KL divergence, not from a hand-set rule.

The smallest public GGUF of this model so far is 129 GB, which needs a machine with more than
128 GB. Mix-128G is 112 GB and fits one.

⚠️ Disclaimer — read before use

This model is built on an abliterated base whose safety alignment has been substantially reduced.
The refusal direction was orthogonalized out of every matrix that writes the residual stream. As a
result, it will comply with many harmful, unethical, offensive, or illegal requests that the
original MiniMax-M3.1-Flash would refuse.

• It is released strictly for legitimate research: interpretability, AI-safety and
  refusal-mechanism study, red-teaming, and robustness evaluation.
• You assume full responsibility for how you use it and for everything it generates. Add your
  own safety, moderation, and abuse-prevention layers before any deployment.
• Use must comply with the MiniMax Community License inherited from the base model,
  including its prohibited-use appendix, and with all applicable law.
• The authors accept no liability for misuse. Its outputs do not reflect the views of the
  uploaders or of MiniMax.

Pick a build

Mix-128G fits a 128 GB machine. That covers a 128 GB Mac, a 128 GB PC running on CPU, or GPUs
with ~120 GB of VRAM in total. This model was quantization-aware trained at NVFP4 (4 bits), and
going below 2 bits costs it a lot. On held-out text, two tokens in three still match the original's
choice, and perplexity is a third higher.

Use Mix-128G to run the model on a 128 GB box. Do not expect it to match the full-precision model.

Evaluation

All builds are scored against the lossless GGUF of the same checkpoint. In that GGUF the
experts stay native NVFP4, and MXFP8 is decoded bit-exact to BF16; it was verified element by
element against the safetensors.

Scoring uses full-vocabulary KLD on held-out chat text: 32 windows of 4096 tokens across English
prose, English chat, Chinese chat and Python code, all rendered through the model's chat template.
M3.1 is a chat model and does not continue raw text well. The precision search never saw this text.

Every build is compared with two others at or near its size, quantized from the same weights with
the same importance matrix:

• llama.cpp's own mixture
• unsloth's UD-IQ1_M recipe, the smallest build of unsloth's GGUFs of this model. We read its per-tensor types from their file and rebuilt it here.

At the same size, Mix-128G has less than half the KL divergence of llama.cpp's IQ2_XXS.
unsloth's smallest recipe scores better, but it is 17.5 GB larger and needs more than 128 GB.

Method note. These are full-vocabulary KLD and next-token agreement on held-out text at 4k
context, not a downstream benchmark. Even Q5_K (5.5 bpw) scores KLD ≈0.04 on this model, so the
absolute numbers here are higher than on models without QAT.

Refusal and capability of the abliterated model

Measured on the unquantized abliterated checkpoint,
not re-measured on these GGUF builds. The KLD above is how far each build sits from that checkpoint.

Setup.

• Runtime: vLLM, TP4, fp8 KV cache.
• Decoding: greedy, thinking disabled.
• Scoring: refusal is judged by a rule-based opening-phrase classifier. Treat the numbers as
  indicative, not publication-grade.

Safety: harmful-prompt refusal (lower = more uncensored). Average 54.9%, against 94.4%
for the base model.

Over-refusal: benign prompts wrongly refused (lower = better).

Capability retention.

How the precision was chosen

The budget is set on the bytes that have to fit in memory.

1. Measure. For every group of tensors, the search measures the real KLD of moving it one
   precision level up and one level down. Groups are as follows:

   • routed experts: one projection (gate, up or down) over two layers
   • attention and shared experts: ten layers at a time
   • leading dense FFN: one group for layers 0–2
   • embedding and output head: one group each

   Each measurement runs llama.cpp's own kernels.

2. Choose. A knapsack picks the combination of moves that fits the budget exactly.

3. Accept. Only steps whose candidate KLD was actually measured lower are kept.

The checkpoint ships each expert's NVFP4 global scale as a separate tensor. During quantization,
that scale is folded into the expert's weights, so every GGUF here holds experts at their true
magnitude.

Mix-128G puts its bits as follows:

The importance matrix comes from 800k tokens of chat-formatted text:

• English prose (wikitext-2)
• English chat (ultrachat_200k)
• Chinese chat (sharegpt_zh)
• Python code (codeparrot)

This is the first release of Mix-128G, taken after one round of the search. Later rounds are
running and will replace it here if they score better.

What's in this repo

The chat template is embedded in each build. The vision projector (mmproj) and the DSpark
speculative drafter are not included yet.

Serving (llama.cpp)

MiniMax-M3.1 is not in llama.cpp master yet. Build the PR that adds it,
ggml-org/llama.cpp#31192. These files were made
and tested at commit 6b95a99:

git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
git fetch origin pull/31192/head:pr-31192 && git checkout 6b95a99
cmake -B build -DGGML_CUDA=ON && cmake --build build -j --target llama-server llama-cli
# Mac: cmake -B build (Metal is on by default) · CPU only: cmake -B build

hf download orcarouter/MiniMax-M3.1-Flash-abliterated-GGUF --include "Mix-128G/*" --local-dir ./m31-gguf

# One GPU with ~120 GB+ of VRAM (tested on 1 x H200)
llama-server -m m31-gguf/Mix-128G/MiniMax-M3.1-Flash-abliterated-Mix-128G-00001-of-00003.gguf \
  -ngl 99 -c 32768 --jinja

# CPU only or Apple Silicon, 128 GB RAM
llama-server -m m31-gguf/Mix-128G/MiniMax-M3.1-Flash-abliterated-Mix-128G-00001-of-00003.gguf \
  -ngl 0 -c 16384 --jinja      # on a Mac, use -ngl 99 to run on Metal

• Memory. The KV cache costs about 135 KB per token: 16k of context adds ~2.2 GB on top of
  the weights, and 32k adds ~4.4 GB.
• 128 GB Mac. macOS lets the GPU wire only about 75% of RAM by default. Raise the limit
  before loading on Metal, for example sudo sysctl iogpu.wired_limit_mb=122000, and close other
  apps.
• Thinking is on by default. The reasoning comes back in message.reasoning_content, and the
  answer in message.content.
• Point llama.cpp at the 00001 part. It finds the other two.

Measured with short prompts, one request at a time:

CPU and Apple Metal speeds have not been measured yet.

Model details

Bias, risks, and limitations

• Safety guardrails are substantially reduced, inherited from the abliterated base; see the
  disclaimer. The refusal and capability numbers above come from the unquantized checkpoint.
  Mix-128G sits far enough from it (KLD 1.06) that its behaviour may differ.
• Mix-128G is heavily degraded. This is the cost of 2-bit post-training quantization on a model
  trained for 4-bit, not a tuning issue.
• Tested on CUDA only. CPU and Apple Metal have not been run with these files yet.
• No vision projector or DSpark drafter yet. Long-context behaviour was not tested: all
  measurements are at 4k context or on short chats.
• Inherits the biases and limitations of MiniMax-M3.1-Flash.
• Requires a llama.cpp build with PR #31192. Stock llama.cpp, Ollama and LM Studio will not load
  these files until it is merged.

License

The MiniMax Community License, inherited from the base model
MiniMaxAI/MiniMax-M3.1-Flash. It covers
non-commercial use. Commercial use requires "Built with MiniMax M3.1-Flash" attribution and a notice
to, or authorization from, MiniMax. See the license for the terms and its prohibited uses.

One Gateway. Every Model.

Route Smarter · Ship Safer · Spend Less

Website · Models · GitHub · Discord · X