cloudcommander/Kvark-Sparkle-27B-MLX-8bit

Kvark Sparkle 1.0 27B, MLX 8-bit

An unofficial MLX build of Egzakta/Kvark-Sparkle-1.0-27B for Apple silicon. It is not made or endorsed by Egzakta. The weights are Kvark's, quantised to 8-bit, with its MTP head included. No training, merging or abliteration was done, so Kvark's own safety behaviour is unchanged.

The other builds:

• Smaller and faster: cloudcommander/Kvark-Sparkle-27B-MLX-AWQ-4.5bit, which also carries the quick evals.
• Uncensored twins: cloudcommander/Kvark-Sparkle-27B-Uncensored-MLX-AWQ-4.5bit and cloudcommander/Kvark-Sparkle-27B-Uncensored-MLX-8bit.

Base	Egzakta/Kvark-Sparkle-1.0-27B @ bb41d9af, BF16 (a post-train of Qwen/Qwen3.8-27B)
Weights	30.0 GB (27.94 GiB). 8-bit affine, group size 64, in all 505 quantised modules, the MTP head's 7 among them
Vision tower	Kvark's, unquantised BF16
MTP head	1 layer, inline in model-mtp.safetensors (see MTPLX and mlx-lm)
Context	262,144 tokens (config)
Architecture	Qwen3_5ForConditionalGeneration, 64 layers, hidden size 5,120

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's shorter reasoning.

Decode speed. These are single requests of one greedy 400-token coding prompt on a Mac Studio (M5 Ultra):

Runtime	Decode	MTP acceptance	Time to first token
oMLX, MTP mode at depth 3, unquantised KV cache	83.8 tok/s	0.881	0.315 s
MTPLX, MTP mode, with the head moved to a sidecar (below)	53.3 tok/s
MTPLX, autoregressive (no MTP)	30.6 tok/s

The MTPLX figures come from a short 80-token smoke test, not the benchmark prompt. The 4/6 build is about 2.3× faster with z-lab's DFlash2 drafter, at 192.9 tok/s, but gives up a little precision: its top-1 agreement with this build is 0.959.

Thinking tokens. They weren't counted on this build. On the 4/6 build, with thinking on, the mean answer was 4,480 tokens on LiveCodeBench and 1,253 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. Quantisation. 8-bit affine with group size 64, starting from Egzakta's BF16. The vision tower is left unquantised.
2. MTP head. Kvark's card says the head is the base model's, unchanged. It is taken from the BF16 checkpoint, its norms are offset by +1.0 to match MLX's convention, and the 7 projections are quantised to 8-bit g64. Its norm means match an independent Qwen3.8 MTP head to 4 decimals.
3. Checks.
   • The bit widths are as declared, the vision tower is unquantised, and all 29 MTP tensors are present.
   • The tokenizer and chat template match Kvark's.
   • All 216 norms match an independent Qwen3.8 8-bit MLX build to within 0.0004.

Usage

With mlx-vlm (tested with 0.7.9):

pip install -U mlx-vlm
python -m mlx_vlm.generate --model cloudcommander/Kvark-Sparkle-27B-MLX-8bit \
  --max-tokens 2048 --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 and use MTP mode. The speed above used 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:

1. Take the mtp.* tensors out of the trunk index and into a separate mtp.safetensors, dropping the language_model. prefix.

2. Quantise mtp.fc to 8-bit g64.

3. In config.json, 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.

Set up that way, this build ran on MTPLX at 53.3 tok/s with MTP.

Not tested

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

Licence and credits

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

• Qwen Team, Alibaba Group: Qwen3.8-27B, the base model.
• Egzakta / KVARK: Kvark Sparkle 1.0, the post-train these weights are.

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