KI & Machine Learning 12 Min. Lesezeit

Apple Foundation Models: On-Device-KI in iOS 26 mit SwiftUI

Lerne, wie du mit Apples Foundation Models Framework On-Device-KI in deine iOS-26-App integrierst — mit Streaming, strukturierten Ausgaben und praktischen SwiftUI-Codebeispielen.

Editorial Team

Was ist das Foundation Models Framework?

Mit iOS 26 hat Apple das Foundation Models Framework vorgestellt — und ehrlich gesagt, das hat mich ziemlich beeindruckt. Im Kern ist es ein On-Device-KI-Toolkit, das dasselbe Sprachmodell nutzt, das auch Apple Intelligence antreibt. Und das Ganze läuft direkt auf deinem Gerät.

Der entscheidende Unterschied zu Cloud-LLMs wie ChatGPT oder Claude: Apples Modell mit rund 3 Milliarden Parametern arbeitet vollständig lokal. Keine Daten verlassen das Gerät, es gibt keine API-Kosten, und die KI funktioniert sogar offline. Das ist schon ziemlich stark.

Für uns Swift-Entwickler bedeutet das einen echten Paradigmenwechsel. Textzusammenfassungen, Inhaltsklassifikation, strukturierte Datenextraktion, generativer Dialog — all das lässt sich jetzt ohne externe Dienste und ohne Datenschutz-Kopfschmerzen umsetzen.

Voraussetzungen und unterstützte Geräte

Bevor du loslegst, kurz die Checkliste für deine Entwicklungsumgebung und Zielgeräte:

  • Betriebssystem: iOS 26+, iPadOS 26+, macOS 26+ (Tahoe) oder visionOS 26+
  • Hardware: Apple Silicon ist Pflicht — iPhone 15 Pro (A17 Pro) oder neuer, iPad oder Mac mit M1-Chip oder neuer
  • Apple Intelligence: Muss in den Systemeinstellungen aktiviert sein
  • Xcode: Version 26 oder neuer
  • Sprachen: Deutsch, Englisch, Französisch, Italienisch, Portugiesisch (Brasilien), Spanisch, Chinesisch (vereinfacht), Japanisch und Koreanisch

Noch ein Hinweis, den man leicht übersieht: Das Gerät braucht ausreichend Akku und darf sich nicht im Spielmodus befinden. Außerdem kann der initiale Download des Modells nach der Aktivierung von Apple Intelligence etwas dauern — also am besten nicht erst kurz vor der Demo aktivieren.

Erste Schritte: LanguageModelSession erstellen

Also, der Einstieg ist tatsächlich unkompliziert. Du importierst das Framework, erstellst eine LanguageModelSession — und kannst im Grunde sofort loslegen.

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "Erkläre den Unterschied zwischen struct und class in Swift.")
print(response.content)

Was mir dabei besonders gefällt: Die Session ist zustandsbehaftet (stateful). Sie merkt sich alle Prompts und Antworten in einem Transkript. Das heißt, Folgefragen funktionieren kontextbezogen, und du kannst den Gesprächsverlauf direkt in der App-Oberfläche anzeigen.

Verfügbarkeit prüfen

Da nicht alle Geräte das Framework unterstützen, solltest du vor der Nutzung unbedingt die Verfügbarkeit checken. Klingt offensichtlich, wird aber gern vergessen:

import SwiftUI
import FoundationModels

struct KIView: View {
    var body: some View {
        switch SystemLanguageModel.default.availability {
        case .available:
            ChatView()
        case .unavailable(let reason):
            ContentUnavailableView(
                "KI nicht verfügbar",
                systemImage: "brain.slash",
                description: Text("Grund: \(reason)")
            )
        }
    }
}

Damit stellst du sicher, dass auch Nutzer auf älteren Geräten eine verständliche Meldung bekommen — statt eines kryptischen Crashes.

Streaming-Antworten in SwiftUI

