license: mit
base_model:

• dealignai/DeepSeek-V4.1-Flash-UNCENSORED-FP8
  base_model_relation: quantized
  pipeline_tag: text-generation
  tags:
• gguf
• dwarfstar
• deepseek-v4.1
• quantized
• q2
• apple-silicon
• abliterated

DeepSeek V4.1 Flash UNCENSORED — DwarfStar Q2 bootstrap

This is a community conversion of dealignAI's DeepSeek-V4.1-Flash-UNCENSORED-FP8 into the Q2 GGUF format that DwarfStar uses.

Why we're sharing it. To save other people the trouble. We downloaded the source checkpoint, converted it on an Apple M5 Max MacBook Pro with 128 GB of unified memory, checked that the result worked, and hooked it up to OpenCode. If you want the same setup, you can download this file instead of pulling the roughly 510 GB source and spending several hours converting it yourself. This is an independent community effort, not an official release from DeepSeek, dealignAI, or DwarfStar.

Who did what

• DeepSeek AI built the original DeepSeek-V4.1-Flash model and its architecture.
• dealignAI produced the abliterated checkpoint. Their model card credits @dealignai and Jordan Schenck / @jordanschenck. The abliteration is entirely their work. We didn't do it and don't take credit for it.
• Salvatore Sanfilippo (antirez) and the DwarfStar contributors wrote the inference engine, the V4.1 converter, the quantization code, and the validation tools we used. DwarfStar in turn builds on llama.cpp and the GGML authors, whose copyright notices are kept in LICENSE-DwarfStar.
• pyrodog ran the conversion, packaged it, did some light local testing, and uploaded it, with help from OpenAI Codex. No training, fine-tuning, merging, or additional abliteration was done. The weights are the source checkpoint's weights, just quantized.

What you're getting

This is not a normal GGUF. It uses DwarfStar's own tensor layout, so don't expect it to load in llama.cpp, Ollama, LM Studio, or any other GGUF runtime. The converter also drops the vision weights and the DSpark speculative-decoding draft weights, so this file alone gives you neither of those features from the source checkpoint.

The main weights take up about 151.8 GiB, which is more than the 128 GB of RAM on our test machine, so DwarfStar has to stream them from the SSD. Another roughly 188.8 GiB of native Engram tables stay on disk permanently. Put the file on a fast local SSD or it will be painfully slow.

How this file was produced

1. We downloaded the public dealignAI safetensors checkpoint at revision d61c59ea5e514e25d305b5850e8a432f7a9969f2. That checkpoint was the direct input to the converter. We did not start from antirez's stock Q2 GGUF.
2. We checked all 48 safetensors files against the SHA-256 hashes in the pinned Hugging Face file manifest.
3. We ran DwarfStar at revision a04f46fa423e45712c8c7e430eff422479f314a3, using gguf-tools/deepseek41_quantize.py with the Q2 recipe, six conversion workers, and resumable output.
4. We changed exactly two metadata strings in the converter: the model's display name and its source URL, so the output correctly identifies itself as the dealignAI derivative. The patch is included. No runtime or quantization logic was touched.
5. We ran deepseek41_validate_gguf.py --payload against the pinned source, then did a short Metal inference test and a read-tool round trip through OpenCode.

The Q2 recipe uses IQ2_XXS for the routed gate/up experts, Q2_K for the routed down experts, Q8_0 for attention, shared experts, and output, and F16/F32 for the tensors the recipe designates. Native Engram rows and scales are packed without loss. Note that this is not the activation-calibrated recipe instance behind the published stock V4.1 Q2. We make no claim that quality matches it.

Provenance files included: provenance.json, source-sha256.json, converter-metadata.patch, and SHA256SUMS.

Download and run

Install the Hugging Face CLI however you like, then:

hf download pyrodog/DeepSeek-V4.1-Flash-UNCENSORED-DwarfStar-Q2 \
  DeepSeek-V4.1-Flash-UNCENSORED-Q2-bootstrap.gguf SHA256SUMS \
  --local-dir ./model
cd model
shasum -a 256 -c SHA256SUMS
cd ..

git clone https://github.com/antirez/ds4.git
cd ds4
git checkout a04f46fa423e45712c8c7e430eff422479f314a3
make -j6
./ds4 -m ../model/DeepSeek-V4.1-Flash-UNCENSORED-Q2-bootstrap.gguf \
  --metal --ssd-streaming --ssd-streaming-cache-experts 32gb --ctx 32768

To run it as an API server that OpenCode can talk to:

./ds4-server -m ../model/DeepSeek-V4.1-Flash-UNCENSORED-Q2-bootstrap.gguf \
  --metal --ssd-streaming --ssd-streaming-cache-experts 32gb \
  --ctx 262144 --host 127.0.0.1 --port 8000 \
  --kv-disk-dir ./server-kv --kv-disk-space-mb 8192

Point your client at http://127.0.0.1:8000/v1 with model ID deepseek-v4.1-flash. Follow DwarfStar's client guide and make sure the client's context setting matches what you gave the server. We used OpenCode 1.18.30 with temperature 1.0 and top-p 0.95. Our OpenCode provider hook is included as opencode-dwarfstar.ts. It sets those sampling values and, for the ds4 provider only, lifts that OpenCode version's 32,000-token output cap so the model's own configured output limit applies.

One thing to understand about context: we set the output ceiling to 262,144 tokens, but input and output share the server's 262,144-token context. The server clamps generation to whatever space is left. You do not get 256K in plus 256K out. With the settings above, the server reported about 51.74 GiB of planned memory. We did not test conversations that actually fill the full 256K.

What we actually tested

• The five converter fixture tests in the DwarfStar repo passed.
• Every source file hash matched.
• The artifact audit passed its 1,046-tensor layout and payload checks. That covers all non-expert tensors, a selection of experts, and a sample of Engram rows. It did not compare every expert or every Engram row.
• A short 4,096-context Metal run answered 17 × 23 = 391 correctly and wrote a coherent Spanish sentence about backups. That run generated 11.87 tokens per second.
• OpenCode successfully called read on a small test file, got the result back, and returned the expected marker. A follow-up turn reused 10,316 cached tokens.

These are basic "does it turn on" checks, not a coding benchmark or a real quality evaluation. Speed will vary with cache state, context length, memory pressure, and workload. We have not independently verified the source publisher's refusal-removal claims, reproduced their evaluations, or checked how well those properties survive Q2 quantization. "UNCENSORED" in the name just identifies which upstream checkpoint this came from. It's not a promise from us about how the model behaves.

Reproducing the conversion

See REPRODUCE.md. You'll need roughly 876 GB of free space for the source plus the output, before caches and headroom. We kept the source on an external Samsung SSD and wrote the output to the internal SSD. Both source verification and the converter need the original checkpoint on disk.

License

The base model and the dealignAI checkpoint are MIT-licensed. The original DeepSeek license is included as LICENSE, and DwarfStar's MIT notice with its upstream acknowledgements is included as LICENSE-DwarfStar. If you redistribute this file, keep the upstream credits and notices intact.