Best Local LLM for a 24GB or 32GB Mac (October 2026)

The picks by job

The overall pick matches the index’s 24 GB and 32 GB tiers. It is the best-ranked model that reaches 15 tok/s on the tier’s reference Mac, the Mac mini M6, with a standard Mac runtime (the rule). Every 24–36 GB Mac page in the index leads with it. Scores are LLMCheck Scores as of 18 October 2026.

The two strongest alternatives are Nemotron 3.5 Lightning (Score 79; 1M-token context, OpenMDW licence) and Gemma 4 26B-A4B (Score 78; image input). Both measured in the mid-40s on a 32 GB Mac mini M6 (community runs: 45 and 48 tok/s), and both fit 24 GB more easily than the 35B models.

24 GB or 32 GB: what fits

The index lists a 24 GB minimum for Qwen 3.6-35B-A3B and KAT-Coder-V2.5. That is the floor, not a comfortable fit. On a 24 GB Mac the files that matter sit close to what macOS will let the GPU use (see below). The sizes below come from the Hugging Face and Ollama listings as of 18 October 2026:

The labels are LLMCheck’s guidance from file size against total memory, not measurements. “Tight” and “very tight” mean you should expect to raise the GPU memory limit, close other heavy apps and keep the context window modest. The practical reading: on 24 GB, choose your build deliberately. Ollama’s default Qwen 3.6 tag will not fit, and a 3- to 4-bit GGUF or LFM2.5 is the safer daily driver. On 32 GB, everything in this guide runs at 4-bit with room for context. The measured Mac mini M6 figures above come from 32 GB machines, except Qwen3.8-27B’s, which was a 24 GB Mac mini M6.

Coding: Qwen 3.6 vs KAT-Coder vs North Mini Code

All three are Apache 2.0 mixture-of-experts models with about 3B active parameters. Each vendor measured SWE-bench on its own harness, so read the table across a row, not down the columns as a ranking:

Sources: the Qwen, Kwaipilot and Cohere model cards. Speeds: Liquid AI’s published baseline on its LFM2.5 card (4K-token input), and single community oMLX runs at 1K context (Qwen, KAT, North), all with speculative decoding off.

Two details make the comparison fairer than the headline numbers suggest:

• KAT-Coder-V2.5 is a fine-tune of Qwen 3.6-35B-A3B. Kwaipilot re-ran its base on the same Claude Code harness and got 64.4, five points below KAT’s 69.4. Kwaipilot notes that its Qwen result is about 10 points under Qwen’s own figure, which it attributes to harness differences. On a like-for-like harness, then, the fine-tune adds about five points.
• The SWE-bench Pro figures are all vendor scaffolds. Vendor scaffolds typically land 15 to 20 points above Scale’s standardized SEAL runs, so none of these is a SEAL score.

The verdict. On a 32 GB Mac, run KAT-Coder-V2.5 for agentic coding. It beat its own base by five points on the one harness that tested both, and community runs measured it at 89.3 tok/s on an M5 Max and 74.2 on an M4 Max. Qwen 3.6-35B-A3B remains the better all-rounder: a general chat and coding model that ranks higher overall (81 to 79) on its faster measured speed. On a 24 GB Mac, North Mini Code is the practical coder. Its 4-bit build is the smallest of the three, it has an official Ollama entry, and community runs measured 119.7 tok/s on an M5 Max and 69.8 on an M5 Pro.

ollama run north-mini-code-1.0     # 19 GB, Q4_K_M
ollama run qwen3.6:35b-a3b         # 23–24 GB, 32 GB Macs
ollama run hf.co/bartowski/Kwaipilot_KAT-Coder-V2.5-Dev-GGUF:Q4_K_M   # 21.4 GB

KAT-Coder has no Ollama library entry, so the last line pulls the community GGUF straight from Hugging Face. On MLX, the 21.9 GB mlx-community/KAT-Coder-V2.5-Dev-OptiQ-4bit loads under stock mlx-lm, according to its card. North Mini Code’s MLX builds run through mlx-vlm, which has the cohere2_moe architecture; mlx-lm does not, as of 18 October. For a full breakdown by RAM tier, see the best local LLM for coding on a Mac.

Fast agents and tool use: LFM2.5-24B-A2B

Liquid AI released LFM2.5-24B-A2B on 13 October 2026 and calls it the last and largest model of the LFM2.5 family. It has 24B parameters with 2.45B active, a 128K context, and it always reasons before answering. Liquid’s card reports (vLLM, vendor-run):

• BFCLv4: 65.01
• IFEval: 96.75
• ToolSandbox: 80.71
• SWE-bench Verified: 51.00, on Liquid’s OpenCode harness. On that harness Liquid’s card puts Qwen 3.6-35B-A3B at 66.20, so LFM2.5 is not the coding pick.

