How Much RAM Do You Need to Run a Local LLM on a Mac?

Not "how fast is your Mac" — how much memory it has. That single number decides which local models you can run, and the answer is more generous than most people expect right up until it isn't.

You can run a local LLM on a Mac with 8 GB of unified memory. The model changes as memory increases; the table gives the engine's current general-purpose pick for each tier.

Quick answer: how much memory for a local LLM?

Use your Mac's installed unified memory, not its free disk space. A 36 GB Mac uses the 32 GB row; 128 GB and larger Macs use the 96 GB policy tier.

These are the engine's defaults. See best local LLM by RAM for how to choose between the general-purpose and fast picks, MacBook Pro model comparisons for measured alternatives, and the model catalog for other tasks.

More choices by memory

For image input, tool calls and reasoning, Bonsai 2 uses 2-bit Hadamard weights. On an 8 GB Mac, try rapid-mlx serve bonsai2-2b-2bit (1.2 GB download) or rapid-mlx serve bonsai2-4b-2bit (1.95 GB). At 16 GB, rapid-mlx serve bonsai2-9b-2bit (3.6 GB) is another option.

For text chat, reasoning and tool calls on larger Macs, Nemotron 3.5 Bolt 74B-A9B offers rapid-mlx serve nemotron-3.5-bolt-3bit (31.7 GB download, 48 GB+ Macs) and rapid-mlx serve nemotron-3.5-bolt (43.3 GB, 64 GB+). Nemotron 3.5 Super VL 120B-A12B offers rapid-mlx serve nemotron-3.5-super-vl-3bit (42.8 GB, targets 64 GB Macs at short context) and rapid-mlx serve nemotron-3.5-super-vl (69.5 GB, 128 GB+). Rapid-MLX serves these Nemotron builds as text only, without image or video input. Downloads are smaller than the memory needed to serve them; leave room for macOS and context.

Every "can my Mac run this model?" thread ends up at the same place: it depends on RAM. Not the chip, not the core count — the unified memory, because the weights have to sit in it.

So we measured it. Every model rapid-mlx serves, at its smallest usable quantization, sized from the actual checkpoints. Then, where Artificial Analysis has scored the model, we plotted that against it.

The short version: 60 of the 82 models fit in 24 GB. A base MacBook Air runs 23 of them. What you cannot buy at any price is the top-right of that chart.

The map

The horizontal axis is the thing that actually constrains you. It plots each model's own footprint, weights plus 20%; the tables below also leave 3 GB for macOS, so a point just left of a tick can land a tier higher. The vertical axis is the Artificial Analysis Intelligence Index v4.1 — a composite of reasoning, coding and agentic benchmarks.

Three things fall out of it.

A 24 GB Mac gets you to 37. That is Qwen3.6 27B, and it is the ceiling for the machine most people own. It is also a genuinely useful model — tool calling, long context, agentic workloads. The engine's 24 GB pick, bonsai-27b-2bit, is a 2-bit build of it; the 37 is the full-precision model's score, not the 2-bit build's.

The 50-point model needs a $10,000 machine. DeepSeek V4 Flash 0731 is the most capable open-weights model we serve. Its smallest quantization is 167 GB of weights, so it wants a 256 GB Mac Studio. Kimi K2.6 asks for 471 GB — more than any Mac ships with.

Between them is a hole. Nothing sits in the 24–64 GB band above 37 points. Not because we skipped it: no released open-weights model belongs there. Everything scoring above 37 on that index has 300 B+ parameters, and 300 B parameters do not fit in 64 GB at any quantization anyone ships today.

The one number to memorise

If you do not want to look anything up, this gets you close for a 4-bit model:

weights (GB)  ≈  parameters (B) × 0.6
usable RAM    ≈  total RAM − 3 GB for macOS − your KV cache

That 0.6 is not a guess — it is the median across the 58 four-bit checkpoints in our registry that name their parameter count. Half land between 0.57 and 0.70.

Two places it breaks. Big MoE models come in leaner — gpt-oss-120b and Qwen3.5 122B both sit near 0.52, because much of the parameter count is in experts that quantize well. Small models come in fatter — Gemma 3n E2B is 2.25 GB per billion, since embeddings and the vocabulary do not shrink with the transformer body and they dominate a 2 B model. Below about 4 B, ignore the formula and read the number.

Leave room for the context

The formula above sizes the weights. The KV cache is on top, it grows with context length, and it is the thing that turns "it loaded fine" into a swap death spiral three turns into a long conversation.

