Best Local LLM for Coding on Mac (October 2026)

The picks by RAM tier

Each pick is the strongest coding model that fits the tier and still runs fast enough for an agent loop on that tier’s usual Mac. The speed column is for the Mac named beside it. The LLMCheck Score is the index’s 0–100 composite of capability, speed, memory and licence as of 24 October 2026; it is not a coding score, so the SWE-bench column carries the coding evidence, with the harness that produced it.

Only one figure in this table is measured: Qwen 3.6-35B-A3B on a 32 GB Mac mini M6 (a community run, MLX 4-bit). The others are the index’s bandwidth estimates for those exact Macs, and each section below quotes the measured runs that exist on other chips.

How to read the SWE-bench numbers

SWE-bench Verified asks a model to resolve 500 real GitHub issues. Each vendor runs it inside its own agent harness, and the harness moves the score by several points. Kwaipilot shows how much: in its own run with Claude Code as the harness, Qwen 3.6-35B-A3B scored 64.4, about 9 points below the 73.4 that Qwen reports from its in-house scaffold (KAT-Coder card). So compare scores within one vendor’s table, not across this list.

All of these are vendor runs on full-precision weights. A 4-bit or 2-bit build on a Mac may score lower. SWE-bench Pro is harder to compare still: scores from a vendor’s own scaffold run roughly 15–20 points above Scale’s standardized SEAL leaderboard, so this guide quotes Pro scores only with their harness and never next to a SEAL figure.

16 GB: Mellum2.1

JetBrains released Mellum2.1-12B-A2.5B-Thinking on 8 October 2026 (announcement). It is an Apache 2.0 thinking model built for coding agents: 12B parameters in total, 2.5B active per token, 128K context. Reading only 2.5B parameters per token makes it fast for its size: estimated~55 tok/s estimated on the 16 GB Mac mini M6. A 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.

It is the speed pick, not the strongest coder per gigabyte. JetBrains reports 47.0 on SWE-bench Verified and 82.0 on LiveCodeBench v6, on its Pi harness, where Qwen3.5-9B scored 50.0. The official Q4_K_M is 8.07 GB and the MXFP4_MOE file 7.03 GB, so either leaves room for a long context on 16 GB.

Alternative: Xiaomi’s MiMo-V2.6-Distill-Qwen-9B (MIT) reports higher coding scores, 61.1 on SWE-bench Verified and 44.6 on SWE-bench Pro (avg@3, scaffold not named). Xiaomi publishes it as a research checkpoint for agentic reinforcement learning rather than a finished assistant. It is a dense 9.4B model, so it reads every weight on every token: estimated~22 tok/s estimated on the 16 GB Mac mini M6, from a 5.84 GB Q4_K_M. Pick it when answers matter more than speed. The 16 GB guide covers the general-purpose picks for the same Macs.

24–32 GB: North Mini Code, Qwen 3.6-35B-A3B or KAT-Coder-V2.5

This is where the index’s leaders start to fit. All three, and Recursive Flint below, are Apache 2.0 mixture-of-experts models with 2.5–3B active parameters; on the leaderboard they rank #1 (Qwen 3.6-35B-A3B), #2 (Flint), #3 (KAT-Coder-V2.5) and #5 (North Mini Code 1.0). The choice comes down to file size, and to which agent harness you use.

On an M5 Max the three established models are all measured: North Mini Code and Qwen run at about 120 tok/s, KAT-Coder at 89 on a mixed 4- and 8-bit OptiQ build, which reads more bytes per token. Flint’s M5 Max figure is an estimate (below). On the Mac mini M6 only Qwen’s figure is measured. North Mini Code’s slowest measured run is 34.2 tok/s on a base M5 (community, oMLX 4-bit), which anchors its M6 estimate low, so treat that cell as a floor.

North Mini Code 1.0 is the 24 GB pick. Cohere released it on 9 June 2026: 30.5B parameters, 3B active, 256K context (model card). Cohere reports 67.6 on SWE-bench Verified with SWE-agent v1.1.0, and 40.2 on SWE-bench Pro with the same scaffold rather than SEAL. Community oMLX runs measured community120 tok/s on an M5 Max and community70 tok/s on an M5 Pro. Its 19 GB Ollama build is the smallest of the three, and it has an official library entry. On 24 GB that still leaves little room: close other heavy apps, keep the context modest, and see the 24 and 32 GB guide for raising the GPU memory limit.

