FoundationModels Framework (iOS 26+)

On-device LLM framework. Integrates AI capabilities into your app while preserving privacy through Apple Intelligence.

Model Availability Check

Always check model availability before use.

import FoundationModels

private var model = SystemLanguageModel.default

func checkAvailability() {
    switch model.availability {
    case .available:
        // Show AI feature UI
        showAIFeatures()

    case .unavailable(.deviceNotEligible):
        // Device not supported (requires A17 Pro or later)
        showFallbackUI()

    case .unavailable(.appleIntelligenceNotEnabled):
        // Apple Intelligence is disabled
        showEnableIntelligencePrompt()

    case .unavailable(.modelNotReady):
        // Model is downloading or not yet ready
        showDownloadingUI()

    @unknown default:
        showFallbackUI()
    }
}

Basic Text Generation

import FoundationModels

let session = LanguageModelSession()

// Simple text generation
let response = try await session.respond(to: "Tell me a fun fact about cats")
print(response.content)  // Access via .content!

Guided Generation (Structured Output)

Use the @Generable macro to enforce structured output.

@Generable(description: "Cat profile information")
struct CatProfile {
    var name: String

    @Guide(description: "Cat age (0-20 years)", .range(0...20))
    var age: Int

    @Guide(description: "Describe personality in one sentence")
    var personality: String
}

// Generate a structured response
let response = try await session.respond(
    to: "Generate a cute rescue cat profile",
    generating: CatProfile.self
)

let profile = response.content  // CatProfile type
print(profile.name)        // "Whiskers"
print(profile.age)         // 3
print(profile.personality) // "Curious and affectionate, loves following people around"

@Generable Rules

// Supported types
@Generable
struct Recipe {
    var title: String           // String
    var cookingTime: Int        // Int
    var isVegetarian: Bool      // Bool
    var rating: Double          // Double

    @Guide(.range(1...10))
    var difficulty: Int         // Range constraint

    @Guide(.options(["Korean", "Chinese", "Western", "Japanese"]))
    var category: String        // Option constraint
}

// Nested Generable
@Generable
struct Ingredient {
    var name: String
    var amount: String
}

@Generable
struct RecipeWithIngredients {
    var title: String
    var ingredients: [Ingredient]  // Nested array
}

Snapshot Streaming

Display partial generation results in real time with streaming.

@Generable
struct TripIdeas {
    var destination: String
    var activities: [String]
    var estimatedBudget: Int
}

let stream = session.streamResponse(
    to: "Recommend a weekend trip near the city",
    generating: TripIdeas.self
)

for try await partial in stream {
    // partial: Partial generation type (all properties are optional)
    if let destination = partial.destination {
        updateDestinationUI(destination)
    }
    if let activities = partial.activities {
        updateActivitiesUI(activities)
    }
}

SwiftUI Streaming

struct AIGeneratorView: View {
    @State private var result: TripIdeas?
    @State private var isGenerating = false

    var body: some View {
        VStack {
            if let result {
                Text(result.destination)
                ForEach(result.activities, id: \.self) { activity in
                    Text(activity)
                }
            }

            Button("Generate") {
                Task {
                    isGenerating = true
                    defer { isGenerating = false }

                    let stream = session.streamResponse(
                        to: "Recommend a trip",
                        generating: TripIdeas.self
                    )

                    for try await partial in stream {
                        // UI updates automatically (@Observable or @State)
                        if let dest = partial.destination {
                            result = TripIdeas(
                                destination: dest,
                                activities: partial.activities ?? [],
                                estimatedBudget: partial.estimatedBudget ?? 0
                            )
                        }
                    }
                }
            }
            .disabled(isGenerating)
        }
    }
}

Tool Calling

Enable the model to call external functions.

@Tool(description: "Fetches current weather information")
func getWeather(city: String) async throws -> String {
    let weather = try await weatherService.fetch(city: city)
    return "\(city): \(weather.temperature)°C, \(weather.condition)"
}

let session = LanguageModelSession(tools: [getWeather])
let response = try await session.respond(to: "What's the weather like in Seoul?")
// The model calls the getWeather tool and responds based on the result

Session Management

// Manage conversation sessions
let session = LanguageModelSession()

// First message
let response1 = try await session.respond(to: "I like cats")

// Second message (previous context is retained)
let response2 = try await session.respond(to: "Explain why")

// Reset the session
session.reset()

Error Handling

do {
    let response = try await session.respond(to: prompt)
    handleResponse(response.content)
} catch let error as LanguageModelSession.GenerationError {
    switch error {
    case .modelNotAvailable:
        showModelUnavailable()
    case .contentFiltered:
        showContentFilteredMessage()
    case .tokenLimitExceeded:
        showTruncationWarning()
    @unknown default:
        showGenericError()
    }
} catch {
    showGenericError()
}

Best Practices

DO:

Always check model availability first
Use @Generable for structured output (more reliable than free text)
Use streaming to minimize user wait time
Handle errors properly (unsupported device, content filter, etc.)
Emphasize on-device processing in your UI to highlight privacy

DON'T:

Do not show AI features without checking model availability
Do not include sensitive personal information in prompts
Do not blindly trust model responses (hallucinations are possible)
Do not rely on generating large amounts of text (on-device model has limitations)
Do not start long generations without streaming (degrades user experience)

Availability

if #available(iOS 26.0, *) {
    // Use FoundationModels
} else {
    // Fall back to server-side AI API or disable the feature
}

FoundationModels is a core AI framework in iOS 26. It enables structured AI capabilities while preserving privacy through on-device processing. Always refer to the Apple Developer Documentation for the latest API details.

foundation-models