Rapid-MLX quantizes the live KV cache to int4 by default, which is most of why these numbers work at all — but a 128k-token context still costs real memory. If a model only just fits, it does not fit.

Why the cost axis lies to you

Artificial Analysis plots intelligence against cost per task, which is the right axis for an API buyer and the wrong one for you. Two reasons.

Run the model locally and the marginal cost is electricity. The x-axis collapses.

Worse, it inverts. Mixture-of-experts models look cheap per task because each token only activates a slice of the network — but you still have to hold every parameter in memory. MiMo-V2.5 is the cheapest 37-point model on the AA chart at $0.011 per task. It is also 311 B parameters. On a Mac it is one of the least runnable models on the entire chart.

So a model being cheap in the cloud tells you nothing about whether your laptop can load it, and sometimes tells you the opposite.

What fits, by machine

Sizes are the download for the smallest usable quantization. Budget roughly 20% on top for the KV cache and activations — more if you run long contexts — and 3 GB for macOS. Each model is listed under the smallest Mac where download × 1.2 + 3 GB fits; Kimi K2.6 fits none and is listed at 512 GB.

The fit tables below list checkpoint sizes and estimated memory tiers, including models the engine does not pick by default. For example, qwen3.5-4b-4bit fits in the 8 GB estimate, while the v0.16.0 engine first recommends it at 16 GB; bonsai-27b-2bit appears in the 16 GB estimate, while the engine first recommends it at 24 GB.

8 GB — the base MacBook Air

Every one of these fits on the cheapest Apple Silicon Mac sold today.

23 models fit.

16 GB

21 models fit.

24 GB

The sweet spot: this is where the strongest small-machine models live.

16 models fit.

32 GB

6 models fit.

48 GB

1 model fits.

64 GB

Past here you are buying a Mac Studio, not a laptop.

3 models fit.

96 GB

4 models fit.

128 GB

2 models fit.

192 GB

2 models fit.

256 GB

2 models fit.

512 GB — maxed M3 Ultra

Kimi K2.6 asks for more than any Mac ships with — listed for completeness.

1 model fits, and Kimi K2.6 is listed with it.

Picking one

The tables above are what fits. What to run is the engine's call: rapid-mlx recipe reads your Mac's memory and prints its pick, and the installer and the desktop app show the same one. Peak memory and speed below are measured on real Macs; Best local LLM for your Mac, by RAM has every run behind them.

• 8 GB — lfm2.5-2.6b-4bit: 2.7 GB peak and 93.2 tok/s on a 32 GB M2 Pro. A tool-caller and chat model, not a coding model.
• 16 GB — qwen3.5-4b-4bit: 4.3 GB peak and 45.4 tok/s on an 18 GB M3 Pro.
• 18 GB — qwen3.5-9b-4bit: 6.7 GB peak and 26.3 tok/s on an 18 GB M3 Pro.
• 24 GB — bonsai-27b-2bit, the 2-bit build of Qwen3.6 27B: 11.0 GB peak and 19.3 tok/s on a 32 GB M2 Pro; a 13.5 GB Metal peak and 22.4 tok/s on our 48 GB M4 Pro.
• 32 GB and up — qwen3.8-27b-4bit: 18.7 GB peak and 15.4 tok/s on a 24 GB M4 Pro; 18.6 GB peak and 32.9 tok/s on a 64 GB M5 Max. It is newer than the tables above, so it is not in them. From 48 GB the fast pick becomes qwen3.6-35b-4bit, a 35B mixture-of-experts at 85.4–104 tok/s on a 48 GB M4 Pro.

The engine's most capable pick stays qwen3.8-27b-4bit all the way up. The bigger models in the tables are there when you choose them yourself: qwen3-coder-next-80b-4bit for coding at 64 GB, qwen3.5-122b-mxfp4 at 96 GB, deepseek-v4-flash-2bit at 128 GB, and deepseek-v4-flash-0731-mxfp4, the 50-point model, at 256 GB.

To see what your own machine can hold, without reading a table:

pip install rapid-mlx
rapid-mlx recipe          # the engine's pick for this Mac
rapid-mlx models          # every alias, with download size
rapid-mlx doctor          # what this Mac can actually run

Or use the live picker — choose your Mac, see what fits.

What these numbers are, and are not

We would rather over-explain this than have someone quote it wrongly.

