DeepSeek-V4.1-Flash-1017 · exlr8

Manifests: k3 loads every main layer's experts at 3 bits (425 GB of weights, or 222 GB with the Engram tables read from disk, sized for two GB10 boxes). k4 loads 4 bits where a layer has a 4-bit encode (layers 0-7 and 38-39) and the official weights elsewhere (506 GB). native loads the official weights. k4 was named pmcgx-k4 before 2026-11-09. No manifest loads the 2-bit files of layers 38-39 yet.

This is kindlingai/deepseek-v4.1-flash-exlr8-native (the official DeepSeek-V4.1-Flash-1017 weights, byte for byte, in the exlr8 v2 file layout) with the routed and shared experts of layers 0-7 also stored as a 4-bit exlr8 trellis encode (K4) with the pmcgx codebook, and the routed and shared experts of layers 0-39 as a 3-bit encode (K3), and those of layers 38-39 also as 2-bit (K2) and 4-bit encodes. Every other matrix keeps its FP8 or BF16 values.

Every layer also keeps its official expert files, so one download serves every choice. A manifest picks the store of every unit:

Weight set ID: 432cab4b808b1a45748243e18bddbf61df6a0add2d5608b0ef121a1c7c3f8fc7. Source revision: 1bae0e1088993b9b82de08f59de5be5a34e42170.

Engine support for the trellis layers is in progress in kindlingai/gr8.

Layout

exlr8 cuts every expert projection into units of 128 intermediate channels and gives each unit a fixed owner at each tensor-parallel size, so a box fetches only its own share with HTTP range requests:

• index-slices/tpN/<store>/rankR.safetensors lists every unit one rank owns at TP = N: (expert, unit), its byte offset in the layer's store file, and its checksum (for k4, also the unit's side data). Slices exist for TP = 1 to 8 and every store: mxfp4, fp8b32, k2, k3 and k4.
• The owner of unit u of expert e in layer L at TP = N is rank (18·e + u + L) mod N. The shared expert is expert E (384, or 128 in the MTP layers).
• Dense matrices sit in one file per layer, with a checksum per 128-channel block of the side a TP engine shards.

Stores

A native unit is the source codes for its 128 channels followed by their scales, in HF orientation; concatenating the units of a projection gives the source tensors exactly. A k2, k3 or k4 unit is 128 channels of trellis tiles in the exlr8 v2 order (gate_up_order grouped, down_order item128). The trellis tensors are named trellis.<proj>.<codebook> and shared.trellis.<proj>.<codebook>, and each trellis file's metadata names its codebook: pmcgx V2 L20 0xCBAC1FED/0xBCA14C51 or mul1 0x83DCD12D. mul1 hashes one weight per state (FORMAT.md, Codebook). pmcgx is a pair trellis: two weights share one 20-bit state, and each is a sum of two fp16 halves of the state's products with the two multipliers, rounded to FP8 E4M3. The rotation (128 × 128 Hadamard on both sides), the layer signs and the per-channel and per-block scales are the exlr8 v2 ones, stored in the layer's index file. All encodes of a layer share its signs and its codebook.

Files

config.json  tokenizer.json  tokenizer_config.json  LICENSE  encoding/   from the source repository
dense/exlr8-dense-LLL.safetensors              layer L's attention, router, engram and mHC tensors
dense/exlr8-split-LLL.engram.embed.pPPP...     engram tables of layers 1 and 14
dense/exlr8-vocab.safetensors                  embed, head, final norm
dense/exlr8-extra-vision.safetensors           vision tower and aligner
experts/exlr8-layer-LLL.index.safetensors      unit offsets and checksums, and the trellis side data
experts/exlr8-layer-LLL.mxfp4.safetensors      routed experts, official FP4
experts/exlr8-layer-LLL.fp8b32.safetensors     shared expert, official FP8
experts/exlr8-layer-LLL.k4.safetensors         layers 0-7 and 38-39: routed and shared experts, 4-bit trellis
experts/exlr8-layer-LLL.k3.safetensors         layers 0-39: routed and shared experts, 3-bit trellis
experts/exlr8-layer-LLL.k2.safetensors         layers 38-39: routed and shared experts, 2-bit trellis
manifests/exlr8-manifest-k3.json
manifests/exlr8-manifest-k4.json
manifests/exlr8-manifest-native.json
index-slices/tpN/{mxfp4,fp8b32,k2,k3,k4}/rankR.safetensors
hashes/<path>.sha256                           "<sha256> <bytes>"

Layers 0-39 are the main layers (layers.L.); layers 40-42 are the MTP stages mtp.0. to mtp.2..

The repository is 790 GB: 7 GB of k2, 204 GB of k3 and 68 GB of k4 files on top of the official weights. A box that loads k4 reads 506 GB, and one that loads k3 reads 425 GB (it skips the official expert files of layers 0-39). About 197 GB of that is the Engram tables, which an engine can read from disk instead of memory.

Loading

The pure-PyTorch reference loader in kindlingai/exlr8 reads the native stores:

python -m loader.exlr8 DIR --manifest native --layer 20 --raw --verify --out layer20.safetensors

It decodes mul1 but not the pmcgx codebook yet.

Checks

Every unit of every k2, k3 and k4 file was read back and compared with the encoder's output, tile for tile, with its checksum and side data. Every index file keeps the native release's blocks byte for byte, and the tooling that wrote the set ID and index slices reproduces those of the earlier versions exactly. The files shared with kindlingai/deepseek-v4.1-flash-exlr8-native are the same bytes, and the reference loader rebuilt the official tensors from them with checksums on.

License

MIT, as the source model. See LICENSE.