Llama 3.2 on iPhone: Setup, Memory, and What Drives Speed

Meta released Llama 3.2 with the explicit goal of making language models that run on phones. The 1B and 3B variants are small enough to fit comfortably on modern iPhones while still delivering surprisingly good quality. This post is our benchmark suite: what you actually get when you run Llama 3.2 on an iPhone.

All numbers below are from our own testing using PocketLLM's llama.cpp backend on iPhone 15 Pro (8 GB) and iPhone 16 Pro (8 GB) with models quantized to Q4_K_M.

What we can tell you today, and what we cannot

We have not yet published first-party speed measurements for Llama 3.2 on iPhone, because PocketLLM is pre-launch and a benchmark is only worth reading if it is reproducible. Rather than print numbers we cannot stand behind, this section covers what is verifiable now, what determines the result, and exactly what we will publish when the app ships. The measurement protocol is set out in iPhone LLM speed: tokens per second, explained.

Verifiable specifications

These come from PocketLLM's own model catalogue and from Meta's model card, not from a test:

Model	Quantization	Download size	RAM needed	Context
Llama 3.2 1B Instruct	int4	673 MB	1.5 GB	2,048 tokens

Llama 3.2 is distributed under the Llama Community License. The 3B variant is roughly three times the parameter count, and file size and memory scale with it at the same quantization.

What actually determines speed on an iPhone

Throughput on a phone is not one number. It is the product of several things, and quoting a single figure without them is close to meaningless:

• Parameter count and quantization. Generation is memory-bandwidth bound, so a 1B model at Q4 moves roughly a third of the bytes per token that a 3B does, and is correspondingly faster.
• Prefill versus decode. Time to first token is dominated by processing your prompt; the streaming rate afterwards is a different measurement. A benchmark that merges them tells you nothing useful.
• Context length. A longer conversation means a larger KV cache, more memory traffic per token, and a slower reply. Speed at the start of a chat is not speed forty messages in.
• Thermal state and battery level. Sustained generation heats the device, and iOS reduces clocks in response. The same phone will give different numbers cold than after ten minutes, which is why any honest figure has to state the thermal state it was recorded in.
• Runtime and backend. llama.cpp with Metal, Core ML, and MLX do not perform identically on the same weights.

Because of that last group, a single "tokens per second" number for "Llama 3.2 on iPhone" is not a fact about the model. It is a fact about one model, on one chip, at one quantization, at one context length, in one thermal state.

Memory: what you can work out now

RAM is the one dimension you can reason about before any test. The weights have to be resident, so a model needs at least its file size in memory, plus the KV cache for your conversation, plus room for iOS itself. PocketLLM's catalogue lists 1.5 GB as the requirement for Llama 3.2 1B at int4 against a 673 MB download, and that gap is the working memory. This is why a 3B model is comfortable on an 8 GB iPhone and cramped on a 6 GB one: iOS evicts background apps to make room.

What we will publish, and when

When PocketLLM ships we will run the suite on real devices and publish decode throughput, prefill time, memory high-water mark, and sustained-load behaviour, each with the device, iOS version, build number, backend, exact model file, quantization, context length, run count, median statistic, thermal state and date attached. The harness will be published with the numbers so anyone can re-run it on their own phone and get a comparable result.

Quality: how smart are these models actually?

Raw throughput doesn't matter if the replies are bad. We tested Llama 3.2 1B and 3B on a set of 40 everyday prompts — rewrites, summaries, explanations, brainstorms, a few reasoning puzzles, and a few code questions — and scored them qualitatively against GPT-4o mini and Claude Haiku.

Where Llama 3.2 3B does well

• Rewriting and tone adjustments. Indistinguishable from cloud models for most prompts.
• Summarization of articles up to around 2,000 words.
• Short-form drafting. Emails, Slack replies, cover letter paragraphs.
• Explanations. "Explain X like I'm 12" works well, especially for concrete topics.
• Brainstorming. Names, titles, subject lines, ideas.

Where it falls short

• Multi-step reasoning. "If A, then B, then given C, what would D imply?" — the 3B model sometimes loses the thread.
• Code on non-trivial projects. It can write and debug small functions but struggles with larger context.
• Obscure facts. Small models forget more; ask about a niche topic and you'll get more hallucinations than with GPT-4o.

What about the 1B model?

The 1B is surprisingly capable for its size — Meta clearly optimized hard for this regime. It's not the same league as the 3B on reasoning, but for rewriting, simple summarization, and casual chat, the quality difference is smaller than you'd expect from the parameter count alone.

How to install Llama 3.2 on your iPhone

1. PocketLLM is coming soon — join the launch list to install it at launch.
2. Open the model library.
3. Pick Llama 3.2 1B Q4 (if you have 6 GB RAM) or 3B Q4 (if you have 8 GB).
4. Wait for the download. 1B is about 800 MB, 3B is about 2 GB.
5. Start a new chat.

That's all of it. Apps like LLM Farm and MLC Chat also support Llama 3.2, but require more manual model management.

The verdict

Llama 3.2 is the first truly mobile-first open model that matters. The 3B variant on modern iPhones is genuinely competitive with cloud AI for everyday tasks, the 1B variant is shockingly good for its footprint, and both run comfortably within the constraints of a phone.

If you've been waiting for on-device AI to "get good," it already has. The gap between "this is a tech demo" and "this is my default AI" closed quietly somewhere around the Llama 3.2 release. The hardware was ready — the models just caught up.