Maple Preview

Maple Preview is an open source reasoning model from DeepGrove that compresses a 20 billion parameter architecture into a 5.3 gigabyte checkpoint. The trick is ternary weights. Instead of standard floating point values, each weight can only be one of three discrete values. That constraint sounds limiting until you see what it enables. On an M4 Mac mini, Maple Preview runs at 218 tokens per second. On an iPhone, it hits 120 tokens per second. For a model that solves math olympiad problems and graduate level science questions, those speeds are five to sixteen times faster than competing systems in the same weight class. The combination of small footprint and fast inference makes local deployment practical on hardware people already own.

The problem this addresses is practical. Large language models with strong reasoning capabilities usually require expensive cloud compute or high end GPUs. Developers building local applications face a choice between paying for inference or running a weaker model that fits on consumer hardware. Maple Preview lands in a different spot on that curve. It compresses aggressively enough to fit in memory on a laptop or phone while still scoring well on benchmarks that matter for reasoning tasks. You get local inference at interactive speeds without renting a GPU cluster. For applications where latency matters or where data cannot leave the device, that capability changes what is possible.

Under the hood, the architecture is a Mixture of Experts design with 256 experts total and 8 active at any time across 24 layers. The attention mechanism uses a sliding window of 512 tokens on three out of four layers, which keeps memory use reasonable even at the maximum context length of 131,072 tokens. That context window is long enough for entire codebases, long documents, or extended conversations. The checkpoint is packed in BF16 format and weighs in at 5.31 gigabytes. That footprint is remarkably small for a model that competes on reasoning benchmarks with systems several times larger and several times slower.

Benchmark numbers situate Maple Preview at a new Pareto frontier for memory to performance and speed to performance ratios. It scores 75.1 on LCB v6, 87.5 on AIME 2026, 78.8 on HMMT 2026, and 73.5 on GPQA Diamond. Those results demonstrate strong reasoning on math olympiad problems, competition mathematics, and graduate level science questions. The AIME 2026 score in particular is notable because that benchmark tests serious mathematical problem solving, not just text generation. The model solves IMO level problems without external tools or calculator plugins. The GPQA Diamond score shows it handles graduate level scientific reasoning well enough to be useful for researchers and students working through technical material.

Running the model requires a compatible environment. The full Transformers implementation uses Triton and FlashAttention under the hood, so a CUDA compatible GPU works. Apple Silicon Macs hit the top speeds mentioned above through native Metal support. You can load the model through the Hugging Face Transformers pipeline with a few lines of Python. It also runs via vLLM or SGLang if you prefer those inference servers for production deployments. The documentation includes examples for each method. No paid API or managed service exists. You download the weights from Hugging Face and run them yourself using whatever infrastructure you control.

The target audience is developers and researchers who need fast local inference for reasoning tasks. If you are building an application that handles math, code, or logic problems and you want to run it on device rather than calling an external API, Maple Preview gives you a foundation that fits in memory and responds quickly. Mobile applications benefit from the 120 tokens per second iPhone performance, which is fast enough for real time assistance without noticeable lag. Desktop applications benefit from the 218 tokens per second Apple Silicon numbers. Cloud deployments benefit from the reduced memory footprint compared to larger models, letting you fit more inference capacity on the same hardware.

One honest limitation is that the model underperforms on agentic benchmarks. DeepGrove focused on raw reasoning and did only small scale general reinforcement learning during training. Multi step planning and tool use were not optimization targets. If your use case involves agents calling external APIs, executing long chains of actions, or coordinating with other systems, you may find Maple Preview less capable than models tuned specifically for those agentic workflows. For pure reasoning and generation tasks where you pose a question and get an answer, though, the speed to quality ratio is hard to beat at this size and price point.

Access is completely free. Maple Preview ships under the MIT license, so you can download the weights from Hugging Face and use them commercially without restrictions. There is no paid tier, no usage limits, no telemetry, and no service to pay for. You run it yourself and own the inference stack. The model card on Hugging Face includes the technical specifications, benchmark results, and code examples to get started. For developers evaluating whether to build on local inference or pay for cloud APIs, Maple Preview offers a reasonable baseline to test against.