Qwen 3.6-35B-A3B is the 32 GB pick and the index’s best model for any Mac with 32 GB or less (#1 overall, Score 81). Qwen reports 73.4 on SWE-bench Verified with its own scaffold. It is also the most-measured model in the index: 64 tok/s community-measured on a 32 GB Mac mini M6, 118 tok/s published on an M5 Max (Liquid AI’s llama.cpp baseline, Q4_K_M) and about 126 community-measured there with MLX (oMLX run). Ollama’s qwen3.6:35b-a3b is 23–24 GB, comfortable on 32 GB and tight on 24.

KAT-Coder-V2.5 is Kwaipilot’s agentic fine-tune of that same Qwen model; the open-weight “Dev” release keeps its 35B/3B-active shape (model card). In Kwaipilot’s own Claude Code run it scored 69.4 on SWE-bench Verified against 64.4 for the base model, and 46.0 against 40.6 on SWE-bench Pro (same vendor harness, not SEAL). A community oMLX run measured community89 tok/s on an M5 Max (OptiQ 4-bit), below the 117 the index had estimated before that run. Try it if your workflow already runs through Claude Code or a similar harness. It has no Ollama library entry; the commands are under install.

Recursive Flint, new on 21 October, is the one to try next to them on 32–48 GB. It is a 39.8B mixture-of-experts with about 2.5B active, Apache 2.0, built for coding agents and always reasoning before it answers (model card). Recursive reports 74.2 on SWE-bench Verified with mini-swe-agent, level with Qwen’s 73.4 on a different harness, and in the same llama.cpp harness on a 48 GB MacBook Pro M5 Pro it ran 92.4 tok/s against Qwen’s 81.96 (community, Q4_1 against Q4_K_M). Its M5 Max figure is an estimate floored by a run on the cut-down 36 GB M5 Max. Ollama’s flint is 23 GB; on 24 GB use an 18 GB 3-bit build and a short context. Its scores are a week old and all its maker’s, so it does not replace the picks yet. Setup, RAM and every measured run are in Recursive Flint on a Mac.

The dense option: Qwen3.8-27B

A dense 27B model reads every weight for every token, so it runs several times slower than the 3B-active models above on the same Mac, but it packs more capability into the same memory. Qwen3.8-27B (Apache 2.0, released 14 August 2026) is the index’s strongest dense model by capability: 46/50 against 38 for Qwen 3.6-35B-A3B; it ranks #14 (Score 71). In Qwen’s own table it scores 61.7 on SWE-bench Pro against 53.5 for Qwen 3.6-27B, with the Claude Code harness on Qwen’s corrected task set: a vendor scaffold, not SEAL (model card). Its predecessor Qwen 3.6-27B (#21, Score 70) is the one with a published SWE-bench Verified score, 77.2.

Speed decides where it makes sense. It runs at community9 tok/s community-measured on a 24 GB Mac mini M6 (the 32 GB model has the same 170 GB/s), too slow for an agent loop that reads and writes thousands of tokens per step. It reaches sourced17 tok/s published on an M5 Pro and estimated~29 tok/s estimated on an M5 Max, and the index lists sourced48 tok/s published on an M5 Ultra, the lower median of four plain-decode runs (BGR’s review measured about 55 at Q4_K_M in LM Studio). On a Max or an Ultra it is a strong choice for long sessions where quality matters more than turnaround. Ollama’s qwen3.8:27b is 18 GB, so it fits a 24 GB Mac.

64 GB: Qwen3-Coder-Next

Qwen3-Coder-Next is Alibaba’s coding-only mixture-of-experts: 80B parameters, 3B active, 256K context, Apache 2.0, trained for agent CLIs such as Claude Code, Qwen Code and Cline (model card). Qwen’s chart gives it 70.6 on SWE-bench Verified and 44.3 on SWE-bench Pro, both with SWE-Agent (the Pro figure is a vendor scaffold, not SEAL). In March it led this guide, and it remains the dedicated coding model to run on 64 GB.

Ollama’s qwen3-coder-next download is 52 GB (Q4_K_M). The index’s minimum is 48 GB from its 0.57 GB-per-billion rule, but with a 52 GB file 64 GB is the practical floor. The index estimates estimated~49 tok/s estimated on a 64 GB Mac mini M5 Pro, estimated~44 tok/s estimated on an M4 Pro and estimated~84 tok/s estimated on an M5 Max. No measured Mac run is in the index yet.

The other way to use 64 GB is the 32 GB pick at higher precision. Qwen 3.6-35B-A3B at Q8_0 is a 39 GB download in Ollama, and a community run measured 92.9 tok/s on an M5 Max (llama.cpp, 400 tokens).

96–128 GB: Inkling-Small

Thinking Machines’ Inkling-Small (Apache 2.0) is a 276B mixture-of-experts with 12B active parameters and image input (model card). Its 80.2 on SWE-bench Verified, on a bash-only harness, is the highest vendor-reported figure in this guide; it adds 55.9 on the public SWE-bench Pro set, also vendor-run. To fit, it has to run at about 2 bits: Unsloth’s UD-Q2_K_XL GGUF is 87.9 GB, and the index estimates estimated~42 tok/s estimated on an M5 Max at Q2_K. The vendor’s scores are for full-precision weights, and a 2-bit build gives some of that back. There is no Ollama library entry; use the Unsloth GGUF in llama.cpp or LM Studio.

Mistral Medium 3.5 reports 77.6 on SWE-bench Verified (harness not stated). It is a dense 128B model, so it is slow: Apple’s ML research team published 7.70 tok/s on an M5 Ultra and 4.95 on an M3 Ultra at native FP8 with an 8K context (Apple ML Research), and the index estimates estimated~7 tok/s estimated on an M5 Max at Q4_K_M (Ollama’s build is 80 GB). That suits a one-off code review, not an agent loop. Its modified MIT licence excludes companies above a revenue threshold.

The index’s all-round pick for 128 GB, Qwen3.8-Flash-Next (community46 tok/s community-measured on an M5 Max), carries a licence condition that matters here: a business that sells a commercial AI coding or office assistant needs a separate licence from Qwen, though internal use is exempt (Qwen Community licence).

Above 128 GB

MiMo-V2.6-Flash (Score 78, MIT), the index’s pick for every Mac with 192 GB or more, needs at least 170 GB. It runs at community62 tok/s community-measured on an M5 Ultra and community59 tok/s community-measured on an M3 Ultra (MLX 4-bit). At 512 GB, Moonshot’s 1T-parameter Kimi K2.7 Code fits at about 3 bits (estimated~27 tok/s estimated on an M5 Ultra). The M5 Ultra vs M3 Ultra vs M5 Max comparison covers what else fits in 256 and 512 GB.

Install it and connect your editor

1. Install Ollama. Use Homebrew or the Mac app, not the Linux install script. Version 0.40.11 is current (24 October); Flint needs 0.40.8 or later. Since 0.40.0, Ollama runs models whose architecture its MLX runtime supports on MLX by default on Apple Silicon (release notes).

brew install ollama
brew services start ollama
# or the Mac app: brew install --cask ollama-app

2. Pull the model for your tier. Every library tag below was checked on ollama.com on 24 October.

ollama pull north-mini-code-1.0     # 19 GB, 24 GB Macs
ollama pull qwen3.6:35b-a3b         # 23–24 GB, 32 GB Macs
ollama pull flint                   # 23 GB, 32 GB Macs (Recursive Flint)
ollama pull qwen3.8:27b             # 18 GB, dense
ollama pull qwen3-coder-next        # 52 GB, 64 GB Macs
# no library entry: pull the GGUF from Hugging Face
ollama pull hf.co/bartowski/Kwaipilot_KAT-Coder-V2.5-Dev-GGUF:Q4_K_M
ollama pull hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:MXFP4_MOE

3. Give it enough context. Ollama’s default context window is 4,096 tokens (Ollama FAQ), and an agent that reads source files fills that in one step. Start the server with a larger window, as memory allows (if you used brew services, stop it first with brew services stop ollama):

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

For the Mac app, set the same variable with launchctl setenv and restart the app. A longer context costs memory on top of the model file, which is one more reason to leave headroom on 24 GB.

4. Point your editor or agent at it. Ollama serves an OpenAI-compatible API at http://localhost:11434/v1, which Continue, Zed and most agent tools accept. For aider (docs):

export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model ollama_chat/qwen3.6:35b-a3b

LM Studio finds the same models by name and also runs their MLX builds. The local coding assistant guide walks through the editor setup step by step.

Frequently Asked Questions