Escha-W2 runs on Metal.Feel the difference.

We know of no other implementation that reads the Escha-W2 tensor format on MLX. Not a claim to have invented EXL3 — exllamav3 is the reference and the source of the method. A claim about portability: the published build is CUDA sm_80–120, this one runs the same weights on Metal. If we missed one, open an issue and we will correct it.

Derived from the tensors, verified against the unquantized base model, and not documented publicly anywhere else.

escha_code   I16  [E, in/16, out/16, 16*K]   packed trellis codes
escha_rin    F16  [E, in]                    per-input-channel scale
escha_rout   F16  [E, out]                   per-output-channel scale
escha_s_in   F32  [E, in]                    all 1.0 in this release
escha_s_out  F32  [E, out]                   all 1.0 in this release
escha_config I32  [9] = [tile=16, K, bits, mcg_flag, num_experts, in, out, in_p, out_p]

Reconstruction puts the scales outside the Hadamard, which is what makes the kernel cheap — H is symmetric orthonormal, so the transform lands on activations and never on weights:

W[out, in] = (H128 · Ŵ · H128 * rin[:,None] * rout[None,:]).T

su = rin*s_in ; sv = rout*s_out
xh    = had_blockwise(x * su, -1)
y_pre = xh @ Ŵ                  # trellis matvec, no Hadamard, no scales
y     = had_blockwise(y_pre, -1) * sv

Codebook 1 decode, three instructions:

x = code * 0xCBAC1FED
x = (x & 0x8FFF8FFF) ^ 0x3B603B60
v = f16(x.lo) + f16(x.hi)

A 16×16 tile is 256 codes packed into 16*K int16 words. Code i is the 16-bit window at bit offset i*K, circular — tail-biting, so adjacent codes share 16-K bits. Tile elements sit in a tensor-core permutation, not row-major. The closed-form inverse, for output column c and lane pair (q, rh):

t = 4*(4*(c&7) + q) + 2*((c>>3)&1) + rh
r = 8*rh + 2*q + {0,1}
e = r & 1

Cosine similarity against the unquantized base is a weak test — it tells you the numbers are close, not that the decode is correct. The stronger test is the Shannon bound. For a Gaussian source at rate R, relative Frobenius error cannot beat 2^-R. The Hadamard transform Gaussianizes the weights, and trellis coding then approaches that limit. A decode with a subtle systematic error cannot land within a few percent of the Shannon limit at precisely the rate the container stores.

Keeping the experts in trellis form is not only smaller — it is the difference between fitting and not fitting. On a 32 GB machine the expanded path drives the system into swap; the native path leaves room for KV cache.

The kernel was bit-exact and the decode sat on the Shannon bound, and the model still emitted pure token salad. The cause was not in the trellis at all: escha stores RMSNorm weights centred on zero, as w - 1. Passing them through untouched left every norm scaling by ≈0 instead of ≈1.

tensor                        escha    base   |e-b|  |e+1-b|
layers.0.input_layernorm      0.031   1.031   1.004    0.004
layers.3.self_attn.q_norm     0.325   1.325   1.004    0.004
final model.norm              1.628   2.628   1.008    0.008
layers.0.linear_attn.norm     0.884   0.884   0.000    1.000   <-- exception

101 tensors carry the offset; the 30 linear_attn.norm tensors — the gated norm inside the GDN block — do not. The residual after adding 1 back is pure bf16 rounding. Effect on the first token of "1 2 3 4 5 6 7 8":

Apple M4, 10 GPU cores, 32 GB unified memory, macOS 27.0, Xcode 26.0.1, higgs 1.6.0. The work lives on the nightly branch — Homebrew and crates.io track upstream, so build from source. The native trellis path is the default; no flag is needed.

git clone -b nightly https://github.com/dusterbloom/higgs
cd higgs && cargo build --release -p higgs

# add the checkpoint to ~/.config/higgs/config.toml, then:
./target/release/higgs serve

curl -s http://127.0.0.1:9000/v1/completions \
  -H 'Content-Type: application/json' -H 'Authorization: Bearer higgs' \
  -d '{"model":"escha-35b-a3b","prompt":"1 2 3 4 5 6 7 8",
       "max_tokens":8,"temperature":0,"logprobs":true,"top_logprobs":3}'

HIGGS_ESCHA_NATIVE=0 selects the expanded affine path for comparison. higgs doctor reports the resident estimate for whichever mode is active, reading the per-projection trellis rate from quantization_config.layer_meta. The fidelity numbers come from tools/escha_forensics.py; the throughput table from a TTFT/inter-token harness over /v1/completions with unique random prompts so the prefix cache cannot serve them.

Two traps if you benchmark an MoE this way. Warm up with enough tokens to route to most experts — 256 tokens touches a handful of 256, and every later run is then still paging weights in. And reject runs that hit EOS early: a 13-token generation measures decode over twelve intervals and is not comparable to a 128-token one. Both corrupted our first published numbers.