Maple-Preview is DeepGrove's 20B-A1B ternary-weight reasoning model, hitting 200+ tok/s on a Mac mini M4. Here's how it works.
Drafted with Claude from source material, checked by automated verification, and reviewed before release. How we make these.
What is Maple-Preview? #
Maple-Preview is an open-weight reasoning model from DeepGrove built around a ternary-weight, mixture-of-experts design. It’s labeled 20B-A1B, meaning it has roughly 20 billion total parameters but activates a much smaller subset (around 1 billion) per token. DeepGrove reports it solves IMO-level math problems and runs at over 200 tokens per second on a Mac mini M4, which the model card claims is 5 to 16 times faster than comparably efficient models like Gemma 4, Qwen3.5, and gpt-oss. It ships under the MIT license.
TL;DR #
Maple-Preview is a 20B-A1B mixture-of-experts reasoning model that uses ternary weights instead of standard 16-bit or 8-bit precision, shrinking the checkpoint to roughly 5.31 GB.- The model runs at 218 tokens per second on an Apple Mac mini M4 using a separate on-device runtime, a speed DeepGrove says beats similarly efficient models by 5 to 16 times. - Architecturally it uses 24 layers and 256 experts, activating only 8 per token, paired with a 3:1 ratio of sliding-window attention to global attention. - It supports a 131,072 token context window, putting it in line with other long-context reasoning models despite its small active-parameter footprint. - DeepGrove positions it as SOTA for its weight class on reasoning benchmarks including LiveCodeBench v6, AIME 2026, HMMT 2026, and GPQA-Diamond, and competitive with larger models. - The release is explicitly a preview focused on raw reasoning, with the model card warning it underperforms on agentic tasks due to minimal post-training in that area. - It’s released under the MIT license, with weights, config, and custom modeling code available on Hugging Face.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
What does “ternary-weight” actually mean here? #
Most LLMs store their weights as 16-bit or 32-bit floating point numbers, or increasingly as 8-bit or 4-bit integers after quantization. A ternary-weight model restricts each weight to one of three values, typically -1, 0, or +1. That’s an extreme form of quantization, and it’s the main reason Maple-Preview’s checkpoint comes in at just 5.31 GB despite having 20 billion total parameters.
The tradeoff is usually accuracy. Squeezing weights down to three possible values throws away a lot of the precision that lets models fine-tune their internal representations. Ternary and binary weight networks have been a research topic for years precisely because they promise huge efficiency gains if you can find a way to preserve model quality. Maple-Preview’s benchmark claims suggest DeepGrove has made real progress on that tradeoff, at least for reasoning-heavy tasks, though the model card is upfront that this is a preview, not a finished general-purpose model.
The practical payoff of ternary weights is memory bandwidth. Smaller weights mean less data to move between memory and compute units, which is often the actual bottleneck in LLM inference, especially on consumer hardware. That’s a big part of why Maple-Preview can hit the speeds it does on a Mac mini rather than a data-center GPU.
How is the model architecture put together? #
Maple-Preview is a mixture-of-experts (MoE) model with 24 layers and 256 experts, of which 8 are active for any given token. MoE architectures let a model have a large total parameter count for storing knowledge while keeping the actual compute per token much lower, since only a fraction of the network fires on each forward pass. That’s the “A1B” in the 20B-A1B naming: 20 billion total parameters, roughly 1 billion active per token.
For attention, the model uses a 3:1 ratio of sliding-window attention (SWA, with a window of 512 tokens) to full global attention (GA). Sliding-window attention limits each token to looking at a fixed-size local window rather than the entire sequence, which is far cheaper to compute. Mixing in a smaller number of global attention layers lets the model still capture long-range dependencies when needed. This hybrid pattern is a common way to support long context windows, in this case up to 131,072 tokens, without paying the full quadratic cost of attention at every layer. Combine the ternary weights, the sparse MoE routing, and the mixed attention pattern, and you get a model architected from the ground up for cheap inference rather than one that’s been quantized after the fact.
How fast is it, and what hardware does that require? #
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
DeepGrove reports 218 tokens per second on an Apple Mac mini M4, using what the model card describes as a separate on-device runtime (distinct from the standard Transformers implementation, which depends on Triton and FlashAttention and targets CUDA GPUs). That’s a notable detail: the flagship speed number is not necessarily the same code path most developers will run out of the box on Hugging Face. Anyone testing Maple-Preview locally should be aware there are two distinct execution paths, one optimized for Apple Silicon and one for CUDA environments.
The headline comparison is that Maple-Preview runs 5 to 16 times faster than “efficient” models like Gemma 4, Qwen3.5, and gpt-oss, according to DeepGrove’s own measurements. Because the checkpoint is only about 5.31 GB, it’s small enough to fit comfortably in unified memory on a machine like the Mac mini M4, which is a meaningfully different deployment target than the multi-GPU servers typically needed for 20B+ parameter dense models.
How good is it at reasoning benchmarks? #
DeepGrove evaluated Maple-Preview using its dense output head across four benchmarks: LiveCodeBench v6 (LCBv6), AIME 2026, HMMT 2026, and GPQA-Diamond. These cover competitive coding, competition math, and graduate-level science question answering, a benchmark mix aimed squarely at measuring reasoning rather than general chat quality or instruction following.
According to the model card, Maple-Preview sets a new point on the Pareto frontier for both memory-to-performance and speed-to-performance, meaning that for its size and speed, its reasoning scores are ahead of other models occupying similar resource budgets. DeepGrove also claims it’s competitive with larger models on these tasks and capable of solving IMO-level math problems, an unusually high bar that’s normally associated with much bigger frontier models.
It’s worth being precise about what “SOTA for its weight class” means here: it’s a claim about performance relative to models of similar size and compute cost, not a claim that Maple-Preview beats the largest frontier reasoning models outright.
Is Maple-Preview good for agentic or general-purpose use? #
Not yet, by DeepGrove’s own account. The model card is explicit that this preview “received minimal post-training for agentic tasks and only small-scale general reinforcement learning.” That means capabilities like tool use, multi-step task execution, or following complex real-world instructions haven’t gotten the same training investment as the raw reasoning benchmarks. DeepGrove frames this as a deliberate sequencing decision: get the reasoning core right first, then layer on general and agentic capability in future training before a full release.
For anyone evaluating Maple-Preview for a project, this matters. A model that solves IMO-level problems isn’t automatically a good fit for, say, an autonomous coding agent or a customer support bot that needs to call APIs reliably. The benchmark strengths and the practical readiness for agentic deployment are separate questions, and right now the gap between them looks intentional rather than accidental.
Frequently Asked Questions #
What does 20B-A1B mean for Maple-Preview?
It means the model has about 20 billion total parameters spread across its mixture-of-experts layers, but only around 1 billion parameters are active for processing any given token, since just 8 of its 256 experts fire per token.
Why is the checkpoint only 5.31 GB for a 20B parameter model?
Because Maple-Preview uses ternary weights, meaning each weight is stored as one of three values instead of the 16 or 32-bit floating point numbers typical dense models use. That drastically cuts storage and memory bandwidth needs.
Can I run Maple-Preview on a Mac?
Remy doesn't write the code. It manages the agents who do. #
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
DeepGrove reports 218 tokens per second on a Mac mini M4 using a separate on-device runtime built for Apple Silicon, distinct from the standard Transformers-based implementation, which is designed for CUDA GPUs with Triton and FlashAttention.
Is Maple-Preview good at general chat and agent tasks?
Not particularly, based on DeepGrove’s own disclosure. The preview was trained mainly for raw reasoning and received only minimal post-training for agentic use cases and small-scale general reinforcement learning, so it may underperform on agentic benchmarks compared to reasoning-focused ones.
What license is Maple-Preview released under?
It’s released under the MIT license, an open license that allows broad reuse, modification, and commercial use of the model weights and code.