Binade/Qwen3.5-9B

Qwen3.5 9B, losslessly compressed with Binade

Qwen/Qwen3.5-9B packed with Binade: 13.27 GB instead of 19.31 GB (10.722 bits per weight instead of 16 in the packed tensors), every weight restored bit for bit, and outputs bit-identical to the BF16 model, not just close.

Binade codes each weight's exponent by its frequency rank and keeps the sign and mantissa as they are. Its kernels decode the weights inside the matrix products and add the products in exactly the order the framework's own BF16 kernels do, so the logits and generated tokens match the original. The paper explains how.

Exactness

check	result
every tensor unpacked and compared with the original checkpoint	775 tensors, 0 values differ (Qwen3.5-9B/roundtrip_v2.md)
logits at 16,352 WikiText-2 positions, Apple M4 Max, against BF16 in memory	16,352 / 16,352 bit-identical (Qwen3.5-9B/exactness_scale.md)
32 greedy generations of 128 tokens, Apple M4 Max	32 / 32 identical, tokens and log-probabilities
the same logits test on NVIDIA RTX PRO 6000 Blackwell Server Edition	16,352 / 16,352 bit-identical, 32 / 32 generations (cuda/Qwen3.5-9B/exactness_scale.md)
MLX 8-bit quantization, for comparison	0 / 16,352 positions identical, argmax agreement 98.2%

Size and speed

	BF16	Binade	MLX 8-bit (lossy)
checkpoint	19.31 GB	13.27 GB
greedy decoding, Apple M4 Max	26.9 tok/s	34.4 tok/s	48.7 tok/s

Decoding speed: Qwen3.5-9B/decode_speed.md. NVIDIA results: https://github.com/GuyShafir/binade/tree/main/results.

Use

pip install binade               # Apple Silicon
pip install "binade[cuda]"       # Linux + CUDA 12

from mlx_lm import generate
from binade.mlx.r4 import load

model, tokenizer, _ = load("Binade/Qwen3.5-9B")
messages = [{"role": "user", "content": "Why is the sky blue?"}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True)
print(generate(model, tokenizer, prompt, max_tokens=200))

To get the original BF16 checkpoint back, bit for bit: binade unpack Binade/Qwen3.5-9B --out Qwen3.5-9B-bf16.

Requirements and limits

• MLX 0.32.2 and mlx-lm 0.31.3, which pip install binade installs. Exactness is tied to MLX's own kernels; the tests in the repository check it.
• Apple Silicon runs the fused prompt kernels on M3 and M4 GPUs. On NVIDIA they are verified on the RTX PRO 6000, L4 and A100; on other GPUs prompts rebuild BF16 weights, which is exact but slower.
• The checkpoint keeps every tensor of the original, the vision and multi-token prediction weights included (binade unpack restores them), but the runtime loads the text model through mlx-lm, so it serves text. Exactness was tested on text generation.
• The Hub tags this repository 8-bit, and counts its parameters by bytes, because the packed bytes are stored as uint8 tensors. The weights are the full BF16 weights: binade unpack restores every one bit for bit.

License

The weights keep the base model's license: apache-2.0 (terms). Binade itself is Apache-2.0.

Citation

@misc{shafir2026binade,
  title  = {Binade: Bit-Exact Compressed LLM Inference on Apple Silicon},
  author = {Guy Shafir and Tulber},
  year   = {2026},
  url    = {https://github.com/GuyShafir/binade}
}

Packed by Binade format 2 at commit 2096638 of the development repository.