Für eine wirklich gute UX willst du Antworten natürlich nicht erst komplett generieren lassen, bevor du sie anzeigst. Streaming ist hier das Stichwort — die Textfragmente werden inkrementell dargestellt, genau wie man es von einem Chat mit einer KI erwartet.

import SwiftUI
import FoundationModels

struct ChatView: View {
    @State private var session = LanguageModelSession()
    @State private var prompt = ""
    @State private var antwort = ""
    @State private var isGenerating = false

    var body: some View {
        VStack(spacing: 16) {
            ScrollView {
                Text(antwort)
                    .padding()
                    .frame(maxWidth: .infinity, alignment: .leading)
            }

            HStack {
                TextField("Frage eingeben...", text: $prompt)
                    .textFieldStyle(.roundedBorder)

                Button("Senden") {
                    Task { await sendeAnfrage() }
                }
                .disabled(prompt.isEmpty || isGenerating)
            }
            .padding(.horizontal)
        }
    }

    private func sendeAnfrage() async {
        isGenerating = true
        antwort = ""

        do {
            let stream = session.streamResponse(to: prompt)
            for try await teilantwort in stream {
                antwort = teilantwort.content
            }
        } catch {
            antwort = "Fehler: \(error.localizedDescription)"
        }

        prompt = ""
        isGenerating = false
    }
}

Die Methode streamResponse gibt eine AsyncSequence von Zwischenergebnissen zurück. Jedes Snapshot-Objekt enthält den aktuellen Stand der Antwort, sodass sich die UI progressiv aktualisiert. Das fühlt sich im Ergebnis richtig flüssig an.

Strukturierte Ausgaben mit @Generable und @Guide

Jetzt wird es richtig spannend. Eine der mächtigsten Funktionen des Frameworks ist die Guided Generation: Statt unstrukturiertem Text kann das Modell typsichere Swift-Structs generieren. Kein fehleranfälliges String-Parsing mehr — du bekommst sofort verwendbare Datenobjekte.

@Generable: Swift-Typen für KI-Ausgaben

Das @Generable-Makro markiert einen Swift-Typ als Zielstruktur für die Modellausgabe. Zur Kompilierzeit wird automatisch ein Schema erzeugt, das dem Modell sagt, welche Felder es befüllen soll.

import FoundationModels

@Generable
struct Rezeptvorschlag {
    let name: String
    @Guide(description: "Eine kurze Beschreibung des Gerichts in einem Satz")
    let beschreibung: String
    @Guide(.count(4))
    let zutaten: [String]
    @Guide(description: "Zubereitungszeit in Minuten", .range(5...120))
    let zubereitungszeit: Int
    @Guide(.anyOf(["Einfach", "Mittel", "Fortgeschritten"]))
    let schwierigkeitsgrad: String
}

@Guide: Einschränkungen und Hinweise

Mit dem @Guide-Makro gibst du dem Modell zusätzliche Constraints mit auf den Weg:

  • .count(n) — exakte Anzahl von Array-Elementen
  • .range(min...max) — Wertebereich für numerische Felder
  • .anyOf([optionen]) — vordefinierte Auswahlmöglichkeiten
  • description: — Freitext-Beschreibung, damit das Modell den Kontext versteht
  • Regex-Muster — strukturelle Vorgaben für Strings

Meiner Erfahrung nach ist gerade die Kombination aus description und .anyOf besonders nützlich, wenn du die Ausgabe wirklich kontrollieren willst.

Strukturierte Daten abrufen

let session = LanguageModelSession()
let rezept = try await session.respond(
    to: "Schlage ein schnelles vegetarisches Abendessen vor",
    generating: Rezeptvorschlag.self
).content

print(rezept.name)              // z.B. "Gemüse-Pad-Thai"
print(rezept.schwierigkeitsgrad) // z.B. "Einfach"
print(rezept.zubereitungszeit)   // z.B. 25

