license: mit base_model: dealignai/MiMo-V2.6-Flash-RL-UNCENSORED base_model_relation: quantized pipeline_tag: image-text-to-text language:

• en
• zh
• ko tags:
• mimo_v2
• mimo
• uncensored
• abliterated
• gguf
• vector-quantization
• vq
• residual-vq
• imatrix
• importance-matrix
• calibration
• mixture-of-experts
• hybrid-attention
• sliding-window-attention
• multimodal
• vision
• video
• audio
• 1m-context
• speculative-decoding
• dflash
• mtp
• dgx-spark
• gb10
• ds4
• ds4-dfm-rs

MiMo-V2.6-Flash-RL UNCENSORED VQ GGUF

[!WARNING] Serving needs the ds4-dfm-rs mimo2_vq family, which is being implemented on DGX Spark next (this release was converted and measured on Runpod; no GB10 load or speed numbers yet). Problems or odd output? Post them in the Community tab.

dealignai's UNCENSORED edition of Xiaomi's 309B native omnimodal MoE (15B active) with its full 1,048,576-token context, its vision/video tower, its audio tokenizer and audio encoder, its DFlash draft model and embedded MTP heads, sized for one 128 GB DGX Spark. The 166 GB checkpoint (MXFP4 experts, FP8 attention) becomes 98.5 GB of GGUF parts; with the 1M-token KV cache, both media sidecars and the drafter loaded at once, 111.1 of the 117.2 GiB a GB10 offers stay in use. Routed experts are 8-dimensional vector-quantized codes — 13-bit everywhere, plus an 8-bit residual stage on 32 layers — fitted with an importance matrix from 4.13M calibration tokens (text, chat, tools, images, video, audio) run through the original checkpoint. Measured against this edition's own BF16 weights, teacher-forced on held-out chats: KL 0.089 and the same next token 91.9% of the time on assistant turns (the RL original against itself, batched differently: KL 0.020, 97.8%).

The predecessor, MiMo-V2.6-Flash-RL Mixed-Quant GGUF, used IQ2_XXS/IQ2_XS scalar experts. This release takes the VQ route ds4-dfm-rs runs for Beam-1.0, DeepSeek-V4.1, GLM-5.3 and MiniMax-M3.1, on dealignai's compliance-tuned edition; the companion MiMo-V2.6-Flash-RL VQ GGUF applies the same recipe to the original.

[!CAUTION] The source model has its refusal behaviour removed at the weight level (dealignai). It will follow harmful instructions; you are responsible for how you use it and for complying with applicable law.

At a glance

What is shared with the original's release

Layers 0–33 of the two checkpoints compute exactly the same activations, so the calibration forward ran once and forked at layer 34: the statistics of layers 1–33 are the same numbers for both models. The expert parts of layers 1–33 and the embedding, vision, audio, DFlash and MTP parts are therefore byte-identical to MiMo-V2.6-Flash-RL VQ GGUF (shared_with_rl in release.json); the expert parts of layers 34–47 are converted from this edition's own statistics and body-nonexpert.gguf carries its o_proj. The residual-stage layers are the ones measured on the original (the edition differs in 14 o_proj matrices); this edition's end-to-end quality is measured on its own below. preprocessor_config.json is the upstream production file (the edition's repository still carries the pre-fix copy with CLIP normalization; its vision weights are the original's byte for byte).

Why this design: only 9 of 48 layers grow with the context

MiMo keeps the full history only in its 9 global-attention layers; the 39 sliding-window layers attend to the last 128 tokens. Its KV is therefore small enough to stay resident at 1M — no SSD tier is needed — once the GA cache is stored in FP8 instead of BF16:

The FP8 cache costs nothing measurable: on the original weights it gives assistant-turn KL 0.0185, inside the original's own batching noise (0.020). The memory saved goes into expert precision.

Why 13 bits plus an 8-bit residual: GB10's 99 KiB

A GB10 CUDA block can use at most 101,376 bytes (99 KiB) of shared memory, and the routed-expert kernels keep the layer's whole codebook there while they decode every selected expert:

