Storage is not the constraint: the standard Gemma 4 E2B edge build is 2,583 MB, and the web-optimised build is 2,008 MB. The limits are context length and sustained token rate. Apple’s on-device model is fixed at 4096 tokens per session, and Google’s own tables show Gemma 4 E4B decoding at 9.7 tokens per second on an iPhone 17 Pro CPU. Readers of the 8 GB VRAM model guide and the llama.cpp sparse-attention coverage should treat a phone as another class of machine. (Source) (Source)
Updated August 2026. This page is refreshed monthly as models and runtimes change.
What Runs a Model on Each Platform
Android’s base layer is llama.cpp, run inside Termux, with Arm CPU acceleration documented up to SME2 and an OpenCL backend for Adreno GPUs. PocketPal AI, MIT licensed, wraps it for GGUF builds of Gemma, Qwen, Phi and Llama offline across CPU, Adreno GPU and Qualcomm Hexagon NPU; its README states “CPU, GPU (Metal on iOS, OpenCL/Adreno on Android), and NPU (Qualcomm Hexagon) inference paths, with graceful fallback”, which is the vendor’s own claim rather than an independent measurement. (Source) (Source)
ChatterUI is AGPL-3.0 and runs GGUF through llama.cpp, Android only: “iOS is Currently unavailable due to lacking iOS hardware for development.” MLC LLM is Apache-2.0 and uses pre-converted weights rather than GGUF, and its docs are blunt: “MLC LLM needs an actual mobile GPU to meaningfully run at an accelerated speed.” (Source) (Source)
Google’s Android path changed. The MediaPipe LLM Inference page, updated 2026-06-12: “The MediaPipe LLM Inference API is in maintenance-only mode. We recommend migrating your Android projects to LiteRT-LM Android (Kotlin) API.” The same page on hardware: “The LLM Inference API is optimized for high-end Android devices, such as Pixel 8 and Samsung S23 or later, and does not reliably support device emulators.” LiteRT-LM is Apache-2.0 and supports Gemma, Llama, Phi-4 and Qwen. (Source) (Source)
There is no official Ollama mobile app: the README’s install sections cover macOS, Windows, Linux and Docker only, and it lists SwiftChat, Enchanted, Maid, Ollama App, Reins and ConfiChat under community integrations. (Source)
On iOS, LLM Farm is built on llama.cpp with Metal and runs on iOS 16 and later, but its own README now states that “The app is temporarily unavailable in TestFlight and Appstore” and its App Store listing no longer resolves, so it cannot currently be installed. Private LLM is a one-time purchase across a buyer’s Apple platforms: “Your conversations never leave the device, and no internet is required after the first model download”. Enclave requires no account and says “When using local models, we do not collect any personal information”, but its optional OpenRouter models leave the device. (Source) (Source) (Source)
What Actually Fits
Gemma 4 shipped on April 2, 2026 in E2B, E4B, 26B and 31B sizes under the Apache 2.0 license, with “a 128K context window” on the edge models. (Source)
| Model | Build | On disk | Licence |
|---|---|---|---|
| Gemma 4 E2B | litert-lm | 2,583 MB | Apache-2.0 |
| Gemma 4 E4B | litert-lm | 3.66 GB | Apache-2.0 |
| Qwen3-1.7B | GGUF Q8_0 | 1.83 GB | Apache-2.0 |
| Qwen3-4B | GGUF Q4_K_M | 2.5 GB | Apache-2.0 |
The sourced range runs from 382 MB (Qwen3-0.6B, Q4_0) to 8.05 GB (Qwen3-4B, BF16). Phone RAM is shared with the operating system, so the usable budget sits below the spec sheet; no official fraction is published. (Source) (Source) (Source)
Two licences get misreported. Gemma 3n, the previous generation, uses the custom gated Gemma licence, not Apache-2.0. Llama 3.2 1B and 3B use the custom Llama 3.2 Community License and support 128K context, from an announcement dated September 25, 2024, roughly two years old. (Source) (Source)
What Speed To Really Expect
One clean multi-device set exists: Google’s LiteRT-LM tables on litert-community model cards. That is Google’s methodology in a Google-managed org, not a press release; the org notes that “The Google AI Edge team will not actively moderate community contributions”. (Source)
| Model | Device | Backend | Prefill tok/s | Decode tok/s |
|---|---|---|---|---|
| Gemma 4 E2B | iPhone 17 Pro | CPU | 532 | 25.0 |
| Gemma 4 E2B | iPhone 17 Pro | GPU | 2,878 | 56.5 |
| Gemma 4 E2B | Galaxy S26 Ultra | CPU | 557 | 46.9 |
| Gemma 4 E2B | Galaxy S26 Ultra | GPU | 3,808 | 52.1 |
| Gemma 4 E4B | iPhone 17 Pro | CPU | 159 | 9.7 |
| Gemma 4 E4B | iPhone 17 Pro | GPU | 1,189 | 25.1 |
| Gemma 4 E4B | Galaxy S26 Ultra | CPU | 195 | 17.7 |
| Gemma 4 E4B | Galaxy S26 Ultra | GPU | 1,293 | 22.1 |
| Gemma 4 E4B | Raspberry Pi 5 (16GB) | CPU | 51 | 3.2 |
| Gemma 3 1B-it | Galaxy S24 Ultra | CPU, dynamic_int4 | 138 | 50 |
| Gemma 3 1B-it | Galaxy S25 Ultra | NPU, a16w4 QAT | 5,836 | 85 |
Each Gemma 4 row is a packaged litert-lm build whose table labels the backend; the Gemma 3 1B rows name the quantisation, hence dynamic_int4 and a16w4 QAT. Prefill and decode are separate measurements that differ by an order of magnitude here, so a bare tokens-per-second claim is usually one of the two, unlabelled. (Source)
Device names matter as much as numbers. iPhone 17 Pro and Galaxy S26 Ultra are current flagships, and no source here benchmarks older or mid-range handsets. The Raspberry Pi 5 is the honest floor: 51 prefill and 3.2 decode for the same Gemma 4 E4B build that reaches 1,189 and 25.1 on an iPhone 17 Pro GPU. (Source)
Where It Falls Over
Context is the hard wall. Apple’s technote: “Apple’s on-device foundation model has a context window of 4096 tokens per [language model session].” An Apple engineer on the developer forum was blunter: “This is always the fixed token limit, there’s no possibility of it changing.” Google’s own phone benchmark configurations run 1280-token or 4096-token contexts even for models rated at 32K to 256K. (Source) (Source) (Source)
Memory is where documentation runs out. Apple’s entitlement com.apple.developer.kernel.increased-memory-limit, available from iOS 15.0, is “A Boolean value that indicates whether core features of your app may perform better with a higher memory limit on supported devices”. Apple publishes no numeric ceiling there, so every circulating “jetsam limit is N GB” figure traces back to third-party developer testing. (Source)
The clearest failure case is agentic work, per an agent project’s docs. OpenClaw tells users to load a full-size Qwen, DeepSeek or Llama build in LM Studio and to take “the largest available model build (avoid ‘small’/heavily quantized variants)”, because “small or heavily quantized checkpoints raise prompt-injection risk”. Its hardware guidance: “Aim for 2+ maxed-out Mac Studios or an equivalent GPU rig (~$30k+) for a comfortable agent loop.” Its own mobile node clients are thin: the phone is a remote control, not the machine running the model. (Source) (Source)
What This Means
The privacy case holds up in each project’s own docs. PocketPal states that “every prompt, response, and document stays on your device. Nothing is uploaded or stored on external servers”, and Private LLM, Enclave and ChatterUI make the same offline claim in local mode; Enclave’s OpenRouter option and ChatterUI’s remote mode are opt-in cloud paths. The numbers do not support treating a phone as a small workstation: a 4096-token session and single-digit decode for Gemma 4 E4B on an iPhone 17 Pro CPU describe a machine for short, self-contained work. (Source) (Source) (Source)
The Bottom Line
On Android, PocketPal or ChatterUI with a 2B to 4B GGUF; on iOS, Private LLM or Enclave, with LLM Farm off the list while it is pulled from the App Store. Pick by on-disk size and licence, judge by decode rate on a device close to yours, and check whether the app reaches the GPU: the gap between 25.0 and 56.5 decode tokens per second for the same Gemma 4 E2B build on one iPhone 17 Pro. (Source)