CanItRun Logocanitrun.

Apple M2 Max

The Apple M2 Max ships in 32–96 GB unified-memory configurations at 400 GB/s. Across those configurations it runs 61 of our 84 tracked models natively in VRAM at 8k context.

More memory means more of our tracked models fit natively — see which configuration you need below.

ConfigurationBandwidthCPU coresNative models+ Offload
96 GB400 GB/s12 (8P + 4E)61 / 840
64 GB400 GB/s12 (8P + 4E)56 / 840
32 GB400 GB/s12 (8P + 4E)46 / 840
Vendor: Apple
Memory type: LPDDR5
Compute backend: METAL
Software: MLX gives the best performance on Apple Silicon; llama.cpp Metal backend is a solid alternative. Both are well-supported by Ollama.

How much of the Apple M2 Max's memory is actually usable?

macOS and background apps need a slice of the pool before a model gets to use it — this site reserves 8GB on every unified-memory GPU, the same baseline used everywhere else on this site. What's left is real headroom for a model's weights and KV cache:

macOS + background apps (8 GB reserved)usable for model weights + KV cacheVertical lines mark roughly where a 7B/14B/32B/... dense model at Q4_K_M lands.

The clean part of the M2 generation: bandwidth exactly doubles at every tier

Apple's M2 lineup spans four SoC tiers, and within this generation memory bandwidth scales in one of the cleanest patterns in the whole Apple Silicon family — each tier up doubles the last, with no exceptions at any memory size:

Apple M2 (24GB)
100 GB/s
Apple M2 Pro (32GB)
200 GB/s
Apple M2 Max (64GB) — this page
400 GB/s
Apple M2 Ultra (192GB)
800 GB/s

100 GB/s (M2) to 200 GB/s (M2 Pro) to 400 GB/s (M2 Max, this page) to 800 GB/s (M2 Ultra) — four tiers, three doublings, no exceptions. That's worth naming because the M3 generation that followed breaks it: the 96GB M3 Max configuration bins down to 300 GB/s instead of continuing the pattern. This M2 Max doesn't have that wrinkle at any of its three memory sizes — 32GB, 64GB, and 96GB all share the same 400 GB/s.

Apple M2 Max (96GB)

With 96 GB LPDDR5 at 400 GB/s, this configuration runs 61 models natively. It runs 70B-class dense models and large MoE models entirely in VRAM.

Apple M2 Max (96GB): the flagship memory configuration of Apple's second-generation Max chip, pairing the 12-core CPU (8 performance + 4 efficiency) with the full 38-core GPU. It shares the same 400 GB/s of LPDDR5-6400 bandwidth as the 32GB and 64GB configs — Apple never cut bandwidth across the M2 Max's memory range the way it later did with the 96GB M3 Max's binned die.

88 GB of real headroom after this site's standard 8 GB reservation unlocks a different tier of model than the 64GB sibling: Llama 3.3 70B fits at Q8_0 (86.4 GB, ~4.2 tok/s) instead of Q4_K_M, and GPT-OSS 120B — a model that doesn't fit the 64GB configuration at any quantization, since even its smallest real build needs about 63 GB before KV cache — fits here at Q4_K_M (80.2 GB) around 30 tok/s. Qwen 3.5 122B-A10B, a mixture-of-experts model, reaches Q4_K_M (85.6 GB) at roughly 14.3 tok/s. 61 of the 84 tracked models fit natively, 5 more than the 64GB configuration.

