license: apache-2.0
base_model: Egzakta/Kvark-Sparkle-1.0-27B
library_name: mlx
pipeline_tag: image-text-to-text
language:

• en
  tags:
• mlx
• 8-bit
• abliterated
• uncensored
• qwen3.8
• kvark
• mtp

Kvark Sparkle 1.0 27B, Uncensored, MLX 8-bit

An unofficial, uncensored version of Egzakta/Kvark-Sparkle-1.0-27B
for Apple silicon. It is not made or endorsed by Egzakta. One refusal direction is projected out of the weights, with a
per-layer strength, and the result is quantised to 8-bit. No training or fine-tuning was done.

The smaller twin is cloudcommander/Kvark-Sparkle-27B-Uncensored-MLX-AWQ-4.5bit.
It has the same edit, plus quick accuracy evals.

Results

All runs on an Apple M5 Ultra. The samples are small, so read these as indications rather than benchmarks.

¹ A held-out split of harmful and harmless prompts that the strength sweep never saw. Decoding was greedy with
thinking off and 96 tokens, scored with Heretic's refusal markers. The markers
count warnings as well as refusals: in an earlier version of the edit, most remaining hits were cautions partway
through an answer. That breakdown was not repeated for this version.
² Teacher-forced over 6,656 positions of coding text. For scale, OrcaRouter's uncensored Qwen3.8 against stock Qwen3.8
is 0.984 / 0.0048, so this edit moves the model about 1.75× as far, by KL.
³ One greedy 400-token coding prompt.

Speed

The weights aren't changed for speed. This build gets its speed from its own MTP head, which drafts tokens ahead for
the trunk to check, and from Kvark spending fewer tokens on thinking.

Decode speed. Single requests of one greedy 400-token coding prompt on a Mac Studio (M5 Ultra), using oMLX in MTP
mode at depth 3 with an unquantised KV cache:

The edit leaves the MTP head's drafting almost untouched. The 4/6 twin is about 2.4× faster with z-lab's DFlash2
drafter, at the cost of a little precision (top-1 agreement 0.959 against this build).

Thinking tokens. They weren't counted on this build. On the 4/6 twin, with thinking on, the mean answer was 3,294
tokens on LiveCodeBench and 1,479 on MMLU-Pro. A Qwen3.8-27B build at the same recipe took 5,952 and 2,010. Details are
on the 4/6 card.

How it was made

1. Direction. A single refusal direction r (5,120 floats), recovered from OrcaRouter's uncensored Qwen3.8-27B
   through npario's 8-bit MLX conversion (npario/Qwen3.8-27B-Uncensored-OrcaRouter-MLX-8bit). That model turned
   out to be a one-direction abliteration of stock Qwen3.8, with the same direction in every layer (cosine 1.000).
   Projecting r out of stock Qwen3.8 reproduces it ten times more closely than stock does (KL 0.00047 against
   0.00477). Kvark shares Qwen3.8's base, and the direction works on it unchanged.
2. Edit. W ← (I − s·r rᵀ) W on the 131 matrices that write into the residual stream: the embeddings, each
   layer's attention output projection (o_proj, or out_proj in the linear-attention layers), each down_proj, and
   the MTP head's o_proj and down_proj. The edit is made on Egzakta's BF16 weights, and the edited matrices are
   then quantised to 8-bit. Everything else is the plain 8-bit build of Kvark.
3. Strength curve. At s = 1 everywhere, Kvark still refused about one harmful prompt in five (22 of 104 for this
   build). Following Heretic's idea of a per-layer strength, but without its Optuna search, 9 curves were tried with the
   direction projected out live. Each was scored on 40 train prompts that still tripped, 16 that didn't, and the
   first-token KL on 32 harmless prompts. s = 1.5 on attention writers and 1 on the MLP and embeddings halved the
   remaining refusals for the least added KL. s = 1.5 everywhere went further at more than twice the KL, and s = 2
   broke the model.
4. Build. It was quantised from Egzakta's BF16, and the MTP head was grafted with its norms offset by +1.0. The
   tokenizer and chat template are Kvark's, unchanged.

Usage

With mlx-vlm (tested with 0.7.9):

pip install -U mlx-vlm
python -m mlx_vlm.generate --model cloudcommander/Kvark-Sparkle-27B-Uncensored-MLX-8bit \
  --max-tokens 1024 --enable-thinking --prompt "Explain how a hash table handles collisions."

The chat template thinks by default. To turn thinking off through an OpenAI-compatible server, send
"chat_template_kwargs": {"enable_thinking": false}.

With oMLX, put the folder in a model directory. The speed above used oMLX's MTP mode with the bundled head at depth 3.

MTPLX and mlx-lm

The MTP head is stored inline as mtp.* tensors. mlx-lm's qwen3_5 loader takes those as the sign of a raw HF
checkpoint and adds +1.0 to every norm, which this build already has, and the output turns to garbage. This was seen
with MTPLX, which loads through mlx-lm. Plain mlx-lm loading should break the same way, but was not tested.

For MTPLX, move the head into a sidecar mtp.safetensors, quantise mtp.fc to 8-bit g64, point
mlx_lm_extra_tensors.mtp_file at the sidecar, and add the head contract that MTPLX's own Qwen3.8 builds use:

"mlx_lm_extra_tensors": {"mtp_file": "mtp.safetensors"},
"mtplx_mtp_contract": {"base_hidden_variant": "post_norm", "concat_order": "embedding_hidden", "hidden_variant": "post_norm",
                       "mtp_position_mode": "local", "mtp_quant_group_size": 64, "mtp_quant_mode": "affine"}

Also drop the per-module mtp.* entries from the quantization block.

Kvark's own 8-bit, set up this way, ran on MTPLX at 53.3 tok/s with MTP. This uncensored build hasn't been run on
MTPLX.

Not tested

• Vision. The tower is Kvark's, untouched and unquantised, but nothing visual was evaluated.
• Accuracy evals on this build. None were run. The 4/6 twin's quick evals are the nearest evidence.
• Refusals with thinking on, long-context behaviour, languages other than English.

Intended use and risks

This model will answer requests the original refuses, and it has no built-in guardrails of its own. It is meant for
research, red-teaming, and private use by people who take responsibility for what they do with it. Don't put it in
front of end users without your own safeguards. You are responsible for its outputs and for following the law where
you live. Its knowledge, mistakes and biases are Kvark's and Qwen3.8's.

Licence and credits

Apache-2.0, as is every model in its lineage. LICENSE and Egzakta's NOTICE are included unchanged. The only
changes to Egzakta's weights are the edit and the quantisation described above.

• Qwen Team, Alibaba Group: Qwen3.8-27B, the base model.
• Egzakta / KVARK: Kvark Sparkle 1.0, the post-train
  this model is built from.
• OrcaRouter: the abliterated Qwen3.8-27B that the refusal direction comes from.
• npario: the MLX conversion of OrcaRouter's model that the direction was extracted from.
• p-e-w's Heretic: the per-layer strength idea and the refusal markers used
  for scoring. No Heretic code is used or shipped.

Egzakta's card gives this citation for Kvark:

@misc{kvarksparkle2026,
  title  = {KVARK Sparkle 1.0},
  author = {Egzakta AI Lab},
  year   = {2026},
  url    = {https://huggingface.co/Egzakta/Kvark-Sparkle-1.0-27B}
}