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]
Design card, conversion in progress (2026-10-30). The recipe, byte formats and memory plan below are
final; quality numbers and file hashes are filled in when the conversion and its measurements finish.
Serving needs the ds4-dfm-rs mimo2_vq family, which is being implemented on DGX Spark next. 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. Routed experts become 8-dimensional vector-quantized codes (13-bit everywhere, plus an 8-bit
residual stage on 32 layers), fitted with an importance matrix from 3.97M calibration tokens run through the
original checkpoint; everything shared by every token stays at 8 bits.

The predecessor, MiMo-V2.6-Flash-RL Mixed-Quant GGUF,
used IQ2_XXS/IQ2_XS scalar experts. This release tries the VQ route that 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 was run
once and forked at layer 34: the statistics of layers 1–33 are the same numbers for both models. Consequently
the expert parts of layers 1–33, the embedding, vision, audio, DFlash and MTP parts are byte-identical to
MiMo-V2.6-Flash-RL VQ GGUF; the expert parts of
layers 34–47 and body-nonexpert.gguf (its o_proj) are converted from this edition's own statistics and weights.
The residual-stage layer list is the one measured on the original (the edition differs only in 14 o_proj
matrices); its end-to-end quality is measured separately on this edition.

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 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. 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 roughly triples the
precision of a layer's weights (GLM-5.3 VQ layer 23: relative MSE 0.1438 → 0.0412). The remaining ~33 KiB holds
activations, MMA tiles and staging: the existing MiniMax prefill MMA kernels use 96,768 B (R13) and 98,816 B
(R13+8). MiMo routes top-8 like Beam-1.0 (MiniMax: top-4), so staging all eight experts' 2,048-wide BF16
intermediate rows for the down projection would need 32 KiB beside the 66 KiB of books; the runtime plan uses
Beam's 4+4 expert staging there.

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:

About 6 GiB stay free in the worst case (1M context, the largest image, the drafter). 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 every row 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. The 8 MoE layers behind the global attention (5, 11, 17, 23, 29, 35, 41,
  47. carry the long context and are protected first; the other 24 are the SWA layers with the largest measured
      end-to-end gain (each layer alone switched to R13+8 on top of the all-13-bit baseline, held-out KL against
      the original). Weight error does not translate proportionally into end-to-end quality, so the choice is
      measured, not assumed.
• 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-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.
• Everything shared by every token (attention, dense FFN, head, MTP, DFlash) is Q8_0; the vision and audio
  sidecars are Q8_0 with their RVQ codebooks, norms, biases and sinks at source precision.

Calibration data

3.97M tokens from the original tokenizer and chat template; held-out sets reserved first.

66% of the text tokens sit in rows of 4,096+ tokens, 15.8% in 16K–32K rows and 6.0% in 32K–64K rows: the
sliding-window layers see 128 tokens, so long rows are what give the global-attention layers (and the experts
behind them) representative statistics.

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 50 held-out
text/image/video/audio/joint inputs, the September original-representation reference at mean KL 0.0026 on the
next-token distribution (45/50 identical argmax).

Planned files

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

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.
• 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.
• 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.