Ein kleiner Tipp am Rande: Das Modell generiert die Felder in der Reihenfolge, wie sie im Struct deklariert sind. Wenn du also zusammenfassende Felder ans Ende packst, hat das Modell beim Generieren bereits alle vorherigen Infos verarbeitet — das verbessert die Ergebnisse spürbar.

Tool Calling: Das Modell mit echten Daten verbinden

Tools erweitern die Fähigkeiten des On-Device-Modells enorm. Du gibst dem Modell damit Zugriff auf externe Datenquellen oder App-Funktionen, und es entscheidet selbstständig, wann ein Tool aufgerufen werden soll.

Ein eigenes Tool definieren

import FoundationModels

struct WetterTool: Tool {
    let name = "AktuellesWetter"
    let description = "Ruft das aktuelle Wetter für eine Stadt ab"

    @Generable
    struct Arguments {
        @Guide(description: "Name der Stadt")
        let stadt: String
    }

    struct Output: ToolOutput {
        let content: String
    }

    func call(arguments: Arguments) async throws -> Output {
        // Hier WeatherKit oder eine andere Quelle nutzen
        let wetter = await fetchWetter(fuer: arguments.stadt)
        return Output(content: "In \(arguments.stadt): \(wetter.temperatur)°C, \(wetter.bedingung)")
    }
}

Tools in der Session registrieren

let tools = [WetterTool()]
let session = LanguageModelSession(tools: tools)

let antwort = try await session.respond(
    to: "Wie ist das Wetter heute in München?"
)
print(antwort.content)

Das Modell analysiert die Anfrage, erkennt, dass es das Wetter-Tool braucht, ruft es auf und baut die Ergebnisse in seine Antwort ein. Wichtig dabei: Das Modell selbst hat keinen Internetzugang — aber dein Tool-Code kann natürlich Netzwerkanfragen durchführen. Die Trennung ist sauber gelöst.

Prewarm und Performance-Optimierung

Das Laden des On-Device-Modells kostet Zeit. Mit prewarm kannst du das Modell vorab initialisieren, bevor der Nutzer überhaupt die erste Anfrage stellt:

struct SmartAssistantView: View {
    @State private var session = LanguageModelSession()

    var body: some View {
        ContentView()
            .task {
                try? await session.prewarm(promptPrefix: "Du bist ein hilfreicher Assistent")
            }
    }
}

Die Performance-Werte sind dabei ziemlich beeindruckend: 0,6 ms Time-to-First-Token auf dem iPhone 15 Pro, bei rund 30 Tokens pro Sekunde Generierungsgeschwindigkeit. Der M4-Chip mit seiner Neural Engine schafft 38 TOPS und ist damit 26-mal schneller als die ursprüngliche Implementierung. Das merkt man in der Praxis deutlich.

Bekannte Einschränkungen

So vielversprechend das alles klingt — es gibt ein paar Limitierungen, die du kennen solltest:

  • Token-Limit: Eingabe und Ausgabe teilen sich ein Budget von 4.096 Tokens. Für längere Konversationen kann das schnell knapp werden
  • Nur Text: Aktuell gibt es ausschließlich Textverarbeitung — Bild- oder Audioanalyse ist (noch) nicht möglich
  • Modellleistung: Das 3-Milliarden-Parameter-Modell ist kein Ersatz für Cloud-LLMs wie GPT-4 oder Claude. Für Zusammenfassungen und Extraktion ist es klasse, aber bei komplexem Reasoning oder Weltwissen stößt es an Grenzen
  • Guardrails: Apples Sicherheitsfilter können gelegentlich False Positives produzieren — teste deine Prompts gründlich
  • Modell-Updates: Apple kann das Modell jederzeit aktualisieren, ohne dass du eine bestimmte Version pinnen kannst. Das ist etwas ungewohnt
  • Codegenerierung: Apple rät explizit davon ab, das Modell für Code- oder Mathe-Aufgaben zu verwenden

