Foundation Models Documentation

Apple just gave every Swift developer access to a 3 billion parameter large language model that runs entirely on-device. No API keys, no usage limits, no privacy concerns. The Foundation Models framework is Apple's answer to making AI accessible while keeping user data private.

What Is It?

The Foundation Models framework provides developers with direct access to Apple's on-device LLM through a Swift-native API. Unlike cloud-based AI services, everything runs locally on the user's device--no internet connection required.

Key Features

  • 3B Parameter Model: Powerful enough for complex language understanding while small enough to run on-device
  • Privacy-First: All processing happens locally--user data never leaves the device
  • Offline Capable: Works without an internet connection
  • Swift Integration: Native Swift API designed for ease of use
  • Guided Generation: Ensures consistent, structured model responses
  • Tool Calling: The model can request additional information from your app
  • Zero Cost: Completely free for developers to use

Why This Matters

Most AI features require sending user data to cloud servers. This creates privacy concerns, requires internet connectivity, and often comes with usage-based pricing. Apple's approach flips this model:

  • No privacy tradeoffs: Users don't have to choose between AI features and data privacy
  • Works anywhere: Apps function fully offline, perfect for travel or areas with poor connectivity
  • No backend complexity: Skip the API integration, rate limiting, and cost management
  • Better latency: On-device processing means instant responses

Applications

Developers are already using Foundation Models to create intelligent experiences across different categories:

SmartGym (Health & Fitness): Generates personalized workout recommendations with detailed explanations based on user fitness levels and goals.

CellWalk (Education): Creates conversational explanations of complex scientific terms, making biology more accessible to students.

Grammo (Language Learning): Produces contextual grammar exercises tailored to the student's current learning level.

Stuff (Productivity): Understands spoken or written tasks and automatically organizes them with smart categorization.

VLLO (Video Editing): Suggests appropriate music tracks and sticker elements based on video content and mood.

OmniFocus (Task Management): Generates project breakdowns with steps and tags from a simple description.

Getting Started

The Foundation Models framework is available through Apple's developer documentation. Here's what you need to know to start building:

Basic Implementation Steps

  1. Import the Foundation Models framework in your Swift project
  2. Initialize the model with your desired configuration
  3. Use guided generation to ensure structured outputs
  4. Optionally provide tools the model can call for additional context
  5. Handle responses and update your UI

The framework provides "guided generation" which helps ensure the model produces consistent, structured responses. This is crucial for building reliable app features--you can define the format you expect and the model will follow it.

Tool Calling

One of the most powerful features is the ability to give the model access to app-specific functions. For example:

  • A fitness app could provide a tool to check the user's recent workout history
  • A productivity app could let the model search through existing tasks
  • A learning app could give access to the user's progress data

The model can decide when it needs additional information and request it through these tools, making interactions more intelligent and context-aware.

Limitations

While the 3B parameter model is impressive for on-device processing, it's not as capable as larger cloud-based models like GPT-4 or Claude. You should consider Foundation Models when:

  • Privacy is a primary concern for your users
  • You need offline functionality
  • Your use case fits well-defined, structured tasks
  • You want to avoid API costs and complexity

For highly complex reasoning tasks or when you need the absolute best quality, cloud-based models may still be necessary.

Future

Apple's Foundation Models framework represents a shift in how we think about AI in apps. Instead of treating AI as a cloud service, it becomes a native platform capability--like Core Data or MapKit.

This approach has major implications:

  • Privacy becomes the default: Developers can add AI features without compromising user privacy
  • AI democratization: Every developer gets access to powerful AI, not just those who can afford expensive API bills
  • New interaction patterns: As Susan Prescott noted, "The in-app experiences they're creating are expansive and creative"
  • Offline-first apps: AI features work everywhere, making apps more reliable and accessible

Tutorial

Ready to implement Foundation Models in your own app? This code-along tutorial walks you through the entire process, from setup to deployment. You'll learn how to integrate the framework, configure the model, implement guided generation, and build a complete working example.

Resources

If you're building language learning apps like we are at Ludus, Foundation Models opens up interesting possibilities for personalized, privacy-protected learning experiences. The ability to generate contextual exercises and explanations entirely on-device means we can make language learning more intelligent without compromising user privacy.