Best Local LLM for a 16GB Mac (October 2026)

The picks by job

The tier pick matches the index’s 16 GB tier: the best-ranked model that reaches 15 tok/s on the tier’s reference Mac, the 16 GB Mac mini M6, and has a standard Mac runtime (the rule). That ranking weighs capability first, with a speed bonus capped at 15 points. This is why Gemma 4 12B wins the tier although GPT-oss 20B has the higher LLMCheck Score. GPT-oss’s lead comes from its speed component (25 points to 16); on capability it trails, 22/50 to 30/50. The other rows each answer a narrower question. Scores are as of 18 October 2026.

The 16 GB Mac mini M6 is the binned part, at 153 GB/s rather than the 170 GB/s of the 24 and 32 GB models, so every figure in that column is an estimate from the index’s bandwidth model. Measured runs on other chips are quoted in each section with their source.

Best all-round: Gemma 4 12B

Google’s Gemma 4 12B is a dense 11.95B model that takes text, image, audio and video input, with a 256K context window, under Apache 2.0 (model card). Google’s own table puts it at 77.2% on MMLU Pro, 78.8% on GPQA Diamond and 72.0% on LiveCodeBench v6. Those are vendor-reported scores, but they sit close to the Gemma 4 26B-A4B (82.6%, 82.3%, 77.1%), which needs at least 18 GB.

It is small enough to leave real headroom. Google’s QAT Q4_0 GGUF is 6.98 GB plus a 0.18 GB vision projector; Ollama’s gemma4:12b is 7.7–8.0 GB.

The index estimates it at estimated~17 tok/s on the 16 GB Mac mini M6. The closest measured run: about 19 tok/s community-measured on a 32 GB Mac mini M6 (QAT build in LM Studio, 18.0–18.8 across five prompts; HDZucht’s benchmark repo). That is reading speed, not instant. On slower 16 GB Macs it falls under the index’s 15 tok/s floor; see every 16 GB Mac.

Fastest capable reasoner: GPT-oss 20B

OpenAI’s GPT-oss 20B is a mixture-of-experts model: 21B parameters in total, 3.6B active per token, Apache 2.0. OpenAI post-trained it in MXFP4 so that it runs “within 16GB of memory” (model card). Reasoning effort is adjustable (low, medium, high).

Because only 3.6B parameters are read per token, it runs more than twice as fast as Gemma 4 12B on the same Mac: estimated~41 tok/s on the 16 GB Mac mini M6. A community run measured 45 tok/s on a 32 GB Mac mini M6 (LM Studio, quant not stated), and tbreak’s review published 107.5 tok/s on a Mac Studio M5 Max in Ollama.

The catch is size. The MXFP4 GGUF is 12.1 GB and Ollama’s gpt-oss:20b is 14 GB, the tightest fit of any pick on this page. Close other heavy apps, keep the context modest, and read the GPU memory limit below. On the index’s capability score Gemma 4 12B is the stronger model (30/50 to 22/50). Pick GPT-oss 20B when answers need to arrive fast.

Best for coding agents: Mellum2.1

JetBrains released Mellum2.1-12B-A2.5B-Thinking on 8 October 2026 (announcement). It is an Apache 2.0 thinking model for coding agents: 12B total, 2.5B active, 128K context.

JetBrains reports 47.0 on SWE-bench Verified and 82.0 on LiveCodeBench v6. The SWE-bench figure comes from its own run on the Pi v0.73.1 harness, which put Qwen3.5-9B at 50.0, so it is a vendor scaffold figure, not a standardized one. Mellum2.1’s case is speed per gigabyte. The official Q4_K_M is 8.07 GB, and the index estimates estimated~55 tok/s on the 16 GB Mac mini M6. One community run measured about 50 tok/s on a 16 GB Mac mini M4 (Q4_K_M, Homebrew llama.cpp, source), on a build from before the fix below.

Alternatives. Xiaomi’s MiMo-V2.6-Distill-Qwen-9B (MIT) is a dense 9.4B model. Xiaomi reports 61.1 on SWE-bench Verified and 44.6 on SWE-bench Pro, on an agent scaffold its card does not name. The card presents it as a research checkpoint for agentic reinforcement learning, not a polished assistant. Its Q4_K_M is 5.84 GB, and the index estimates it at estimated~22 tok/s on the 16 GB M6. IBM’s Granite 4.2 8B (Apache 2.0) comes with IBM’s own GGUF (Q4_K_M 5.35 GB) and MLX builds; IBM reports 47.67 on SWE-bench Verified, scaffold not stated. The 24B dense coders (Devstral Small, Mistral Small 3.2) also fit in 16 GB, but at estimated~8 tok/s on the 16 GB M6 they are too slow for agent loops.

A 27B model in 7 GB: the Bonsai models

PrismML’s Ternary Bonsai 2 27B (Apache 2.0, 17 September 2026) is Qwen3.8-27B rebuilt with ternary weights. The PQ2_0 file is 7.21 GB, the PTQ1_0 file 5.95 GB, and an optional 0.63 GB projector adds image input. Its capability score, 37/50, is the highest of any model in the index that fits in 16 GB.

PrismML reports that it keeps 98.2% of the full-precision model’s average across 14 benchmarks (EvalScope and vLLM on NVIDIA H100, thinking mode, vendor-run). The loss is concentrated in agentic coding. On SWE-bench Verified it scores 60.8 against 80.6 for Qwen3.8-27B (mini-swe-agent, vendor-run).

