Prism ML's Ternary Bonsai 2 Squeezes a 27B Reasoning Model Into 8.6 GB

Prism ML's Bonsai 2 27B compresses a 27B reasoning model to 8.6 GB using ternary weights, retaining 98.2% of FP16 benchmark quality.

·
·
Prism ML's Ternary Bonsai 2 Squeezes a 27B Reasoning Model Into 8.6 GBPRO
  • Prism ML released Ternary Bonsai 2 27B, a ternary-weight 27B model at 8.6 GB total on disk
  • Retains 98.2% of FP16 average across 14 thinking-mode benchmarks, vs 84.1% for conventional IQ2_XXS
  • Uses Hadamard-rotated ternary weights {-1, 0, +1} with FP16 group scales, 1.72 bits/weight true rate
  • Runs at ~47 tok/s on Apple M5 Max, ~130 tok/s on RTX 5090, 262K context
  • Ships MLX 2-bit plus GGUF packings; needs Prism ML's forked kernels or bundled loader
  • Apache 2.0, based on Qwen3.8-27B, includes unquantized vision tower

A 27B reasoning model in an 8.6 GB package

Prism ML has released Ternary Bonsai 2, a 27-billion-parameter model whose language weights use three values: -1, 0, and +1. The complete MLX package occupies about 8.6 GB, including a 0.92 GB FP16 vision tower, while Prism reports an average score of 84.78 across 14 reasoning benchmarks, 1.54 points below the FP16 Qwen3.8-27B baseline.

Custom MLX and CUDA kernels read the packed weights directly without first expanding the full model to FP16. That implementation detail determines whether ternary compression produces a small file or a model that also uses less memory bandwidth during inference.

  • Compact language weights: 5.95 GB using the densest GGUF packing
  • MLX language weights: 7.67 GB
  • Complete MLX package: approximately 8.6 GB with the FP16 vision tower
  • Reported context limit: 262,000 tokens, subject to available memory for the KV cache
  • License: Apache 2.0

Three values per weight

Each compact-format weight group contains 128 ternary values and one shared FP16 scale. A ternary value carries log23, or approximately 1.585, bits of information. Including the group scale raises the theoretical storage cost to about 1.71 bits per weight, while format metadata brings Prism’s measured average to 1.72 bits. That is an idealized 9.3-fold reduction from FP16.

Before quantization, Prism applies an orthogonal Hadamard rotation to blocks of each weight matrix. The rotation spreads large outliers across the block, reducing the error introduced when continuous values are assigned to three levels. The transformed weights are stored offline, and the runtime applies the corresponding rotation to activations. This adds computation but no weight-storage overhead.

Prism applies ternary values across the language model’s embeddings, attention projections, MLP projections, and output head. The separate 0.92 GB vision tower remains in FP16. Those components explain the difference between the 5.95 GB compact language-model file, the 7.67 GB MLX language model, and the complete 8.6 GB multimodal package.

Reasoning survives most of the cut

Prism evaluated the model in thinking mode on an Nvidia H100 using EvalScope and vLLM. The comparison includes the FP16 base model and two conventional low-bit builds derived from the same weights. These results are vendor-reported and have not been independently reproduced in the release materials.

Pro article

This story is for Pro members

You've reached the end of the free preview. Upgrade to AlphaSignal Pro to read the full article - and everything else behind the paywall.

Trending
  • No trending articles

Comments

avatar

Next Reads