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
• awq
• abliterated
• uncensored
• qwen3.8
• kvark
• mtp

Kvark Sparkle 1.0 27B, Uncensored, MLX AWQ 4/6-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 with AWQ to mixed 4/6-bit. No training or fine-tuning was done.

The 8-bit twin is cloudcommander/Kvark-Sparkle-27B-Uncensored-MLX-8bit.

Results

All runs on an Apple M5 Ultra, against Kvark built the same way without the edit. The samples are small, so read
these as indications rather than benchmarks.

The evals have too few questions to separate the two: the ranges overlap. The token counts are under
Speed.

¹ 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, and only 3 opened with a refusal. That breakdown was not repeated for this version.

How far the edit moves the model:

• Drift (8-bit twins). Uncensored 8-bit against Kvark 8-bit, teacher-forced over 6,656 positions of coding text:
  top-1 agreement 0.979, KL 0.0084. For scale, OrcaRouter's uncensored Qwen3.8 against stock Qwen3.8 is 0.984 /
  0.0048.
• This build against the uncensored 8-bit. Top-1 0.959, KL 0.018. Kvark's own 4/6 against its 8-bit is 0.959 /
  0.018.

Speed

The weights aren't changed for speed. Two things make it fast: speculative decoding, and Kvark spending fewer tokens on
thinking.

Decode speed. These are single-request runs of one greedy 400-token coding prompt on a Mac Studio (M5 Ultra), using
oMLX with the Splash engine, int8 KV cache, and z-lab's DFlash2 drafter
(z-lab/Qwen3.8-27B-DFlash2):

The last two rows were measured in the same session and this model's row in a later one. Between sessions the same
build has varied by about 7 tok/s, so treat the three as equal.

DFlash2 was trained on stock Qwen3.8, and it still fits Kvark's weights. Without a drafter, the model decodes at
ordinary 4-bit speed.

Thinking tokens. These are counted with thinking on, on the same eval questions as above:

On questions that both this model and the Qwen3.8 build got right, it used 49% fewer tokens on LiveCodeBench
(28 questions, 3,055 → 1,553) and 34% fewer on MMLU-Pro (75 questions, 893 → 588). At the same decode speed, that
means answers finish sooner.

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 two output projections. The edit is made on Egzakta's BF16 weights.
3. Strength curve. At s = 1 everywhere, Kvark still refused about one harmful prompt in five (21 of 104).
   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 controls, 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. Re-grid. At 4 and 6 bits the edit is smaller than one quantisation step, so requantising the build snaps it
   back: a first attempt still refused 100 of 104. Instead, the edited BF16 writers, times the build's AWQ input
   scales, are rounded onto the build's own grid. 96–99% of unedited weights land on their previous integers, all
   within one step. After rounding, the attention writers keep about −0.5 of their original refusal component (the
   overshoot) and the MLP writers about 0, as intended.
5. Quantisation. Before the edit, the build was quantised from Egzakta's BF16 with AWQ calibration, 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-AWQ-4.5bit \
  --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 197 tok/s above used the Splash engine with
z-lab/Qwen3.8-27B-DFlash2 as the draft model, set in oMLX's per-model settings.

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 and point mlx_lm_extra_tensors.mtp_file at it.

Not tested

• Vision. The tower is Kvark's, untouched and unquantised, but nothing visual was evaluated.
• Full benchmarks. Only the quick evals above have been run.
• 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.
• z-lab: the DFlash2 drafter used for the speed figure. It is not included here.

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}
}