Apple M2 Max

The Apple M2 Max ships in 32–96 GB unified-memory configurations at 400 GB/s. Across those configurations it runs 69 of our 99 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)69 / 990
64 GB400 GB/s12 (8P + 4E)63 / 990
32 GB400 GB/s12 (8P + 4E)53 / 990
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 69 models natively. 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 (83.4 GB) at roughly 15.6 tok/s. 69 of the 99 tracked models fit natively, 6 more than the 64GB configuration.

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 (83.4 GB) at roughly 15.6 tok/s. 69 of the 99 tracked models fit natively, 6 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 (69)

Show 64 more

Apple M2 Max (64GB)

With 64 GB LPDDR5 at 400 GB/s, this configuration runs 63 models natively. 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 (52.29 GB) around 24.8 tok/s.

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 (52.29 GB) around 24.8 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 (63)

Show 58 more

Apple M2 Max (32GB)

With 32 GB LPDDR5 at 400 GB/s, this configuration runs 53 models natively. 24 GB of real headroom after the standard 8 GB reservation, identical capacity to the M2 Pro 32GB configuration, so the same 53 of 99 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.

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 53 of 99 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 (53)

Show 48 more

Too large for any Apple M2 Max configuration (30)

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, Qwen3.8-Flash-Next, and 13 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 69 of the 99 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Qwen3.8-Flash-Next at Q2_K, Qwen 3.8 27B at BF16, Ornith 1.5 35B-A3B (MoE) at BF16.
Can the Apple M2 Max (96GB) run Gemma 4 31B?
Yes. The Apple M2 Max (96GB) runs Gemma 4 31B natively in VRAM at BF16 quantization, achieving approximately 5.1 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 Qwen3 8B?
Yes. The Apple M2 Max (96GB) runs Qwen3 8B natively in VRAM at BF16 quantization, achieving approximately 18.6 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 63 of the 99 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Qwen 3.8 27B at Q8_0, Ornith 1.5 35B-A3B (MoE) at Q8_0, Qwen 3.5 122B-A10B (MoE) at Q2_K.
Can the Apple M2 Max (64GB) run Gemma 4 31B?
Yes. The Apple M2 Max (64GB) runs Gemma 4 31B natively in VRAM at Q8_0 quantization, achieving approximately 9.4 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 Qwen3 8B?
Yes. The Apple M2 Max (64GB) runs Qwen3 8B natively in VRAM at BF16 quantization, achieving approximately 18.6 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 53 of the 99 open-weight models tracked by CanItRun natively in VRAM at 8k context. Top options include: Qwen 3.8 27B at Q5_K_M, Ornith 1.5 35B-A3B (MoE) at Q3_K_M, Ornith 1.5 9B at BF16.
Can the Apple M2 Max (32GB) run Gemma 4 31B?
Yes. The Apple M2 Max (32GB) runs Gemma 4 31B natively in VRAM at Q4_K_M quantization, achieving approximately 15.8 tokens per second.
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 Qwen3 8B?
Yes. The Apple M2 Max (32GB) runs Qwen3 8B natively in VRAM at BF16 quantization, achieving approximately 18.6 tokens per second.