MLX and llama.cpp's Metal backend are both mature on this chip; community benchmarks commonly report MLX running 20-87% faster than llama.cpp Metal for dense models under 14B parameters, narrowing toward parity above roughly 27B parameters where decode is fully bandwidth-bound. Several of the larger fits above — Llama 3.3 70B at Q8_0 (86.4 GB) and GPT-OSS 120B at Q4_K_M (80.2 GB) among them — exceed macOS's default ~72 GB Metal working-set limit (roughly 75% of unified memory), so raising it by hand with `sudo sysctl iogpu.wired_limit_mb=90112` (leaving 8 GB for macOS, matching this page's reservation) is necessary before loading them.

Models the 96 GB configuration runs natively (61)

Show 56 more

Apple M2 Max (64GB)

With 64 GB LPDDR5 at 400 GB/s, this configuration runs 56 models natively. It handles 70B-class models at Q4 quantization.

Apple M2 Max (64GB): The M2 Max pairs a 12-core CPU (8 performance + 4 efficiency) with up to a 38-core GPU. Unlike the M3 Max generation that replaced it — where the 96GB build bins down to a slower die — every M2 Max memory size (32GB, 64GB, 96GB) shares the same 400 GB/s of LPDDR5-6400 unified memory bandwidth regardless of GPU core count; Apple never cut bandwidth on this chip.

This calculator always recommends the highest-quality quantization that still fits within this configuration's roughly 56 GB of usable memory (64 GB minus 8 GB reserved for macOS). For 32B-class dense models — Qwen3 32B, Qwen 2.5 32B and its Coder variant, and DeepSeek-R1-Distill-Qwen-32B — that's Q8_0: Qwen3 32B lands at 40.55 GB and roughly 8.8 tok/s, with the other three landing within half a gigabyte and a tenth of a token per second of that (41.1 GB, 8.7 tok/s). Hand-picking Q4_K_M instead (23.88 GB for Qwen3 32B) nearly doubles that to about 15 tok/s at some quality cost. Dense 70B-class models fit at Q4_K_M: Llama 3.3 70B reaches 50.75 GB at roughly 7.1 tok/s, and Qwen 2.5 72B is the largest dense model this configuration fits natively at all, at 52.12 GB and 6.9 tok/s — both track a widely-cited real-world report of about 7 tok/s for Llama 2 70B Q4 on an M2 Max. MoE models are where the extra bandwidth pays off, since decode only reads the active parameters: Qwen3-30B-A3B and Qwen 3.5 35B-A3B both fit at full Q8_0 (36.62-41.86 GB) around 28-30 tok/s. GPT-OSS 120B is the exception that proves the rule — it doesn't fit this configuration at any quantization, because OpenAI never released its MoE expert weights above native MXFP4: even the smallest real build is about 63 GB before KV cache and overhead, past the ~56 GB of usable memory here regardless of which quant label you pick. Qwen 3.5 122B-A10B, the largest model this configuration fits at all, reaches Q2_K (54.47 GB) around 21.6 tok/s.

MLX and llama.cpp's Metal backend are both mature on this chip. Community benchmarks commonly report MLX running 20-87% faster than llama.cpp Metal for dense models under 14B parameters, with the gap narrowing toward parity above roughly 27B parameters, where decode is fully bandwidth-bound and the software stack matters less. One gotcha specific to this 64GB configuration: macOS's Metal driver only exposes about 75% of unified memory to the GPU by default — around 48 GB here — enough for every 32B-class Q8_0 model above but not the 50.75 GB Llama 3.3 70B Q4_K_M this page recommends. Raise it by hand with `sudo sysctl iogpu.wired_limit_mb=57344` (leaving 8 GB for macOS, matching what every estimate on this page already assumes) before loading anything close to that ceiling.

Models the 64 GB configuration runs natively (56)

Show 51 more

Apple M2 Max (32GB)

With 32 GB LPDDR5 at 400 GB/s, this configuration runs 46 models natively. It comfortably runs 7B–32B models at Q4; 70B-class models typically need CPU offload.

Apple M2 Max (32GB): the base memory configuration of Apple's second-generation Max chip, launched January 2023 alongside the M2 Pro on the 14-inch and 16-inch MacBook Pro. It shares the 12-core CPU (8P+4E) with every other M2 Max memory size and doubles the M2 Pro's 200 GB/s bandwidth to 400 GB/s from the same starting memory pool.

24 GB of real headroom after the standard 8 GB reservation — identical capacity to the M2 Pro 32GB configuration, so the same 46 of 84 tracked models fit natively, including Qwen3 32B at Q4_K_M (23.9 GB) and Mixtral 8x7B at Q2_K. What changes is speed: this site's calculator projects roughly 15 tok/s for Qwen3 32B here, about double the M2 Pro 32GB's 7.5 tok/s, and mid-size models get real precision headroom too — Llama 3.1 8B and Qwen2.5 7B fit at full BF16 (19.1 GB and 17.6 GB) at roughly 18.7-20.4 tok/s rather than being squeezed onto a lower quant.

Full MLX and llama.cpp Metal support, same as the 64GB and 96GB siblings. Because macOS's Metal working-set reservation stays roughly fixed regardless of installed memory, it eats a much smaller share of this 32 GB pool than it does on a 16 GB Apple Silicon configuration, leaving comfortable headroom for every fit above.

Models the 32 GB configuration runs natively (46)

Show 41 more

Too large for any Apple M2 Max configuration (23)

Compare Apple M2 Max with other GPUs

Frequently asked questions

How much memory does the Apple M2 Max have?
The Apple M2 Max ships in 3 unified-memory configurations: 96 GB, 64 GB, 32 GB, all at 400 GB/s.
Should I get the 32 GB or 96 GB Apple M2 Max?
Both run everything that fits natively in 32 GB. The extra memory in the 96 GB configuration additionally fits Step 3.7 Flash, Step 3.5 Flash, Mixtral 8x22B Instruct v0.1, and 12 more models natively in VRAM — worth the upgrade if you plan to run any of those.
How much VRAM does the Apple M2 Max (96GB) have?
The Apple M2 Max (96GB) has 96 GB of LPDDR5 with 400 GB/s memory bandwidth (unified system memory, shared between CPU and GPU).
What is the Apple M2 Max (96GB) best for?
With 96 GB of unified memory, the Apple M2 Max (96GB) is a high-capacity laptop platform that runs 70B-class dense models and large MoE models natively, with plenty of room for long context.
What LLMs can the Apple M2 Max (96GB) run locally?
The Apple M2 Max (96GB) can run 61 of the 84 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Llama 3.3 70B Instruct at Q8_0, Llama 3.1 8B Instruct at FP32, Llama 3.2 3B Instruct at FP32.
Can the Apple M2 Max (96GB) run Llama 3.3 70B Instruct?
Yes. The Apple M2 Max (96GB) runs Llama 3.3 70B Instruct natively in VRAM at Q8_0 quantization, achieving approximately 4.2 tokens per second.
Show 14 more questions
Can the Apple M2 Max (96GB) run Qwen 3.6 27B?
Yes. The Apple M2 Max (96GB) runs Qwen 3.6 27B natively in VRAM at BF16 quantization, achieving approximately 5.9 tokens per second.
Can the Apple M2 Max (96GB) run Llama 3.1 8B Instruct?
Yes. The Apple M2 Max (96GB) runs Llama 3.1 8B Instruct natively in VRAM at FP32 quantization, achieving approximately 9.7 tokens per second.
How much VRAM does the Apple M2 Max (64GB) have?
The Apple M2 Max (64GB) has 64 GB of LPDDR5 with 400 GB/s memory bandwidth (unified system memory, shared between CPU and GPU).
What is the Apple M2 Max (64GB) best for?
With 64 GB of VRAM, the Apple M2 Max (64GB) is ideal for running 70B-class models at Q4 quantization and large MoE models — a workstation sweet spot for local inference.
What LLMs can the Apple M2 Max (64GB) run locally?
The Apple M2 Max (64GB) can run 56 of the 84 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Llama 3.3 70B Instruct at Q4_K_M, Llama 3.1 8B Instruct at FP32, Llama 3.2 3B Instruct at FP32.
Can the Apple M2 Max (64GB) run Llama 3.3 70B Instruct?
Yes. The Apple M2 Max (64GB) runs Llama 3.3 70B Instruct natively in VRAM at Q4_K_M quantization, achieving approximately 7.1 tokens per second.
Can the Apple M2 Max (64GB) run Qwen 3.6 27B?
Yes. The Apple M2 Max (64GB) runs Qwen 3.6 27B natively in VRAM at Q8_0 quantization, achieving approximately 10.9 tokens per second.
Can the Apple M2 Max (64GB) run Llama 3.1 8B Instruct?
Yes. The Apple M2 Max (64GB) runs Llama 3.1 8B Instruct natively in VRAM at FP32 quantization, achieving approximately 9.7 tokens per second.
How much VRAM does the Apple M2 Max (32GB) have?
The Apple M2 Max (32GB) has 32 GB of LPDDR5 with 400 GB/s memory bandwidth (unified system memory, shared between CPU and GPU).
What is the Apple M2 Max (32GB) best for?
With 32 GB of VRAM, the Apple M2 Max (32GB) is well-suited for running 7B–32B models at Q4 with room for context, making it a great all-rounder for local LLM inference.
What LLMs can the Apple M2 Max (32GB) run locally?
The Apple M2 Max (32GB) can run 46 of the 84 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Llama 3.1 8B Instruct at BF16, Llama 3.2 3B Instruct at FP32, Llama 3.2 1B Instruct at FP32.
Can the Apple M2 Max (32GB) run Llama 3.3 70B Instruct?
The Apple M2 Max (32GB) does not have enough VRAM to run Llama 3.3 70B Instruct. You would need more VRAM or a lower quantization level.
Can the Apple M2 Max (32GB) run Qwen 3.6 27B?
Yes. The Apple M2 Max (32GB) runs Qwen 3.6 27B natively in VRAM at Q5_K_M quantization, achieving approximately 16.2 tokens per second.
Can the Apple M2 Max (32GB) run Llama 3.1 8B Instruct?
Yes. The Apple M2 Max (32GB) runs Llama 3.1 8B Instruct natively in VRAM at BF16 quantization, achieving approximately 18.7 tokens per second.