base_model: dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 base_model_relation: quantized license: mit library_name: ds4 pipeline_tag: text-generation quantized_by: spiritfather , SolsticeAI tags:

• solstice-ai
• gguf
• deepseek-v4.1
• uncensored
• abliterated
• mxfp4
• ds4

DeepSeek-V4.1-Flash-1017-UNCENSORED — MXFP4 GGUF for ds4

A @Solstice-AI x @spiritfather release

WIP FOR PROTIUM INTEGRATION

[!Note] All credit for the model goes to dealignai — a weight-level abliteration (refusal removal) of DeepSeek V4.1 Flash 1017 — and DeepSeek for the base DeepSeek-V4.1-Flash-1017 (552B MoE, 1M context). This is a format conversion only.

[!Important] The file format, tensor layout and quant recipe are antirez's, from his ds4 inference engine and his stock DeepSeek-V4.1-Flash-1017 MXFP4 build. This file uses the same tensor types as that build, so the only difference is dealignai's uncensored weights. Thank you.

[!Tip] Benchmarked on CaliperBench — a creative-writing benchmark scoring prose craft, roleplay and willingness rather than general intelligence. Both halves (thinking on and off) were swept from this exact file and are read against the stock DeepSeek V4.1 Flash 1017 served by the provider in FP8.

What this is

DeepSeek V4.1 Flash is a 552B mixture-of-experts model with a new architecture (compressed attention, Engram n-gram memory tables, hyper-connections) that mainline llama.cpp cannot load yet. ds4 is antirez's dedicated engine for it (Metal, CUDA, ROCm). It streams the routed experts and the Engram tables from SSD, so a 256 GB Apple Silicon machine can run it.

dealignai released the uncensored weights only as FP8 safetensors. This repo is those weights converted to ds4's GGUF so they can run locally:

Verified on conversion: ds4's validator passes all 1,046 tensors against the source payload, and the layer-0 routed experts are byte-identical to antirez's stock 1017 MXFP4 build. So dealignai's abliteration left the routed experts untouched, and repacking them did not lose anything.

Downloading

Hugging Face caps a file at 500 GB and this one is 501.6 GB, so it is published as 9 standard GGUF split shards, the same layout as antirez's stock 1017 MXFP4 release. ds4 needs the single file, so download the shards and join them with ds4's own merge script. It restores the 16 KiB page alignment and checks the result against the original file's SHA-256, so what you run is byte-for-byte the file we validated and benchmarked.

# 1. Download the 9 shards (~467 GiB)
hf download spiritfather/DeepSeek-V4.1-Flash-1017-UNCENSORED-MXFP4-GGUF \
  --include "*.gguf" --local-dir ds41-uncensored

# 2. Join them with ds4's merge script (from a ds4 checkout)
python3 ds4/gguf-tools/merge_deepseek41_shards.py \
  --output DeepSeek-V4.1-Flash-1017-UNCENSORED-MXFP4.gguf \
  --expected-bytes 501609136128 \
  --sha256 39c0291c57af11124b933d5a742a66b676f357520912a44a227bfa2dc5d9a175 \
  ds41-uncensored/DeepSeek-V4.1-Flash-1017-UNCENSORED-MXFP4-0000{1..9}-of-00009.gguf

# 3. Once it prints the verified file, the shards can go
rm -r ds41-uncensored

• Disk: the merge keeps the shards until it finishes, so you need about 935 GiB free at once: 467 GiB of shards plus the 467 GiB output. It checks the space before it starts, and an interrupted merge resumes.
• Hashes: the merged file must be exactly 501,609,136,128 bytes with SHA-256 39c0291c57af11124b933d5a742a66b676f357520912a44a227bfa2dc5d9a175. The merge script refuses anything else.
• Shards: 1–7 hold the attention, shared-expert and routed-expert tensors in file order. Shards 8 and 9 are the two 94.4 GiB Engram tables, one each.

Running (ds4)

./ds4-server -m DeepSeek-V4.1-Flash-1017-UNCENSORED-MXFP4.gguf --ssd-streaming --ctx 81920 --host 0.0.0.0 --port 7001

• Memory: the main weights are ~279 GiB, which is more than a 256 GB machine holds. With --ssd-streaming and the default expert cache, about 61% of the experts stay resident. Expect ~9–14 tok/s decode once warm, on a single session. Each restart empties the cache, so the first prompts are slow.
• Keep the automatic cache. A larger --ssd-streaming-cache-experts budget left the static weights pageable and decode fell to ~0.3 tok/s under memory pressure.
• Thinking: on by default. For the non-thinking mode send "think": false in the request body.
• Sampling: ds4 has no repetition penalty and ignores thinking-budget limits.
• Text only: the vision encoder is not included. antirez's DeepSeek-V4.1-Flash-Vision.gguf is the stock one.

Conversion recipe

1. dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 safetensors → ds4 GGUF with ds4's converter and an MXFP4 recipe that matches antirez's stock 1017 build. The routed experts are already FP4 in the checkpoint and are repacked to MXFP4 without requantizing; attention, shared experts and the output head go to Q8_0; the Engram tables are stored for disk streaming.
2. Checked with ds4's payload validator (1,046/1,046 PASS) and a byte-for-byte comparison of the layer-0 experts against antirez's file.
3. Split for upload into 9 standard GGUF split shards. Before any shard was written, ds4's own merge logic was run on the shard headers and rebuilt the original header and size exactly; the alignment padding was checked to be zero. So the merge above reproduces the original file, and its SHA-256 check proves it.

License

MIT, inherited from deepseek-ai/DeepSeek-V4.1-Flash-1017 and dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8.