R13 is the widest base book that fits; the 8-bit residual stage adds only a 2 KiB book and cuts a layer's weight error about threefold (relative MSE 0.145–0.16 → 0.049–0.060 on layers 12–47). The remaining ~33 KiB holds activations, MMA tiles and staging. MiMo's expert geometry (hidden 4,096, expert FFN 2,048, top-8) is exactly GLM-5.3 VQ's, whose kernels already run it:

GB10 allows 101,376 B; staging all eight experts for the down projection leaves 1 KiB beside the residual book (GLM-5.3 VQ's decode-down kernel runs exactly 100,352 B), and Beam's 4+4 expert staging is the fallback.

Memory at the full 1,048,576 tokens

Against the 117.2 GiB a GB10 reported available to ds4-server --check-config (Beam-1.0 VQ), with every optional component loaded at once (actual part bytes):

6.1 GiB stay free in this worst case (1M context, the largest image and the drafter at once). 36 residual layers would leave 3 GiB and 40 do not fit; 32 keeps a margin for the new runtime family's buffers. memory-budget.json and tools/memory_budget_mimo.py reproduce the rows from exact byte layouts.

Recipe

• Routed experts. Every 8 consecutive weights of an expert row become one index into the layer's codebook, times one F16 row gain. One codebook per layer serves all 256 experts and gate/up/down. 13 bits everywhere: the 12-bit code stream plus a 1-bit plane (GVQ1 v1, the format ds4-dfm-rs runs for Beam, GLM and MiniMax).
• Residual stage (R13+8). A second 256-entry codebook codes what the first stage left (weighted Lloyd on the stage-1 residuals with the same importance weights), adding 8 bits per 8 weights; the 13-bit stage is byte-identical with and without it.
• Which layers get the residual stage — measured. Every MoE layer was converted both ways. With all layers at 13 bits as the baseline (assistant-turn KL 0.233), each layer alone was switched to R13+8 and the held-out set re-run end to end (47 forks of one teacher-forced pass). The gains concentrate in the second half of the stack: layer 47 (−0.0153), then 24, 22, 20, 28, 27 and GA layer 23; layers 1–16 gain nothing measurable. Six of the eight GA MoE layers rank in the top 22; the 8 GA layers are protected first (they carry the long context, which 2K–6K-token held-out rows cannot exercise), the other 24 are the best measured SWA layers. The purely measured top 32 (26 and 31 instead of GA layers 5 and 11) gives assistant KL 0.086 vs 0.088 but all-position KL 0.543 vs 0.534 — no measurable difference.
• Calibration-weighted Lloyd (importance matrix for VQ). The original checkpoint runs over the calibration set layer by layer; per layer and expert the collector sums the squared activations entering gate/up and down and how often and how strongly each expert is routed. Codebook training, vector assignment and the row-gain refit minimize the importance-weighted error: per-expert column importance tempered by a power of 0.75, rare experts shrunk toward the layer mean with a 256-token prior, column weights floored at 2%, importance-weighted least-squares gains, 32 Lloyd iterations — the weighting that measured best on A.X-K2 and Beam-1.0 and served MiniMax-M3.1. MiMo's first layers feed their experts through a few "massive activation" channels (layer 1: one hidden channel carries 38% of the input energy); the weighting fits those exactly (importance-weighted error 0.003) at the price of a high plain error (0.25), and the residual stage then buys nothing there — the sweep confirms it.
• Everything shared by every token (attention, dense FFN, head, MTP, DFlash) is Q8_0 (relative MSE 3e-5); the vision and audio sidecars are Q8_0 with their RVQ codebooks, norms, biases and sinks at source precision.
• Dead experts. Layer 7's experts 184 and 13 are never (0 of 33M routes) or almost never (11) chosen by the router — the same pair an independent 1.1M-token calibration found unobserved; the weighting gives them a trace weight.

Calibration data

4.13M tokens from the original tokenizer and chat template; held-out sets (27 text cases, 63,337 tokens; 50 native text/image/video/audio inputs, 21,288 tokens) reserved first.

66% of the text tokens sit in rows of 4,096+ tokens, 20.7% in 16K–32K rows and 6.5% in 32K–64K rows (longest 48,950): the sliding-window layers see 128 tokens, so long rows are what give the global-attention layers (and the experts behind them) representative statistics. Every MoE layer's least-routed live expert received thousands of tokens (median over layers 21,452); routes per token exactly 8.0.

Reference forward

The statistics and all measurements come from a layer-streamed reference forward of the original weights (tools/mimo_ref.py). It matches the checkpoint's own transformers code (MiMoV2DecoderLayer, same dequantized weights) to BF16 rounding (layer output relative RMS 0.1–1.0%, routed expert sets identical) and, on the 50 held-out text/image/video/audio inputs, an independent original-representation reference at mean next-token KL 0.0026 (45/50 identical argmax).

Measured on the converted bytes

Teacher-forced comparison on the held-out set (27 text cases and 50 native inputs; 65,223 scored positions, 24,885 of them in assistant turns), on RTX PRO 6000. The rows marked RL are the original's release, measured against the original; the UNCENSORED row is this release, measured against this edition's own BF16 weights. The student reads every routed expert from this repository's parts (decoded by an independent reader written from FORMAT.md, bit-identical to the converter's); the release row also uses the Q8_0 body and simulates the FP8 GA cache.

