Maple-Preview

Maple-Preview

A 20B ternary-weight reasoning model that activates about 1B parameters per token. Built for fast on-device use, with a 5.31 GB checkpoint and 131,072 token context. A preview that is weaker on agent tasks.

Made by deepgrove on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Maple-Preview is an open-source reasoning model from DeepGrove, called 20B-A1B because it has 20B parameters and uses about 1B of them for each token. Its weights are ternary, and the card lists a 5.31 GB checkpoint. It has a 24-layer design with 256 experts, 8 of them active, and a context of 131,072 tokens. The maker presents it as a preview aimed at raw reasoning.

Who it suits: It suits developers and researchers who want a small, fast reasoning model that can run on a laptop-class machine, and who accept that it is an early release.

Industry | Who uses it | How they use it | Example
On-device AI | App developers | Run a reasoning model locally | The card reports 218 tok/s on an M4 Mac mini
Education and research | Math and science learners | Work through hard problems step by step | The card says it solves IMO-level problems
Model research | Efficiency researchers | Study ternary weights and sparse experts | The card describes a 256-expert design with 8 active

You can skip it if you need an agent that calls tools, because the card says this preview may underperform on agentic benchmarks.

Where to use it:

• A CUDA machine, through the Transformers code that comes with the repository
• An Apple Silicon Mac, through a separate on-device runtime that the card mentions but does not name
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Local reasoning help | Developers | Step-by-step answers from a small, quick model
Math and logic practice | Students and teachers | Worked solutions to hard problems
Speed and memory studies | Researchers | A model that sits on the card's speed and memory frontier

How to set it up: You need Python and, for the Transformers route, a CUDA GPU.

• Python with the Hugging Face tools
• For the Transformers code, a CUDA environment with Triton and FlashAttention
• For Apple Silicon, the separate runtime behind the card's Mac result
• About 40.4 GB for the BF16 weights listed by Hugging Face, while the card names a 5.31 GB checkpoint

1. Install the Hugging Face tools with Python.
2. Download the repository files with the second command below.
3. Pick the route: the Transformers code on CUDA, or an on-device runtime.
4. Prompt it with a reasoning question.

pip install -U huggingface_hub
hf download deepgrove/maple-preview

How to use it: The card gives no run command. The Transformers code in the repository is meant for a compatible CUDA setup. The Mac figure on the card comes from a different runtime, so check which one you are using before you compare speeds.

Tool | What it does
Transformers | Loads the model on a compatible CUDA setup
Triton and FlashAttention | Needed by the included Transformers code
On-device runtime | Produced the card's Apple Silicon speed result
hf download | Fetches the repository files

Example: You load the model on a CUDA machine and ask it a hard math question. It reasons through the problem and writes out its steps. On the maker's test, a Mac mini M4 reached 218 tok/s with a separate runtime.

For newcomers and experts: Think of it as a small, quick thinker that was built to fit on everyday hardware. A first small try is one math question on the CUDA route.

It mixes sparse experts, so only 8 of 256 run for each token, with ternary weights. The attention pattern is 3:1 SWA-512:GA. The card claims reasoning at the top of its weight class and speeds 5 to 16 times faster than Gemma 4, Qwen3.5 and gpt-oss. These are the maker's numbers, and the charts are images that are not readable here.

Load the model on CUDA or an on-device runtime
Send a reasoning question
Only 8 of 256 experts run per token
The model writes its reasoning steps
Read the answer and check it

Good to know: The card lists these properties.

Title: Maple-Preview at a glance
Property | Value
Model | 20B-A1B
Speed on an M4 Mac mini | 218 tok/s
Checkpoint | 5.31 GB
Context | 131,072 tokens
Layers | 24
Experts | 256, 8 active

• Limits: little training went into agent tasks, and its general reinforcement learning was small in scale
• Plans: the maker intends more training before a full release
• Language: English
• Other versions: other people have published 16 quantized and 3 fine-tuned versions
• License: MIT
• Cost to run: none named
• Data it reaches: the files you download and the prompts you run locally
• Not for: agent and tool-calling work, since the card warns about weaker results there

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 20.2B
• Weights: about 40.4 GB in BF16; about 10.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,867
• Likes: 433
• License: mit
• Languages: en
• Quantized versions: 16
• Fine-tunes: 3
• Tags: transformers, safetensors, text-generation, causal-lm, mixture-of-experts, reasoning, ternary, custom-code, conversational

Links

• Model: https://huggingface.co/deepgrove/maple-preview
• Files: https://huggingface.co/deepgrove/maple-preview/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download deepgrove/maple-preview

Then follow the usage in its model card. Nothing in this kit runs by itself.