On-Device AI for Indie Apps: Apple Foundation Models & Gemini Nano

For an indie developer, the hardest part of shipping an AI feature was never the model — it was the meter. Every cloud call costs money, so every free user is a liability, and the paywall ends up shaped by your API bill instead of your product. That constraint has now fundamentally changed: both platforms ship a capable language model on the phone, callable from your app, at zero marginal cost.

I build AI-first apps — Heirloom is an AI photo restoration app — so I've been watching this closely. Here's the state of on-device AI for app developers in 2026, and how I'd use it in an indie app today.

What Apple gives you: the Foundation Models framework

Since iOS 26, Apple's Foundation Models framework gives any app direct access to the on-device model behind Apple Intelligence — a roughly 3-billion-parameter LLM — through a native Swift API. The parts that matter for product work:

• Zero cost, offline, private. Inference runs on the device. No API key, no bill, no data leaving the phone — which also simplifies your privacy story and store review.
• Guided generation. You can constrain output to typed, structured results instead of parsing free text — the difference between a demo and a feature you can ship.
• Tool calling. The model can invoke functions you define, so it can act inside your app rather than just chat.
• It keeps improving. The framework arrived with iOS 26 and was expanded at WWDC 2026 alongside the next generation of Apple Intelligence; the trajectory is clearly "this becomes a standard system capability".

The constraint is hardware: it requires an Apple Intelligence-capable device (iPhone 15 Pro and later, plus recent iPads and Macs). In 2026 that's a large and growing share of the iPhone installed base — and exactly the share most likely to pay for apps.

What Google gives you: Gemini Nano

Android's answer is Gemini Nano, the on-device member of the Gemini family, exposed to developers primarily through the ML Kit GenAI APIs: summarisation, proofreading, rewriting, and image description as packaged tasks, with lower-level access for custom prompting. With Android 16 the supported-device list widened well beyond Pixel flagships into the broader high end. Coverage is less uniform than Apple's — capability depends on the device's chip and Google's rollout — so on Android you treat on-device AI as progressive enhancement with a graceful fallback, not a baseline.

What a ~3B model can and can't do

Being honest about the ceiling is what keeps these features good. On-device models of this size are genuinely strong at:

• Summarising and rewriting text the user already has
• Classifying, tagging, and extracting structured data from content
• Short-form generation: titles, captions, replies, search queries
• Powering natural-language interfaces over your app's own data

They are weak at deep multi-step reasoning, long documents, broad factual recall, and anything where a wrong answer is expensive. The failure mode to design against isn't refusal — it's confident mediocrity.

The pattern that works: local-first, cloud-for-heavy

The architecture I recommend (and use) is a hybrid:

1. Default to on-device for every task inside the local model's competence — instant, free, offline, private.
2. Route heavyweight tasks to the cloud — in Heirloom's case, the actual photo restoration runs server-side on specialised vision models, and that's not changing; but caption suggestions, album naming, and search-by-description are exactly the kind of work a local model should absorb.
3. Make the seam invisible. Users don't care where inference ran; they care that the fast things are instant and the expensive things are worth waiting for.

Why this changes indie economics

Zero marginal cost inverts the usual AI monetisation anxiety. You can put real AI features in the free tier — the tier that drives downloads and word of mouth — without watching a dashboard in terror, and reserve the cloud-powered heavy lifting for the subscription, where the costs are real and the value is obvious. Your paywall goes back to being shaped by value instead of by your vendor's pricing page. For a solo developer, "the free users cost me nothing" is the difference between an AI feature being a growth engine and being a tax.

The React Native angle

Neither framework is JavaScript-native, but both are a thin native module away, and the community has moved fast — wrappers for the Foundation Models framework and the ML Kit GenAI APIs exist, and with Expo you can fold either into a config plugin without ejecting. The integration surface is small: a function that takes a prompt (or a typed request) and returns a result. If you've never written a native module, this is the motivating example — I covered the broader AI-app plumbing in Building a React Native AI Chat App UI, and the same screens drive a local model just as happily as a cloud one.

The window here is genuinely good for small developers: the platforms spent the money on models and silicon, and handed the capability to anyone who can design a feature around it. The apps that win won't be the ones that bolt on a chat box — they'll be the ones that quietly make twenty small interactions smarter at zero cost.