On assistant turns this edition's BF16 NLL is 0.777 nat/token, this release's 0.785 (RL: 0.773 / 0.790). All positions include untrained ones (user turns, tool schemas, the text after an image or audio clip), where even the floor disagrees at KL 0.21. By kind (all positions, KL / same top-1): raw web text and code 0.12 / 87%, thinking chats 0.38 / 88%, non-thinking chats 0.33 / 87%; tool/agent transcripts 2.3 / 58% and media turns 0.7–3.2 are dominated by their untrained prompt positions.

Files

These are independent GGUF parts, not numbered GGUF splits. Standard llama.cpp, Ollama and Transformers loaders do not read this format.

Limits

• Lossy at about 2.3 bits per routed-expert weight: on assistant turns the release agrees with the original's next token 92% of the time (KL 0.088). Long free generation, tool use, media understanding and 1M-token retrieval have not been measured here; greedy decoding may loop in long reasoning.
• The fidelity numbers are teacher-forced on held-out rows of up to 6K tokens with a reference forward, not on the engine; the GA layers' long-context behaviour is not exercised by them.
• No DGX Spark numbers yet: load, --check-config at 1M, speed and the FP8 cache kernels come with the mimo2_vq family. The memory table above is the design, computed from exact byte layouts.

Credits and sources

• Xiaomi MiMo — MiMo-V2.6-Flash-RL, its vision and audio encoders and its DFlash draft model, MIT.
• dealignai — the UNCENSORED edition, MIT.
• YoungAi by Wenzhou Wu — the 8-dim shared-codebook VQ method, F16 row gains and bit planes; its notice is kept in LICENSE-YoungAi.
• ds4-dfm-rs — GVQ1 container, GB10 VQ kernels and residual stage, calibration-weighted VQ tools, the mimo2 runtime this family builds on.
• SGLang, transformers — the MiMo-V2 reference implementations the reference forward was checked against; the September MiMo Mixed-Quant work for the native media calibration inputs.
• llama.cpp / GGML — GGUF, Q8_0 and the importance-matrix idea.

License

MIT, inherited from the pinned source and its upstream model. Calibration datasets keep their own licenses.

The upstream model card's Use Restrictions apply to derivatives, including this quantization: no unlawful, fraudulent or malicious use, no infringement of third-party rights, no harm to individuals or groups, no military use, no malicious cyber activity, no unauthorized processing of personal data, and no autonomous execution of high-risk actions without human oversight (see the upstream README).

Citation

@misc{mimo2026v26flash,
  title={MiMo-V2.6-Flash-RL},
  author={{Xiaomi MiMo Team}},
  year={2026},
  howpublished={\url{https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-RL}},
}