The intelligence scores are borrowed, and they are not measured on what you will run. Artificial Analysis evaluates full-precision models served over an API. rapid-mlx runs 2/4/6/8-bit MLX quantizations. Quantization costs accuracy. We have not run the AA task set against our own quantized builds, so read every vertical position as "this model family's tier" — not "this alias scores that." Closing that gap is on our list, and it matters: if 2-bit quantization drops a 40-point model to 30, the whole "compress it into 64 GB" strategy needs rethinking.

The memory figures are ours and they are real, but they are still estimates. Weight sizes come from the actual checkpoints. The 20% headroom, the 3 GB for macOS and the rounding up to Mac configurations are engineering judgement, not measurement. A long context, a second loaded model, or anything else on the machine will push you into the next tier.

Only 20 of the 82 models have an AA score at all. The rest — UI-TARS, Tmax, VibeThinker, Holo3, Devstral, LFM2, the Bonsai ternary builds — have never been benchmarked by Artificial Analysis, so they appear in the tables and not the chart. Absence from the plot says nothing about them.

Scores are AA Intelligence Index v4.1, read on 2026-07-31. Both the index and the model set move. rapid-mlx serves 166 text aliases; this page covers the 82 distinct models behind them.

Frequently asked questions

How much RAM do I need to run a local LLM on a Mac?

8 GB is enough to run real models — 23 of the 82 here fit, and the engine's pick there is lfm2.5-2.6b-4bit. 16 GB is comfortable. 24 GB is the sweet spot: the engine picks bonsai-27b-2bit, a 2-bit build of Qwen3.6 27B, the highest-scoring model on the chart above that fits a machine most people own. Above 64 GB you are buying a Mac Studio.

Can a 16 GB MacBook Air run a local LLM?

Yes. The engine's pick for 16 GB is qwen3.5-4b-4bit, which peaks at 4.3–5.3 GB. Bigger models fit too — Qwen3.5 9B peaked at 7.8 GB on a 16 GB M4 — but leave room for macOS and the KV cache; if a model only just fits, it does not fit.

Does a Mixture-of-Experts model use less memory?

No — only less compute. MoE activates a slice of the network per token, which makes it fast and cheap to serve, but every parameter still has to be resident. This is why MiMo-V2.5 looks like the cheapest capable model on cost-per-task charts and is simultaneously one of the least runnable on a Mac: 311 B parameters have to fit somewhere.

How do I estimate the memory a model needs?

Multiply parameters in billions by 0.6 for a 4-bit build, then subtract about 3 GB from your total RAM for macOS and leave headroom for the KV cache. The 0.6 is the median across 58 four-bit checkpoints in our registry. It breaks below ~4 B, where embeddings dominate and models come in fatter.

What is the most capable model that runs locally on a Mac?

DeepSeek V4 Flash 0731, at 50 on the Artificial Analysis Intelligence Index — but its smallest quantization is 167 GB of weights, so it needs a 256 GB Mac Studio. For a laptop, Qwen3.6 27B at 24 GB is the highest-scoring model on the chart that fits.

Questions about Mac memory for local LLMs

How much memory do I need for a local LLM on a Mac?

The engine has an 8 GB tier for chat and tools. On that Mac, run rapid-mlx serve lfm2.5-2.6b-4bit; 16 GB moves the default to qwen3.5-4b-4bit.

Can a 16 GB MacBook Air run a local LLM?

Yes. The 16 GB recommendation is qwen3.5-4b-4bit, with a 6 GB policy working-set footprint; run rapid-mlx serve qwen3.5-4b-4bit.

What local LLM fits a 24 GB Mac?

The engine's 24 GB default is bonsai-27b-2bit, with a 13 GB policy working-set footprint. Run rapid-mlx serve bonsai-27b-2bit; it is a text-only model.

How much memory does the 32 GB pick need?

qwen3.8-27b-4bit has a 20 GB policy working-set footprint and first appears in the 32 GB recommendation tier. Run rapid-mlx serve qwen3.8-27b-4bit; a 36 GB Mac uses that same tier.

Should I choose a bigger model on a 96 or 128 GB Mac?

The general-purpose default remains qwen3.8-27b-4bit at both memory sizes. Run rapid-mlx serve qwen3.8-27b-4bit, or compare other aliases in the model catalog if you have a specific task.

Related

• Best local LLM for your Mac, by RAM — the engine's pick for each Mac, measured
• Every alias, quant and family — the full reference
• RAM tier map + serve flags per tier
• Rapid-MLX vs Ollama vs LM Studio — an honest comparison with a reproducible benchmark

curl -fsSL https://rapidmlx.com/install.sh | bash