Best Practices für die Praxis

  1. Verfügbarkeit immer prüfen: Bau Fallback-Verhalten für Geräte ohne Apple Intelligence ein — das erspart dir viel Support-Ärger
  2. Prompts kurz und präzise halten: Bei nur 4.096 Tokens Budget zählt jedes Token
  3. Guided Generation bevorzugen: Strukturierte Ausgaben sind deutlich zuverlässiger als Freitext-Parsing
  4. Prewarm nutzen: Lade das Modell vor, damit die erste Antwort nicht ewig dauert
  5. Fehlerbehandlung einbauen: Fange LanguageModelSession.GenerationError ab und zeige dem Nutzer verständliche Meldungen
  6. Token-Budget im Blick behalten: Kürze Konversationsverläufe oder starte neue Sessions, wenn das Limit erreicht wird
  7. Offline-Szenarien testen: Das Framework funktioniert ohne Internet — und deine App sollte das auch tun

Foundation Models vs. Cloud-APIs: Wann was nutzen?

Die Entscheidung zwischen On-Device- und Cloud-KI hängt letztlich vom Anwendungsfall ab:

  • Foundation Models eignen sich für: Datenschutzkritische Anwendungen, Offline-Funktionalität, Zusammenfassungen, Inhaltsklassifikation, strukturierte Extraktion und kostenempfindliche Projekte
  • Cloud-APIs sind besser bei: Komplexem Reasoning, umfangreichem Weltwissen, Codegenerierung, multimodalen Aufgaben (Bild + Text) und sehr langen Kontexten

Und natürlich lassen sich beide Ansätze wunderbar kombinieren. Nutze Foundation Models für schnelle, lokale Aufgaben und greife bei Bedarf auf Cloud-Dienste zurück. In der Praxis ist dieser hybride Ansatz oft die beste Lösung.

Häufig gestellte Fragen (FAQ)

Welche Geräte unterstützen das Foundation Models Framework?

Du brauchst Apple Silicon: iPhone 15 Pro (A17 Pro) oder neuer, iPad oder Mac mit M1-Chip oder neuer sowie Apple Vision Pro. Dazu muss iOS 26, iPadOS 26, macOS 26 oder visionOS 26 installiert und Apple Intelligence aktiviert sein.

Ist das Foundation Models Framework kostenlos?

Ja, komplett kostenlos. Keine API-Gebühren, keine Token-Kosten, keine Datenübertragungskosten. Das Modell läuft auf der Hardware des Nutzers — was nebenbei auch bedeutet, dass sich der Ansatz mit wachsender Nutzerbasis automatisch skaliert. Ziemlich clever, eigentlich.

Kann das On-Device-Modell auf das Internet zugreifen?

Nein, das Modell selbst hat keinen Internetzugang. Aber über das Tool-Calling-System kannst du eigene Tools bereitstellen, die Netzwerkanfragen machen. Das Modell ruft diese Tools bei Bedarf automatisch auf und verarbeitet die Ergebnisse.

Wie schneidet das Apple-Modell im Vergleich zu ChatGPT oder Claude ab?

Das 3-Milliarden-Parameter-Modell ist für geräteskalierte Aufgaben optimiert — also Zusammenfassungen, Extraktion, Klassifikation und kurze generative Texte. Für komplexes Reasoning und Weltwissen bleiben Cloud-Modelle klar überlegen. Aber der Vorteil bei Datenschutz, Latenz und Kosten ist nicht zu unterschätzen.

Funktioniert das Framework auch offline?

Ja, und das ist ehrlich gesagt einer der größten Vorteile. Sobald das Modell einmal heruntergeladen und Apple Intelligence aktiviert ist, läuft alles ohne Internet. Deine App kann also auch im Flugmodus oder in Gebieten ohne Netz intelligente Features bieten.

Über den Autor Editorial Team

Our team of expert writers and editors.