Speed is the open question on a 16 GB Mac. PrismML’s published figures are 46.8 tok/s on an M5 Max and 28.1 on an M5 Pro, in its llama.cpp fork on Metal (tg128; whitepaper and model card). Ternary decoding is limited by compute rather than memory bandwidth, so the index does not extrapolate those figures to the M1–M4 or M6 chips that 16 GB Macs use. No figure has been published for those chips yet. That is the only reason it is not the headline pick.

The runtime story moved this month:

• PrismML’s llama.cpp fork runs the main PQ2_0 and PTQ1_0 files.
• Upstream llama.cpp b11556+ (PR #29600, merged 11 October) runs only the Q2_0 packing, which is published in PrismML’s separate -dev repo.
• MLX: the 8.60 GB 2-bit pack loads in mlx-vlm 0.7.8.
• Ollama: bonsai-2:27b (8.3 GB) uses the q2_0 type added in Ollama v0.40.6, a stable release since 16 October.

The older Bonsai 27B (July, 1-bit, 3.8 GB) still has the higher LLMCheck Score, 72, but a lower capability score (33/50). Its published figures are 66.4 tok/s on an M5 Max, 44.2 on an M5 Pro and 26.0 on an M4 Pro (PrismML llama.cpp fork, tg128). That M4 Pro figure is the nearest any Bonsai model has to a 16 GB-class chip.

Smallest and fastest

If the job is quick answers, summaries or autocomplete, a small model leaves most of the 16 GB free:

• Nanbeige4.2-3B (Score 68) scores highest among the index’s models of 4B parameters or fewer: estimated~64 tok/s on the 16 GB Mac mini M6.
• Gemma 4 E4B adds image and audio input at estimated~49 tok/s; Gemma 4 E2B is the fastest model the index has a figure for on that Mac, at estimated~91 tok/s.
• Maple Preview 20B-A1B (MIT) is a ternary mixture-of-experts with 1B active. DeepGrove reports sourced169 tok/s on an M4 Mac mini with the exact output head (218 with its approximate “flash head”), vendor-reported in its own mlx-lm fork. It runs only through DeepGrove’s forks of mlx-lm and llama.cpp, and its card says it had minimal post-training for agentic tasks.
• Ternary Bonsai 2 9B is 2.42 GB with vision; PrismML published 76.5 tok/s on an M5 Pro.

What doesn’t fit in 16 GB

The index sets these models’ minimums from their 4-bit builds plus about 2 GB (rule), so the models people most often ask about need more than 16 GB. Smaller 3-bit GGUFs exist (Unsloth’s UD-IQ3_XXS is 13.2 GB for Qwen 3.6-35B-A3B and 9.0 GB for LFM2.5-24B-A2B), but the index has no Mac run of them:

2-bit builds of the 35B models exist (Unsloth’s UD-IQ2_M of Qwen 3.6-35B-A3B is 11.5 GB). The index has no Mac run that used one, and their quality loss is unmeasured, so it does not set minimums from them. If those models are the reason you want local AI, the next tier is the answer. Qwen 3.6-35B-A3B, the index’s best pick at 24 and 32 GB, ran at 64 tok/s community-measured on a 32 GB Mac mini M6. The 24–32 GB guide covers that tier.

The GPU memory limit on a 16 GB Mac

macOS does not let the GPU wire all of unified memory. Metal reports the cap as recommendedMaxWorkingSetSize, and llama.cpp prints it when a model loads. On a 16 GB Mac the usable share is well under 16 GB, which is why a 12 GB model such as GPT-oss 20B is at the edge while 7–8 GB models are comfortable.

If a model fits in RAM but runs slowly, MLX’s documentation suggests raising the system wired-memory limit (mlx-lm README, macOS 15 or newer):

sudo sysctl iogpu.wired_limit_mb=N

N should be larger than the model in megabytes and smaller than the Mac’s memory. The setting lasts until you restart. Leave a few gigabytes for macOS. The rule of thumb behind the index’s minimums is about 0.57 GB per billion parameters at Q4_K_M, plus about 2 GB.

Every 16 GB Mac, model by model

Same three models, every 16 GB configuration in the index, fastest memory first. Each Mac links to its own page.

Gemma 4 12B is dense, so it reads all 12B weights for every token and slows in step with memory bandwidth. On the M4 Mac mini and the M1–M4 MacBook Airs it drops under the index’s 15 tok/s floor, so their pages lead with a faster model: GPT-oss 20B, which reads only its 3.6B active parameters per token, on the M1–M3 Airs, and Nanbeige4.2-3B on the M4 machines. The 200 GB/s Mac mini M2 Pro, at ~22 tok/s estimated, keeps Gemma 4 12B. If you own one of those Macs, follow its page rather than the tier pick.

Install commands

Every tag below exists in the Ollama library as of 18 October 2026. Since v0.40, Ollama runs architectures that MLX supports on MLX by default on Apple Silicon (release notes).

ollama run gemma4:12b        # 7.7–8.0 GB
ollama run gpt-oss:20b       # 14 GB
ollama run granite4.2:8b     # 5.3 GB
ollama run bonsai-2:27b      # 8.3 GB, needs Ollama 0.40.6+

Mellum2.1 has no library tag. JetBrains’ GGUF card documents ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M; the Metal caveat above applies to whatever llama.cpp your Ollama build bundles. LM Studio users can search the same names; the community MLX 4-bit build of Gemma 4 12B is 6.74 GB.

Frequently Asked Questions