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. This post covers what you need to run Llama 3.2 on an iPhone, and what drives its speed.
PocketLLM lists Llama 3.2 1B with int4 quantization through Core ML. The general model comparison below does not describe PocketLLM speed tests.
PocketLLM is launching soon. Private, on-device AI, starting on iPhone, with more platforms planned. No account required, no in-app tracking, and chat processing stays on your device. Join the launch list and be first in.
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 smaller model at the same quantization moves fewer bytes per token, 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 have not run a quality test of Llama 3.2 on iPhone, so this post does not grade its answers or rank it against cloud models.
What about the 1B model?
The 1B is the lighter option. It is a smaller model than the 3B, so it needs less memory and generates faster. The trade is capability: expect it to fall behind the 3B on reasoning.
If your iPhone has 8 GB RAM or more, use the 3B. If it has 6 GB, the 1B is actually a better experience, with less memory pressure and faster generation. Don't force the 3B onto a constrained device; the 1B will serve you better.
How to install Llama 3.2 on your iPhone
- PocketLLM is coming soon — join the launch list to install it at launch.
- Open the model library.
- Pick Llama 3.2 1B Q4 (if you have 6 GB RAM) or 3B Q4 (if you have 8 GB).
- Wait for the download. 1B is about 800 MB, 3B is about 2 GB.
- 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 fits comfortably on an 8 GB iPhone, the 1B variant is the better fit for a 6 GB one, and both are built for 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.