Its strength is footprint and speed. Liquid published 184 tok/s on an M5 Max (llama.cpp Q4_K_M, 4K-token input) with 15 GB in use. Community runs are lower:

• 59.9 tok/s on a 24 GB M4 (MLX 4-bit, 1K context)
• 74.2 on a 32 GB base M5 (4K)
• 89.7 on an M4 Max (5-bit, 4K)

These runs disagree more than memory bandwidth explains, because runtimes and quants differ. To plan for a 24 GB Mac, use the M4 run. It is the one model on this page that sits comfortably in 24 GB with room for a long context.

Two practical notes:

• Licence: the LFM Open License allows commercial use only for organisations under US$10M in annual revenue.
• MLX: the official 4-bit build (13.6 GB) requires mlx-lm 0.32.0 or later. Its card warns that earlier versions load the model but route the experts incorrectly. ollama run lfm2.5:24b pulls the 15 GB Q4_K_M.

Vision: MiniCPM-V 4.7 35B-A3B

OpenBMB released MiniCPM-V 4.7 35B-A3B on 12 October 2026 under Apache 2.0. It takes single images, multiple images and video, with a 256K context. OpenBMB’s comparison table was run in instruct mode, with no harness named:

• MMMU: 80.22, against 77.44 for Qwen 3.6-35B-A3B
• OCRBench: 91.20, against 86.00
• Video-MME: 76.40, against 75.70

On text-only benchmarks it trails Qwen slightly on MMLU-Pro and SuperGPQA.

Community oMLX runs measured 100.2 tok/s on an M5 Max (MXFP4) and 48.2 on an M4 Pro (5-bit), both with speculative options off. For vision you also need the 1.12 GB projector, which puts Q4_K_M at about 22.3 GB: a 32 GB model. On 24 GB, the IQ4_XS build (18.7 GB plus the projector) is the realistic option.

• llama.cpp: supported since b11551 (PR #29416). A fix for image-marker positions, PR #30510, was still open on 18 October, so image prompts may misbehave on mainline builds.
• MLX: mlx-vlm 0.7.8 or later; stock mlx-lm does not load it.
• Ollama: ollama run openbmb/minicpm-v4.7:35b-a3b (22 GB). This is OpenBMB’s own namespace, linked from its model card, not the official library.

If 24 GB is firm, Gemma 4 26B-A4B is the easier vision model. Its QAT build is 16 GB in Ollama, and it measured 48 tok/s on a 32 GB Mac mini M6 (community, LM Studio) and 52.2 on the same chip with MLX 4-bit (community, SwiftLM). Vision picks for every memory size are in the best local vision model for Mac.

The dense option: Qwen3.8-27B

Qwen3.8-27B has the highest capability score of any model that fits in this tier (46/50), with image and video input. It is dense, so every token reads all 27.8B parameters. On the Mac mini M6 that means 9.42 tok/s, community-measured on a 24 GB machine (LM Studio, 4-bit QAT MLX, source). That is why the index’s per-Mac pages list it as “most capable (slow)” rather than the pick. It earns its place on a faster chip: the index estimates estimated~15 tok/s on a 24 GB M5 Pro and estimated~22 tok/s on the 36 GB Mac Studio M5 Max. Use it for careful one-shot work, not for agent loops.

Every 24–36 GB Mac

Every configuration in the index from 24 to 36 GB picks Qwen 3.6-35B-A3B. How the three most useful models scale with each Mac’s memory bandwidth:

LFM2.5’s estimates do not rise smoothly with bandwidth, because its published and community runs disagree (above). Where a measured run exists for a chip, the cell shows that run rather than a scaled estimate. To see how far the index’s estimates sit from new measurements, read how accurate the speed estimates are.

The GPU memory limit on 24 GB

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 24 GB Mac it sits below the 20 GB-plus files of the 35B models. That is the main reason the same model feels effortless on 32 GB and fragile on 24.

The mlx-lm documentation says that if a model fits in RAM, it can often be sped up by raising the system wired-memory limit (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. Leave several gigabytes for macOS and your apps. The setting lasts until you restart.

Buying: 24 or 32 GB?

If you are choosing now, choose 32 GB. On the Mac mini M6 both configurations have the same 170 GB/s, so the speed figures are the same. What 32 GB adds is room: every model in this guide runs at 4-bit with a working context. On 24 GB you are choosing between quants. The Mac mini M6 32 GB page lists everything that runs on it. If you need more speed rather than more room, the 24 GB Mac mini M5 Pro has 1.8× the M6’s bandwidth (307 GB/s), but it has the 24 GB fit problem described above. If your Mac has 16 GB, read the 16 GB guide instead.

Frequently Asked Questions