Disclaimer

Übersicht

Wichtige Entwickler-Fristen:

Quelle: Apple Developer Releases, Apple Support iOS 26

iOS 26

Version 26.0

Veröffentlicht: 15. September 2025

Build: 23A341

Quelle: Apple Developer Releases, Apple iOS 26 Release Notes

Highlights für Entwickler

Liquid Glass Design Language

• Neues Software-Material "Liquid Glass" – größte Designänderung seit iOS 7 (2013)
• UINavigationBar, UITabBar, UIToolbar, UISegmentedControl erhalten transluzentes Glasmaterial
• UIDesignRequiresCompatibility = true in Info.plist erlaubt vorübergehend den alten Stil (wird in iOS 27 entfernt)
• Automatische Adoption: Apps, die mit dem iOS 26 SDK kompiliert werden, erhalten Liquid Glass auf nativen Steuerelementen

Was Entwickler beachten müssen:

Liquid Glass reagiert auf den Inhalt darunter und wechselt zwischen heller und dunkler Darstellung. Custom NavigationBar-Hintergründe (z. B. setBackgroundImage) brechen dieses Verhalten. Auf echten Geräten testen – der Simulator zeigt Spiegelungen und Bewegungsreaktionen nicht vollständig.

Foundation Models Framework (neu)

Das Foundation Models Framework ist der zentrale Einstiegspunkt für On-Device-KI in eigenen iOS-Apps.

Was ist es?

• Direkter Zugriff auf Apples On-Device-LLM (~3B Parameter) via Swift API
• Das Modell läuft vollständig auf dem Gerät – kein Internet, kein API-Key, keine Cloud-Kosten
• Ermöglicht Textzusammenfassung, Klassifikation, Extraktion, generative Antworten, Chatbots, strukturierte Ausgaben und Tool Calling
• Verfügbar auf iOS 26, iPadOS 26, macOS 26 Tahoe, visionOS 26

Unterstützte Geräte:

• iPhone 15 Pro und iPhone 15 Pro Max
• iPhone 16, iPhone 16 Plus, iPhone 16 Pro, iPhone 16 Pro Max
• iPhone 17 Familie (alle Modelle), iPhone Air
• iPad mit Apple Silicon (M1 und neuer)
• Mac mit Apple Silicon (M1 und neuer)
• Nicht unterstützt: iPhone 15, iPhone 15 Plus (kein Apple Intelligence)

Verfügbarkeit prüfen (Pflicht!):

import FoundationModels

// Vor jeder Nutzung prüfen
guard LanguageModelSession.isAvailable else {
    // Gerät unterstützt Apple Intelligence nicht
    // Fallback-Lösung anzeigen
    return
}

Einfache Abfrage:

import FoundationModels

let session = LanguageModelSession()

// Synchrone Antwort (await)
let response = try await session.respond(to: "Erkläre Swift Concurrency in 3 Sätzen.")
print(response.content)

Streaming (für UIs mit Echtzeit-Ausgabe):

for try await partial in session.streamResponse(to: "Erkläre Liquid Glass.") {
    // Partial-Antwort anzeigen während der Text generiert wird
    updateUI(with: partial)
}

Strukturierte Ausgabe mit @Generable:

import FoundationModels

@Generable
struct TravelRecommendation {
    @Guide("Name des Reiseziels") var destination: String
    @Guide("Empfohlene Reisedauer in Tagen") var duration: Int
    @Guide("Hauptaktivitäten") var activities: [String]
}

let session = LanguageModelSession()
let recommendation: TravelRecommendation = try await session.respond(
    to: "Empfehle ein europäisches Reiseziel für eine Woche.",
    generating: TravelRecommendation.self
)
print(recommendation.destination)

@Generable nutzt Constrained Decoding, das garantiert, dass der Ausgabe-JSON strukturell korrekt ist. Primitive Typen (String, Int, Double, Float, Decimal, Bool) und Arrays sind unterstützt.

Chatbot mit Session-Verlauf:

// LanguageModelSession ist stateful – Transcript wird automatisch geführt
let session = LanguageModelSession(
    instructions: "Du bist ein hilfreicher Swift-Entwickler-Assistent."
)

let antwort1 = try await session.respond(to: "Was ist ein Actor?")
let antwort2 = try await session.respond(to: "Und wie unterscheidet er sich von einer Klasse?")
// Die zweite Frage kennt den Kontext der ersten

Tool Calling (App Intents als Tools):

struct WeatherTool: Tool {
    let name = "getWeather"
    let description = "Gibt das aktuelle Wetter für eine Stadt zurück"
    
    @Parameter var city: String
    
    func call() async throws -> ToolOutput {
        let weather = await WeatherService.fetch(city: city)
        return ToolOutput(weather.description)
    }
}

let session = LanguageModelSession(tools: [WeatherTool()])
let response = try await session.respond(to: "Wie ist das Wetter in München?")

Einschränkungen (offiziell bestätigt):

• Kein System Prompt im traditionellen Sinne – stattdessen instructions-Parameter im Initializer
• Begrenzte Kontextgröße (Genauigkeit: nicht offiziell dokumentiert, Community schätzt ~4k–8k Tokens)
• Rate Limits: Nicht offiziell dokumentiert – bei intensiver Nutzung kann das Modell kurzzeitig pausieren
• Kein Fine-Tuning oder Custom Models
• Sprach-Support: Englisch primär; andere Sprachen funktionieren, aber mit reduzierter Qualität (Nicht von Apple offiziell bestätigt – Community-Erfahrungswerte)

Fehlerbehandlung:

do {
    let response = try await session.respond(to: prompt)
} catch LanguageModelSession.Error.modelUnavailable {
    // Modell nicht verfügbar (Gerät nicht unterstützt oder Apple Intelligence deaktiviert)
} catch LanguageModelSession.Error.contextSizeExceeded {
    // Kontext zu groß – neue Session starten
} catch {
    // Allgemeiner Fehler
}

Was passiert auf nicht unterstützten Geräten?

LanguageModelSession.isAvailable gibt false zurück. Beim direkten Erzeugen einer Session wird ein Fehler geworfen. Immer den Availability-Check einbauen und eine sinnvolle Fallback-UI bereitstellen.

WWDC25 Sessions:

• Session 286: Meet the Foundation Models framework
• Session 301: Deep dive into the Foundation Models framework
• Session 259: Code-along: Bring on-device AI to your app

Metal 4

Metal 4 ist das neue GPU-Framework-Update für iOS 26, macOS 26 und visionOS 26.

Neue Features gegenüber Metal 3:

• MTLTensors: Native Tensor-Unterstützung in der Metal API und Shading Language für ML-Workflows
• MTL4MachineLearningCommandEncoder: Ausführen von ML-Netzwerken direkt auf der GPU-Timeline
• Shader ML: ML-Operationen direkt in Shader-Code einbetten
• Placement Sparse Resources: Effizienteres Ressourcen-Streaming und Memory Management
• Residency Sets: Vereinfachtes Ressourcen-Management für komplexe Szenen
• Native Parallel Encoding: Mehrere Command Encoder parallel befüllen
• MetalFX Upscaling: Verbesserungen für Upscaling, Frame Interpolation und Denoising
• Neues Xcode 26 Metal 4 Template für schnellen Einstieg

Wann ist Migration notwendig?

Metal 3 ist weiterhin vollständig unterstützt. Migration auf Metal 4 ist sinnvoll wenn:

• KI/ML-Inferenz auf der GPU benötigt wird (MTLTensors)
• Maximale Memory-Effizienz erforderlich ist (Placement Sparse Resources)
• Bessere Performance bei Game Rendering gewünscht wird (MetalFX Verbesserungen)
• Neues Projekt: Xcode 26 Metal 4 Template verwenden

Wann kann Metal 3 bleiben?

• Bestehende Render-Pipelines ohne ML-Anforderungen
• Einfache 2D/3D-Rendering-Apps
• Keine sofortige Migrationspflicht

WWDC25 Sessions:

• Session 205: Discover Metal 4
• Session 254: Explore Metal 4 games
• Session 262: Combine Metal 4 machine learning and graphics

SwiftUI: glassEffect APIs

Vollständige Detailbeschreibung siehe Abschnitt SwiftUI – glassEffect API.

Kurzübersicht:

• .glassEffect() – Modifier für das Liquid-Glass-Material
• GlassEffectContainer – ermöglicht koordinierte Animationen mehrerer Glass-Elemente
• glassEffectID – Morphing-Animationen zwischen verbundenen Glaselementen
• .buttonStyle(.glass) und .buttonStyle(.glassProminent)

Weitere neue APIs in iOS 26.0

Nativer WebView in SwiftUI:

• WebView ist jetzt ein natives SwiftUI-View aus dem WebKit-Framework
• Kein UIViewRepresentable-Wrapper mehr notwendig
• Begleitet von WebPage – einem Observable-Modell für Steuerung und JavaScript-Kommunikation
• Vollständige Detailbeschreibung: SwiftUI – WebView

TextEditor erheblich verbessert:

• Rich Text Editing mit AttributedString nativ unterstützt
• Custom Formatierungs-Controls
• Genmoji-Support in TextEditor
• Vollständige Detailbeschreibung: SwiftUI – TextEditor

Chart3D API in Swift Charts:

• 3D-Diagramme direkt in SwiftUI
• PointMark, RuleMark, RectangleMark und neuer SurfacePlot in 3D
• Chart3DPose für Kamerawinkel, orthografische und Perspektivprojektion
• Vollständige Detailbeschreibung: SwiftUI – Chart3D

labelIconToTitleSpacing Modifier:

Label("Einstellungen", systemImage: "gear")
    .labelIconToTitleSpacing(8) // Abstand zwischen Icon und Text in Punkten

DeclaredAgeRange Framework:

• Datenschutzschonendes Altersverifikations-API (gesetzliche Anforderung Texas/Australien)
• Vollständige Detailbeschreibung: App Store – DeclaredAgeRange

Apple Intelligence

• Writing Tools (Umschreiben, Korrekturlesen, Zusammenfassen) plattformweit
• Image Playground und Genmoji verfügbar
• Siri: Produktwissen, robusteres Request-Handling, natürlichere Stimme, Text-Eingabe
• Onscreen-Awareness für Siri
• On-Device-Verarbeitung für viele Funktionen

Deprecated/Breaking Changes in 26.0

UIScene-Lifecycle – Jetzt vorbereiten (Pflicht in iOS 27):

Ab iOS 27 (Xcode 27) ist der UIScene-Lifecycle Pflicht. Apps, die nur AppDelegate verwenden, starten nicht mehr.

// 1. SceneDelegate erstellen
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession,
               options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: windowScene)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }
}

// 2. Info.plist: UIApplicationSceneManifest eintragen
// UIApplicationSceneManifest:
//   UIApplicationSupportsMultipleScenes: NO (oder YES)
//   UISceneConfigurations:
//     UIWindowSceneSessionRoleApplication:
//       - UISceneConfigurationName: Default
//         UISceneDelegateClassName: $(PRODUCT_MODULE_NAME).SceneDelegate

// 3. UIWindow mit windowScene erstellen (statt UIWindow(frame:))
window = UIWindow(windowScene: windowScene) // Korrekt
// window = UIWindow(frame: UIScreen.main.bounds) // Deprecated

Version 26.0.1

Veröffentlicht: 15. September 2025

Build: 23A342 (Tag-1-Update für RC-Nutzer)

Quelle: Apple Developer Releases

Kleines Day-1-Patch für Nutzer, die das Release Candidate Build 23A340 installiert hatten.

Version 26.1

Veröffentlicht: 3. November 2025

Quelle: Apple Support, MacRumors

Entwickler-relevante Änderungen

• Slide-Over wiederhergestellt: Slide-Over-Multitasking (iPad) wurde nach Benutzer-Feedback wieder hinzugefügt
• In iOS 26.0 war Slide-Over entfernt worden, um Platz für die neue Floating-Tab-Bar zu schaffen
• Nach negativem Nutzerfeedback in 26.1 reaktiviert
• Auswirkung für Entwickler: Apps, die Slide-Over-spezifische windowScene-Konfigurationen verwenden, müssen erneut getestet werden
• Liquid-Glass-Feinabstimmungen: Mehr Kontrolle über die Ästhetik für Nutzer
• Stabilitäts- und Qualitätsverbesserungen

Bekanntes Problem (wurde in 26.1 identifiziert):

• Menu in einem GlassEffectContainer kann die Morphing-Animation unterbrechen.

// Workaround für Menu in GlassEffectContainer
Menu("Optionen") {
    Button("Option A") { }
    Button("Option B") { }
}
.glassEffect(.regular.interactive()) // Diese Zeile ist der Workaround

Version 26.2

Veröffentlicht: 12. Dezember 2025

Build: 23C57 (nicht von Apple offiziell bestätigt, Quelle: Community)

Quelle: Apple Developer Release Notes, iClarified

Entwickler-relevante Änderungen

• Apple Music: Offline-Lyrics
• Podcasts: Automatische Kapitel
• Games: Verbesserte Filterung und Navigation
• Apple News: Abschnittslinks im "Heute"-Tab
• Freeform: Tabellen-Unterstützung
• Lock Screen: Transparenz-Regler für die Uhr
• Stabilitätsupdates und Sicherheitspatches
• DeclaredAgeRange SDK-Anforderung: Für vollständige Nutzung des DeclaredAgeRange Frameworks ist ab dieser Version iOS 26.2 SDK (Xcode 26.2) erforderlich

Version 26.2.1

Veröffentlicht: 26. Januar 2026

Quelle: Apple Support

• AirTag (2. Generation) Unterstützung aktiviert
• Bug Fixes

Version 26.3

Veröffentlicht: 11. Februar 2026

Quelle: Apple Developer Release Notes

• Bug Fixes und Sicherheitsupdates
• Keine Breaking Changes für Entwickler dokumentiert

Version 26.4

Veröffentlicht: 24. März 2026

Quelle: Apple Developer Release Notes

Entwickler-relevante Änderungen

• Apple Music und Podcasts: Hintergrundfarbe folgt dem Artwork-Cover (dynamisches Farbschema)

StoreKit: SubscriptionInfo.pricingTerms (neu in 26.4)

iOS 26.4 führt das neue PricingTerms-Modell ein, das Monatsabonnements mit 12-Monats-Binding-Plänen unterstützt:

import StoreKit

// Subscription-Informationen abrufen
for await result in Transaction.currentEntitlements {
    if case .verified(let transaction) = result {
        if let subscription = await transaction.subscriptionStatus {
            // Neue pricingTerms API
            if let pricingTerms = subscription.renewalInfo.pricingTerms {
                print("Binding-Plan: \(pricingTerms.bindingPeriod)")
                print("Preis: \(pricingTerms.price)")
                print("Periode: \(pricingTerms.subscriptionPeriod)")
            }
        }
    }
}

Was sind 12-Monats-Binding-Pläne?

Nutzer können ein Monatsabonnement mit einer 12-Monatsbindung abschließen – ähnlich wie ein Jahresabo, aber monatlich abgerechnet. pricingTerms gibt Entwicklern Zugriff auf die Binding-Konditionen, um sie korrekt in der UI darzustellen.

Wann muss ein Entwickler das implementieren?

• Apps mit StoreKit 2 Auto-Renewable Subscriptions
• Wenn die App Binding-Pläne anbietet oder plant anzubieten
• Für korrekte Darstellung der Konditionen im UI

Version 26.4.1

Veröffentlicht: 11. April 2026

Quelle: Apple Support, Apple Developer

Entwickler-relevante Änderungen

• iCloud-Sync-Bug behoben
• "Stolen Device Protection" wird auf Geräten automatisch aktiviert, auf denen es nach 26.4 noch nicht aktiviert war
• Kein Änderungsbedarf für Entwickler

Version 26.5

Veröffentlicht: 11. Mai 2026

Quelle: Apple Developer Release Notes, MacRumors

Entwickler-relevante Änderungen

• RCS End-to-End-Verschlüsselung: RCS-Nachrichten zwischen iPhone und Android-Nutzern sind nun End-to-End-verschlüsselt
• Auswirkung für Messaging-App-Entwickler: Kein direkter API-Impact auf Drittanbieter-Apps. RCS E2EE ist auf System-Level implementiert.
• Apps, die eigene Messaging-Protokolle nutzen, sind nicht betroffen
• Neue Hintergrundbilder
• EU: Neue Proximity-Pairing-Optionen für Drittanbieter-Wearables
• Drittanbieter-Wearable-Entwickler erhalten neue APIs für Proximity-Pairing-Konfigurationen
• Relevant für Hersteller von Smartwatches, Fitness-Trackern und ähnlichen Geräten, die EU-Regulierungen unterliegen
• Entspricht den EU-Anforderungen zu offenen Schnittstellen
• Bug Fixes und Sicherheitsupdates
• StoreKit APIs: SubscriptionInfo.pricingTerms-Funktionalität ausgebaut (erweitert aus 26.4)

Version 26.5.1

Veröffentlicht: 1. Juni 2026

Build: 23F81

Quelle: Apple Developer Releases, 9to5Mac

Entwickler-relevante Änderungen

• Behebt einen Bug bei einer kleinen Anzahl von iPhone Air und iPhone 17 Modellen, der das kabelgebundene Laden verhinderte, wenn der Akku nahezu entladen war
• Betrifft ausschließlich: iPhone Air und iPhone 17 Familie
• Kein Entwicklungs-Handlungsbedarf

Migration zu iOS 26

Pflicht ab 28. April 2026: iOS 26 SDK

Seit dem 28. April 2026 müssen alle neuen App-Einreichungen und Updates im App Store Connect mit dem iOS 26 SDK (Xcode 26) kompiliert werden. Die Deployment-Target-Einstellung ist davon unabhängig und kann weiterhin auf iOS 16+ gesetzt werden.

Sofortiger Handlungsbedarf für Entwickler:

1. Xcode 26 verwenden – Mindestvoraussetzung für App-Store-Einreichungen
2. Liquid Glass evaluieren – Test mit echtem Gerät notwendig (Simulator stellt Glaseffekte nicht vollständig dar)
3. UIDesignRequiresCompatibility prüfen – Flag kann gesetzt werden, entfällt aber in iOS 27
4. Deprecated APIs ersetzen:

• UIScreen.main → view.window?.windowScene?.screen
• .actionSheet → .confirmationDialog
• SceneKit → RealityKit

1. UIScene-Lifecycle implementieren – In iOS 27 Pflicht, jetzt vorbereiten
2. Neue APIs evaluieren: Foundation Models, glassEffect, Chart3D

Wie teste ich Liquid Glass korrekt?

• Immer auf echtem Gerät testen
• Light Mode und Dark Mode testen
• "Transparenz reduzieren" in Einstellungen aktivieren und prüfen ob Layout korrekt degradiert
• Verschiedene Wallpaper testen (Liquid Glass reagiert auf Hintergrundfarbe)
• Dynamic Type-Größen testen

Liquid Glass Migration:

// Vorher – Custom NavigationBar Background (bricht Liquid Glass)
navigationController?.navigationBar.setBackgroundImage(UIImage(), for: .default)

// Nachher – native Liquid Glass verwenden
// Keine manuelle Anpassung notwendig, native Controls übernehmen Glaseffekt automatisch

// Kompatibilitäts-Flag setzen (temporär, entfällt in iOS 27)
// Info.plist: UIDesignRequiresCompatibility = true

UIDesignRequiresCompatibility:

• Wo setzen: Info.plist → Key UIDesignRequiresCompatibility, Wert YES
• Oder in Xcode: Build Settings → Suche nach "UIDesignRequiresCompatibility"
• Was passiert wenn gesetzt: App behält alten Pre-iOS-26-Look, kein Liquid Glass
• Was passiert wenn nicht gesetzt: App erhält automatisch Liquid Glass auf nativen Controls
• Zeitplan: Entfällt in iOS 27 – bis dahin alle UI-Probleme lösen

// UIScreen.main Migration
// Vorher (deprecated)
let size = UIScreen.main.bounds

// Nachher
let size = view.window?.windowScene?.screen.bounds

// Oder in SwiftUI
GeometryReader { geometry in
    // geometry.size statt UIScreen.main.bounds
}

// actionSheet Migration
// Vorher (deprecated)
.actionSheet(isPresented: $show) {
    ActionSheet(title: Text("Aktion wählen"), buttons: [...])
}

// Nachher
.confirmationDialog("Aktion wählen", isPresented: $show, titleVisibility: .visible) {
    Button("Option A") { }
    Button("Abbrechen", role: .cancel) { }
}

Vollständige Xcode-Projekteinstellungen für iOS 26:

• Minimum Deployment Target: iOS 16+ weiterhin möglich
• Base SDK: iOS 26 (Pflicht für App Store)
• Swift Version: Swift 6 (empfohlen, 5.x weiterhin möglich)
• UIDesignRequiresCompatibility: Nur temporär setzen, bis Liquid Glass korrekt integriert ist
• UIApplicationSceneManifest: Für UIScene-Lifecycle eintragen

iPadOS 26

iPadOS 26 folgt demselben Versions- und Build-Zyklus wie iOS 26. Die Build-Nummern sind identisch.

Version 26.0

Veröffentlicht: 15. September 2025

Build: 23A341

Alle iOS-26.0-Änderungen gelten für iPadOS 26.0. Zusätzlich:

Liquid Glass auf iPad-spezifischen Komponenten:

• UISplitViewController Sidebar erhält Liquid Glass
• Navigationsleiste, Toolbar und Sidebar: floating, über Inhalt
• NavigationSplitView in SwiftUI: neues backgroundExtensionEffect-Modifier erlaubt Views, sich über die Safe Area hinaus zu erstrecken

Floating Tab Bar:

• Tab Bar hebt sich als floating Liquid-Glass-Element über den Inhalt
• UITabBarController mit UITab und UITabGroup für automatische Adaptivität
• Wechsel zwischen Tab Bar und Sidebar erfolgt automatisch (iPad vs. iPhone)
• Auswirkung auf safeAreaInsets: Die Floating-Tab-Bar liegt über dem Inhalt – safeAreaInsets.bottom ändert sich
• Bekanntes Problem: Bei Landscape-Rotation kann safeAreaInsets.top temporär falsche Werte zurückgeben

Stage Manager:

• Neue Window-Resize-Handles in der rechten unteren Ecke
• Window Controls links oben (größer bei Tap)
• Jede App, die Multitasking unterstützt, erhält automatisch diese Controls
• Entwickler-Auswirkung: windowScene-Koordinaten können sich dynamischer ändern – adaptive Layouts wichtiger denn je

Multitasking-Anpassungen:

• Slide-Over war in 26.0 entfernt (wurde in 26.1 reaktiviert)

Version 26.1

Veröffentlicht: 3. November 2025

• Slide-Over wiederhergestellt – war in 26.0 entfernt worden
• Hintergrund: Apple hatte Slide-Over in 26.0 entfernt, um die neue Floating-Tab-Bar zu forcieren; Nutzer-Feedback führte zur Reaktivierung
• Bedeutung für Entwickler: Apps, die Multi-Tasking-Fenster-Konfigurationen verwenden, benötigen erneutes Testing

Version 26.2

Veröffentlicht: 12. Dezember 2025

Identisch mit iOS 26.2. Freeform-Tabellen sind auf iPadOS besonders relevant.

Version 26.3 – 26.5.1

Identisch mit dem iOS-26-Zyklus. Versionsnummern und Builds sind gleich.

Migration

Alle Migrationsschritte aus iOS 26 gelten vollständig für iPadOS 26. Zusätzlich:

• UISplitViewController prüfen – Floating-Tab-Bar verändert safeAreaInsets auf iPad
• UITabBarController mit UITab/UITabGroup migrieren – für korrekte Adaptivität zwischen Tab Bar und Sidebar
• backgroundExtensionEffect evaluieren – für Sidebar-Designs, die sich bis zum Rand erstrecken sollen
• Multitasking-Layouts auf neue Sidebar-Verhaltensweise testen (Stage Manager + Slide-Over)
• Stage Manager auf veränderte windowScene-Koordinaten testen
• Landscape-Rotation-Bug testen: safeAreaInsets.top nach Rotation prüfen

macOS 26 "Tahoe"

Codename: Tahoe

Versionsnummer: 26.x (synchronisiert mit iOS 26)

Darwin-Kernel-Version: 25.x (Build-Nummern beginnen mit "25")

Version 26.0

Veröffentlicht: 15. September 2025

Build: 25A352

Quelle: Apple Developer Release Notes macOS Tahoe

Highlights für Entwickler

Liquid Glass auf macOS:

• NSToolbar: Glass-Material automatisch hinter Toolbar-Items
• Neue style-Property auf NSToolbarItem: .prominent für hervorgehobene Items (nutzt Accent-Farbe)
• Nicht jedes Item soll über Glass erscheinen – prominent-Style nur für wichtige Aktionen
• NSSidebar: Floating Liquid Glass Sidebar
• NSSheet, NSPopover: Erhalten Glass-Hintergrund
• AppKit vs. SwiftUI: SwiftUI-Views bekommen Glass automatisch durch .glassEffect(); AppKit erfordert NSToolbarItem-Konfiguration

Foundation Models auf macOS:

• Verfügbar auf Macs mit Apple Silicon (M1 und neuer)
• Nicht verfügbar auf Intel-Macs – Foundation Models benötigen Apple Neural Engine
• Gleiche Swift API wie auf iOS
• LanguageModelSession.isAvailable gibt auf Intel-Macs false zurück

Metal 4 auf Mac:

• Verfügbar auf Apple Silicon Macs
• MTLTensors für ML-Workflows
• Auf Intel-Macs: Metal 3 weiterhin unterstützt, Metal 4 Features nicht verfügbar

Swift 6.1 mit Xcode 26.0

Wichtige Hinweise für macOS:

• Erste macOS-Version mit synchronisierten Versions- und Build-Schemata (macOS 26 = iOS 26-Zyklus)
• Intel-Mac-Unterstützung weiterhin vorhanden (letztes Release mit Rosetta 2)
• macOS 27 wird ausschließlich Apple Silicon unterstützen ✅ Bestätigt

Hinweis zu Build-Nummern:

macOS-Tahoe-Build-Nummern beginnen mit "25" (Darwin 25.x), obwohl die macOS-Version 26 ist. Quelle: Der Flounder Blog

Version 26.1

Veröffentlicht: 20. Oktober 2025

Quelle: Macworld

• Stabilitätsverbesserungen
• Sicherheitsupdates

Version 26.2

Veröffentlicht: 12. Dezember 2025

Build: 25C56

Quelle: Macworld

• Synchronisiert mit iOS 26.2
• Bug Fixes und Sicherheitsupdates

Version 26.3 / 26.3.1 / 26.3.2

Veröffentlicht: Februar 2026

Quelle: Macworld, Eclectic Light Company

• Schrittweise Bug Fixes
• Sicherheitspatches

Version 26.4

Veröffentlicht: 24. März 2026

Quelle: Macworld

• Synchronisiert mit iOS 26.4
• Bug Fixes

Version 26.4.1

Veröffentlicht: ca. 9. April 2026

Build: 25E253

Quelle: Eclectic Light Company, Apple

• Bugfixes
• Sicherheitsupdate

Version 26.5

Veröffentlicht: 11. Mai 2026

Build: 25F71

Quelle: Apple Developer Release Notes macOS 26.5, Eclectic Light Company

• Bug Fixes und Sicherheitsupdates

Version 26.5.1

Veröffentlicht: 1. Juni 2026

Build: 25F80

Quelle: Thurrott, Apple

• Synchronisiert mit iOS 26.5.1
• Sicherheitspatch

Migration

• Rosetta 2 ist noch verfügbar – macOS Tahoe (26) unterstützt weiterhin Intel-Macs und Rosetta 2
• macOS 27 wird ausschließlich Apple Silicon unterstützen ✅ Bestätigt
• Intel-only Targets können evaluiert werden
• CI/CD-Pipelines auf Apple Silicon vorbereiten
• Universal Binaries empfohlen, noch nicht Pflicht
• Foundation Models: Nur auf Apple Silicon – isAvailable auf Intel false
• NSToolbarItem: .style = .prominent für korrekte Liquid-Glass-Darstellung prüfen

watchOS 26

Version 26.0

Veröffentlicht: 9. September 2025 (Vorab) / 15. September 2025 (offiziell mit iPhone)

Build: 23R352

Liquid Glass auf watchOS:

• Komplikationen und Zifferblätter erhalten Liquid Glass
• Neue adoptingLiquidGlass-API für fine-tuning (nicht offiziell bestätigt, Community-Quelle)
• Entwickler sollten offizielle Dokumentation zu "Adopting Liquid Glass" prüfen

Apple Intelligence auf watchOS:

• Verfügbar auf Apple Watch Ultra 2 und neueren Modellen
• Foundation Models Framework: Nicht verfügbar auf watchOS (Nicht offiziell bestätigt – zu wenig RAM/Neural Engine Kapazität auf Watch)
• Siri-Verbesserungen durch Apple Intelligence verfügbar

WidgetKit auf watchOS 26:

• Push-Updates für Widgets via APNs jetzt auf watchOS möglich
• ClockKit-Komplikationen: Migration zu WidgetKit jetzt notwendig (APNs-Push-Updates nur in WidgetKit)
• Smart Stack: Relevante Widgets erscheinen automatisch basierend auf Routine, Standort, usw.
• Neue Smart Stack-Signale: Points of Interest für standortbasierte Widget-Relevanz
• Mehrere Instanzen desselben Widgets im Smart Stack gleichzeitig möglich

HealthKit/WorkoutKit:

• Apps mit HKWorkoutActivityType: Korrekt konfigurieren für Smart Stack-Vorschläge
• HKWorkoutRouteBuilder: Standortdaten für bessere Workout-Vorschläge nutzen

Version 26.0.1 und 26.0.2

Veröffentlicht: September 2025

Build 26.0.1: 23R8362

• Stabilitätsupdates

Version 26.1

Veröffentlicht: 3. November 2025

• Stabilitätsverbesserungen
• Sprach-Aktualisierungen (zusätzliche Siri-Sprachen)

Version 26.2

Veröffentlicht: 12. Dezember 2025

• Bug Fixes

Version 26.2.1

Veröffentlicht: 26. Januar 2026

• AirTag (2. Generation) Unterstützung

Version 26.3

Veröffentlicht: 11. Februar 2026

• Bug Fixes und Sicherheitsverbesserungen

Version 26.5

Veröffentlicht: 11. Mai 2026

Quelle: Apple Developer Release Notes watchOS 26.5

• Bug Fixes und Sicherheitsupdates

Migration

• ClockKit → WidgetKit Migration: Jetzt durchführen – Push-Updates via APNs sind nur in WidgetKit verfügbar
• watchOS-26-Apps mit HealthKit oder WorkoutKit auf neue Berechtigungsmodelle prüfen
• HKWorkoutActivityType korrekt setzen – beeinflusst Smart Stack-Vorschläge
• Liquid-Glass-Komplikationen auf Apple Watch Ultra 2 testen
• Controls: iOS-Controls werden automatisch auf watchOS 26 geteilt

SwiftUI

Neue Features

glassEffect API

Das neue primäre API für Liquid-Glass-Material in SwiftUI.

Was ist es und warum ist es wichtig?

Liquid Glass ist Apples neue Design Language. In SwiftUI ist .glassEffect() der Standardweg, um dieses Material in eigene Views zu integrieren. Ohne korrekte Implementierung sehen Custom Controls in iOS 26 aus wie Fremdkörper im System-UI.

Alle Parameter und Optionen:

// Standardform – Capsule-Form, kein Tint
myView
    .glassEffect()

// Mit eigener Form
myView
    .glassEffect(.regular, in: RoundedRectangle(cornerRadius: 16))

// Mit Tint (Farbe hinzufügen)
myView
    .glassEffect(.regular.tint(.blue))

// Für interaktive Elemente (Custom Controls, Buttons in Containern)
myView
    .glassEffect(.regular.interactive())

// Kombiniert: Form + Tint + Interactive
myView
    .glassEffect(.regular.interactive().tint(.blue), in: Circle())

GlassEffectContainer – wann und wie verwenden:

GlassEffectContainer fasst mehrere Liquid-Glass-Shapes zu einer einzigen Form zusammen und ermöglicht Morphing zwischen ihnen. Verwenden wenn:

• Mehrere Glass-Elemente in einer Ansicht koordiniert animiert werden sollen
• Beim Wechsel zwischen Zuständen (z.B. Tab-Wechsel) ein fließender Übergang gewünscht ist

@Namespace var glassNamespace

GlassEffectContainer(spacing: 8) {
    // Zwei Glass-Elemente die ineinander morphen können
    Button("Aktion A") { activeTab = "a" }
        .glassEffectID("a", in: glassNamespace)
    
    Button("Aktion B") { activeTab = "b" }
        .glassEffectID("b", in: glassNamespace)
}
.animation(.spring, value: activeTab)

glassEffectID – Morphing und Namespaces:

glassEffectID(_:in:) verknüpft Glass-Effekte mit einer Identität, sodass SwiftUI beim Wechsel zwischen Zuständen eine Morphing-Animation durchführen kann:

@Namespace var ns

// Tab 1 aktiv
if activeTab == 1 {
    Rectangle()
        .glassEffect()
        .glassEffectID("tab", in: ns)
}

// Tab 2 aktiv
if activeTab == 2 {
    Circle()
        .glassEffect()
        .glassEffectID("tab", in: ns)
}
// Das Glass-Element morpht flüssig zwischen Rechteck und Kreis

Button-Stile:

// .glass: Standard-Glasbutton
Button("Standard") { }
    .buttonStyle(.glass)

// .glassProminent: Hervorgehobener Glasbutton (mit Accent-Farbe getönt)
Button("Primär") { }
    .buttonStyle(.glassProminent)

// Unterschied: .glass ist für normale Aktionen, .glassProminent für die primäre Aktion
// .glassProminent verwendet die App's Accent Color als Tint

Tinting:

// Tint über .glassEffect Modifier
myView.glassEffect(.regular.tint(.purple))

// Tint via tint() Modifier
myView
    .glassEffect()
    .tint(.orange) // Beeinflusst den Glass-Tint

Accessibility – Reduce Transparency:

• Mit "Transparenz reduzieren" (UIAccessibility.isReduceTransparencyEnabled) erhält Glass einen opaken Hintergrund
• SwiftUI handhabt das automatisch bei nativen Controls
• Bei Custom Glass-Views: Immer mit "Transparenz reduzieren" aktiviert testen
• Fallback implementieren:

@Environment(\.accessibilityReduceTransparency) var reduceTransparency

if reduceTransparency {
    myView.background(.regularMaterial)
} else {
    myView.glassEffect()
}

Deployment Target Absicherung:

if #available(iOS 26, *) {
    myView.glassEffect()
} else {
    myView.background(.regularMaterial)
}

Simulator-Einschränkungen:

• Echte Spiegelungen und Lichtbrechung: Nur auf physischen Geräten
• Bewegungsreaktionen (Gyroscope): Nur auf physischen Geräten
• Grundlegende Transparenz-Darstellung: Im Simulator vorhanden

Bekannte Probleme und Workarounds:

• Menu in GlassEffectContainer unterbricht Morphing → .glassEffect(.regular.interactive()) auf Menu
• Zu viele GlassEffectContainer nebeneinander können Performance beeinflussen → Container sparsam einsetzen

Referenzen:

• Applying Liquid Glass to custom views
• WWDC25 Session 323: Build a SwiftUI app with the new design
• WWDC25 Session 219: Meet Liquid Glass

Nativer WebView

iOS 26 führt mit dem WebKit-Framework eine native SwiftUI-View ein.

Warum wichtig?

Vorher mussten alle Entwickler einen UIViewRepresentable-Wrapper um WKWebView bauen – mit manuellem Coordinator-Pattern. Das entfällt jetzt.

Vergleich alt vs. neu:

// ALT – UIViewRepresentable Wrapper (weiterhin funktioniert, aber unnötig)
struct LegacyWebView: UIViewRepresentable {
    let url: URL
    func makeUIView(context: Context) -> WKWebView { WKWebView() }
    func updateUIView(_ view: WKWebView, context: Context) {
        view.load(URLRequest(url: url))
    }
}

// NEU – Native SwiftUI WebView (iOS 26+)
import SwiftUI
import WebKit

struct ContentView: View {
    var body: some View {
        WebView(url: URL(string: "https://example.com")!)
    }
}

WebPage – Observable Modell für Steuerung:

import SwiftUI
import WebKit

struct ContentView: View {
    @State private var page = WebPage()
    
    var body: some View {
        VStack {
            // Navigation Controls
            HStack {
                Button("Zurück") { page.goBack() }
                    .disabled(!page.canGoBack)
                Button("Vor") { page.goForward() }
                    .disabled(!page.canGoForward)
                Button("Laden") { page.reload() }
            }
            
            WebView(page)
                .onAppear {
                    page.load(URLRequest(url: URL(string: "https://example.com")!))
                }
        }
    }
}

JavaScript-Bridge:

// JavaScript ausführen
let result = try await page.evaluateJavaScript("document.title")

// Nachricht von JavaScript empfangen
page.addMessageHandler(forName: "myHandler") { message in
    print("Von JS empfangen: \(message)")
}

URL-Scheme-Handler:

// Eigenes URL-Schema verarbeiten
class MySchemeHandler: URLSchemeHandler {
    func urlSchemeTask(_ task: URLSchemeTask, start: () -> Void) {
        // Eigene Daten für myapp:// URLs liefern
        let data = Data("Custom Content".utf8)
        task.didReceiveResponse(...)
        task.didReceiveData(data)
        task.didFinish()
    }
}

let config = WebPageConfiguration()
config.setURLSchemeHandler(MySchemeHandler(), forURLScheme: "myapp")
let page = WebPage(configuration: config)

Was muss migriert werden?

• UIViewRepresentable-Wrapper um WKWebView können durch natives WebView ersetzt werden
• Coordinator-Patterns für Navigation und Callbacks können durch WebPage ersetzt werden
• Bestehender WKWebView-Code funktioniert weiterhin (kein Breaking Change)

WWDC25 Session: Session 231: Meet WebKit for SwiftUI

Chart3D

Swift Charts erhält 3D-Unterstützung in iOS 26.

Verfügbare Diagrammtypen in Chart3D:

• PointMark (mit Z-Achse erweitert) – 3D-Scatter-Plot
• RuleMark (mit Z-Achse) – 3D-Linien
• RectangleMark (mit Z-Achse) – 3D-Balken
• SurfacePlot – einzigartiger 3D-Typ, der mathematische Flächen darstellt (Erweiterung von LinePlot)

Hinweis: Separate BarMark3D- oder LineMark3D-Typen existieren laut offizieller Dokumentation nicht – bestehende Marks wurden für 3D erweitert. (Quelle: WWDC25 Session 313)

Grundlegendes Beispiel:

import Charts
import SwiftUI

struct ContentView: View {
    let data = [
        DataPoint(x: 1, y: 2, z: 3),
        DataPoint(x: 2, y: 4, z: 1),
        DataPoint(x: 3, y: 1, z: 5)
    ]
    
    var body: some View {
        Chart3D(data, id: \.id) { point in
            PointMark(
                x: .value("X", point.x),
                y: .value("Y", point.y),
                z: .value("Z", point.z)
            )
        }
    }
}

Achsen-Konfiguration:

Chart3D(data, id: \.id) { point in
    PointMark(
        x: .value("Monat", point.month),
        y: .value("Umsatz", point.revenue),
        z: .value("Kosten", point.costs)
    )
}
.chartXAxis { ... }
.chartYAxis { ... }
.chartZAxis { ... } // Neue Z-Achse
.chartZScale(domain: 0...100) // Z-Skalierung

Kamerawinkel und Chart3DPose:

Chart3D(data, id: \.id) { ... }
    .chart3DPose(.front) // Vorderansicht
    // Oder:
    .chart3DPose(Chart3DPose(azimuth: .degrees(45), inclination: .degrees(30)))
    // azimuth: links/rechts Rotation
    // inclination: oben/unten Neigung

Kamera-Projektionen:

// Orthografisch (Standard) – parallele Linien bleiben parallel
Chart3D(data) { ... }
    .chart3DCameraProjection(.orthographic)

// Perspektiv – weiter entfernte Punkte erscheinen kleiner
Chart3D(data) { ... }
    .chart3DCameraProjection(.perspective)

Interaktivität:

• Standardmäßig sind Chart3D-Diagramme drehbar (Touch/Maus)
• Zoom via Pinch-Geste

SurfacePlot für mathematische Flächen:

Chart3D {
    SurfacePlot(x: "X", z: "Z", y: "Y") { x, z in
        // Mathematische Funktion: y = sin(x) * cos(z)
        return sin(x) * cos(z)
    }
}

Performance-Tipps:

• Chart3D ist rechenintensiver als 2D-Charts – große Datensätze aggregieren
• Auf älteren Geräten (iPhone 15 non-Pro) testen
• @preconcurrency vermeiden in Chart3D-Datenmodellen

Deployment Target Absicherung:

if #available(iOS 26, *) {
    Chart3D(data) { ... }
} else {
    Chart(data) { ... } // 2D Fallback
}

WWDC25 Session: Session 313: Bring Swift Charts to the third dimension

TextEditor Verbesserungen

Der SwiftUI TextEditor unterstützt ab iOS 26 Rich Text Editing.

Was ist neu?

// Vorher: Nur Plain Text
@State private var text = ""
TextEditor(text: $text)

// Neu: Rich Text mit AttributedString
@State private var attributedText = AttributedString()
TextEditor(text: $attributedText) // Jetzt mit AttributedString!

Custom Formatierungs-Controls:

// AttributedString manipulieren
var boldText = attributedText
boldText[selectedRange].bold = true

// Schriftgröße ändern
boldText[selectedRange].font = .systemFont(ofSize: 18)

Cross-App Rich Text mit AttributedTextFormattingDefinition:

// Eigene Formatierungs-Attribute definieren, die zwischen Apps übertragen werden können
struct MyFormattingDefinition: AttributedTextFormattingDefinition {
    static var attributes: [any CodableAttributedStringKey.Type] {
        [MyCustomAttribute.self]
    }
}

Genmoji-Support:

// Genmoji-Eingabe in TextEditor aktivieren (automatisch in iOS 26)
TextEditor(text: $attributedText)
// Genmoji werden als spezielle AttributedString-Attachments verarbeitet

Was können Entwickler jetzt machen, was vorher nicht möglich war?

• Rich Text direkt in SwiftUI ohne UIViewRepresentable/NSViewRepresentable
• Cross-App Formatierung mit CodableAttributedStringKeys
• Benutzerdefinierte Formatierungs-Toolbars
• Genmoji nativ in eigene Text-Views

WWDC25 Session: Session 280: Code-along: Cook up a rich text experience in SwiftUI with AttributedString

Breaking Changes

actionSheet deprecated ✅ Bestätigt

// Nicht mehr verwenden (deprecated in iOS 26)
.actionSheet(isPresented: $showingActionSheet) {
    ActionSheet(title: Text("Aktion wählen"), buttons: [...])
}

// Korrekte Verwendung
.confirmationDialog("Aktion wählen", isPresented: $showingActionSheet, titleVisibility: .visible) {
    Button("Option A") { }
    Button("Abbrechen", role: .cancel) { }
}

UIScreen.main deprecated ✅ Bestätigt

In SwiftUI: GeometryReader oder windowScene.screen verwenden.

// SwiftUI
GeometryReader { geometry in
    let screenWidth = geometry.size.width
}

// UIKit
let screenBounds = view.window?.windowScene?.screen.bounds

Bekannte Probleme

• iOS 26.1: Menu in GlassEffectContainer kann Morphing-Animation unterbrechen. Workaround: .glassEffect(.regular.interactive()) direkt auf Menu verwenden.
• Liquid Glass im Simulator: Spiegelungen und Bewegungsreaktionen werden im Simulator nicht vollständig dargestellt. Immer auf echten Geräten testen.
• Reduce Transparency: Mit aktiviertem "Transparenz reduzieren" sollen alle Glass-Layouts korrekt degradieren. Immer testen.
• iPadOS safeAreaInsets: Nach Landscape-Rotation kann safeAreaInsets.top falsche Werte zurückgeben – erst nach App-Hintergrundlegung aktualisiert.

Beispiele

Deployment-Target-Absicherung für Liquid Glass

if #available(iOS 26, *) {
    myView.glassEffect()
} else {
    myView.background(.regularMaterial)
}

Foundation Models Framework

import FoundationModels

guard LanguageModelSession.isAvailable else {
    showFallbackUI()
    return
}

let session = LanguageModelSession()

// Einfache Antwort
let response = try await session.respond(to: "Erkläre Swift Concurrency in 3 Sätzen.")
print(response.content)

// Streaming
for try await partial in session.streamResponse(to: "Erkläre Liquid Glass.") {
    print(partial)
}

Vollständiges Chatbot-Beispiel

import SwiftUI
import FoundationModels

@Observable
class ChatViewModel {
    var messages: [ChatMessage] = []
    var inputText = ""
    private var session: LanguageModelSession?
    
    init() {
        guard LanguageModelSession.isAvailable else { return }
        session = LanguageModelSession(
            instructions: "Du bist ein hilfreicher iOS-Entwickler-Assistent."
        )
    }
    
    func sendMessage() async {
        guard let session, !inputText.isEmpty else { return }
        let userMessage = inputText
        inputText = ""
        messages.append(ChatMessage(role: .user, content: userMessage))
        
        var assistantMessage = ChatMessage(role: .assistant, content: "")
        messages.append(assistantMessage)
        let lastIndex = messages.count - 1
        
        do {
            for try await partial in session.streamResponse(to: userMessage) {
                messages[lastIndex].content = partial
            }
        } catch {
            messages[lastIndex].content = "Fehler: \(error)"
        }
    }
}

Swift 6

Neue Features

Swift 6.1 (Xcode 26.0 – 26.2)

• Kompilier-Cache als Opt-in-Feature (beschleunigt iterative Build/Test-Zyklen)
• Swift Explicit Modules jetzt Standard für alle Swift-Targets
• Bounds Safety für C: -fbounds-safety Spracherweiterung mit automatischer Bounds-Prüfung

Typed Throws (Swift 6)

Funktionen können jetzt spezifische Fehlertypen werfen:

// ALT: throws wirft Any Error
func riskyOperation() throws -> String {
    throw NetworkError.timeout
}

// NEU: typed throws mit konkretem Fehlertyp
enum NetworkError: Error {
    case timeout, noConnection, unauthorized
}

func riskyOperation() throws(NetworkError) -> String {
    throw NetworkError.timeout
}

// Aufruf: catch kennt den konkreten Typ
do {
    let result = try riskyOperation()
} catch let error: NetworkError {
    switch error {
    case .timeout: print("Timeout")
    case .noConnection: print("Keine Verbindung")
    case .unauthorized: print("Nicht autorisiert")
    }
    // Kein default-Fall notwendig – alle Fälle sind bekannt
}

Warum wichtig? Keine Typumwandlungen, kein error as? NetworkError, vollständige Switch-Exhaustivität.

Non-Copyable Types / ~Copyable

Typen die nicht kopiert werden dürfen (einzigartige Ressourcen):

// ~Copyable: Dieser Typ kann nicht kopiert werden
struct FileHandle: ~Copyable {
    private let fd: Int32
    
    init(path: String) {
        fd = open(path, O_RDONLY)
    }
    
    // deinit garantiert, dass handle geschlossen wird
    deinit {
        close(fd)
    }
}

// Verwendung: Ownership wird explizit übergeben
func processFile(_ handle: consuming FileHandle) {
    // handle gehört jetzt dieser Funktion
}

// Fehler: Kopieren ist nicht erlaubt
let handle1 = FileHandle(path: "/tmp/test")
let handle2 = handle1 // ❌ Compile-Fehler: ~Copyable kann nicht kopiert werden

~Copyable Generics:

// Generic Code der mit ~Copyable Types funktioniert
func useOnce<T: ~Copyable>(_ value: consuming T) {
    // value wird genau einmal verwendet
}

Embedded Swift

Swift 6 enthält einen Preview-Modus für Embedded-Entwicklung (Microcontroller, ressourcenbeschränkte Umgebungen):

• Reduzierte Swift-Runtime-Größe
• Kein Garbage Collector / ARC-Overhead
• Einschränkungen: Typed Throws und do/catch nicht in allen Closures verfügbar (bekanntes Problem)

Quelle: Announcing Swift 6 – Swift.org

Swift 6.2 (Xcode 26.3)

• Allgemeine Performance-Verbesserungen
• Stack-Allocation-Bug in async-Funktionen (bekanntes Problem, in 6.3 behoben)

Swift 6.3 (Xcode 26.4)

• Behebt Stack-Allocation-Bugs in async-Funktionen aus 6.2
• MetricKit-Crash-Fix: Crash bei MetricKit-Apps durch fehlende Symbole auf iOS < 26.4 wurde behoben – Rebuild mit Xcode 26.4.1 empfohlen
• Erweiterte C++-Interoperabilität

Swift 6.3.1 (Xcode 26.4.1)

• Bug Fix für MetricKit-Crash

Swift 6.3.2 (Xcode 26.5)

• Weitere Stabilisierungen

Concurrency

Swift 6 Strict Concurrency ist der neue Standard.

Was bedeutet Strict Concurrency konkret?

Der Compiler prüft jetzt zur Compile-Zeit, ob Daten sicher zwischen verschiedenen Concurrency-Domänen (Actors, Tasks) übergeben werden. In Swift 5.x gab es nur Warnungen, in Swift 6 sind es Fehler.

Häufige Migration-Fehler:

// FEHLER: Non-Sendable type in async context
class MyViewModel {
    var data: [String] = [] // Non-Sendable!
    
    func loadData() async {
        // ❌ Swift 6 Fehler: Cannot pass non-sendable value
        await someActor.process(self)
    }
}

// LÖSUNG 1: @MainActor für UI-gebundene ViewModels
@MainActor
class MyViewModel {
    var data: [String] = [] // Sicher auf Main Actor
    
    func loadData() async {
        data = await NetworkService.fetch()
    }
}

// LÖSUNG 2: Sendable Conformance
final class MyData: Sendable {
    let items: [String] // let + final = implizit Sendable
    init(items: [String]) { self.items = items }
}

@MainActor – wann verwenden?

• ViewModels die SwiftUI-Views bedienen: immer @MainActor
• UI-Updates: immer auf Main Actor
• Aber: Nicht überall verwenden – verhindert echte Parallelität

// Gut: @MainActor für ViewModel
@MainActor
class ProfileViewModel: ObservableObject {
    @Published var username = ""
    
    func load() async {
        // Network call außerhalb des Main Actors
        let name = await networkService.fetchUsername()
        // Zurück auf Main Actor für UI-Update
        username = name
    }
}

Sendable Conformance:

// Struct ist automatisch Sendable wenn alle Properties Sendable sind
struct Config: Sendable {
    let timeout: TimeInterval // Double ist Sendable
    let maxRetries: Int // Int ist Sendable
}

// Enum ist Sendable wenn alle associated values Sendable sind
enum Action: Sendable {
    case fetch(url: URL) // URL ist Sendable
    case cancel
}

// Class: Explizit markieren + sicherstellen dass thread-safe
final class Cache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Any] = [:]
    
    func set(_ value: Any, for key: String) {
        lock.lock()
        storage[key] = value
        lock.unlock()
    }
}

Actor vs. Class:

// Actor: Thread-safe by default, serialisierter Zugriff
actor DataStore {
    private var data: [String] = []
    
    func append(_ item: String) {
        data.append(item) // Kein Lock notwendig
    }
    
    func getAll() -> [String] { data }
}

// Class: Manuelles Synchronisieren erforderlich
class DataStoreClass {
    private let queue = DispatchQueue(label: "datastore")
    private var data: [String] = []
    
    func append(_ item: String) {
        queue.sync { data.append(item) }
    }
}

Structured Concurrency mit TaskGroup:

// Parallele Tasks mit TaskGroup
func loadImages(urls: [URL]) async throws -> [UIImage] {
    try await withThrowingTaskGroup(of: UIImage.self) { group in
        for url in urls {
            group.addTask {
                try await URLSession.shared.fetchImage(from: url)
            }
        }
        
        var images: [UIImage] = []
        for try await image in group {
            images.append(image)
        }
        return images
    }
}

Breaking Changes

• Strict Concurrency: Beim Upgrade auf Swift 6 können Concurrency-Fehler auftauchen, die in Swift 5.x als Warnungen behandelt wurden
• Lösung: Schrittweise Migration – Swift 6 kann auch im Swift 5 Compatibility Mode betrieben werden
• Xcode Build Setting: Swift Language Version = Swift 5 behält alte Semantik
• MetricKit: Apps, die mit Xcode 26.4 (Swift 6.3) gebaut wurden, können auf iOS < 26.4 abstürzen. Lösung: Mit Xcode 26.4.1 (Swift 6.3.1) neu bauen
• Typed Throws: Generischer Code der Fehler weiterleitet muss any Error oder rethrows überprüfen

Xcode 26

IDE

Xcode 26.0 – Initial Release (15. September 2025)

Build: 17A345 (nicht offiziell bestätigt)

Quelle: Xcode 26 Release Notes

Compilation Caching (Opt-in):

• Cacht Kompilierungsergebnisse für Swift und C auf Modulebene
• Was wird gecacht: Vollständig kompilierte Module, nicht nur PCH-Dateien
• Wie aktivieren: Xcode Build Settings → Compilation Caching = Enabled
• Performance: Branch-Wechsel und Clean Builds deutlich schneller (Community berichtet 30–60% Verbesserung bei großen Projekten – nicht von Apple bestätigt)
• Einschränkungen: DerivedData muss zwischen CI-Runs erhalten bleiben; bei sehr kleinen Projekten kaum Unterschied

Swift Explicit Modules als Standard:

• Was sind Explicit Modules? Jedes Swift-Modul wird explizit und deterministisch gebaut – keine impliziten Modulabhängigkeiten mehr
• Vorteile: Schnellere parallele Builds, bessere Fehlerdiagnose, deterministisches Build-Verhalten
• Mögliche Probleme: Modul-Dependency-Cycle-Fehler können bei SPM-Paketen auftreten
• Fehler: "Module dependency cycle" → In Xcode 26 Developer Forums dokumentiert
• Workaround: Explizite Abhängigkeiten im Package.swift prüfen und auflösen
• Wie deaktivieren: Build Settings → Enable Explicit Module Dependencies = NO (nur als temporäres Workaround)

Enhanced Security:

• Runtime Pointer Authentication: Pointer Authentication Codes (PAC) für kritische Pointer
• Sandbox-Verbesserungen: Strengere App-Sandbox für neue Apps
• Was bedeutet das für Entwickler: Apps die Low-Level-Pointer-Manipulation nutzen (z.B. JIT-Compiler) müssen geprüft werden

LLM-Integration:

• ChatGPT (GPT-4.1 / GPT-5) und Claude (Claude Sonnet 4) direkt in Xcode integriert
• Fähigkeiten im Xcode-Kontext:
• Code generieren und erklären
• Tests schreiben
• Dokumentation generieren
• Refactoring-Vorschläge
• Fehlerbehebung und Debugging
• Datenschutz: Code-Snippets werden an externe APIs gesendet (OpenAI/Anthropic). Für sensible Projekte: Feature deaktivieren
• Konfiguration: Xcode → Settings → LLM Providers → API Keys eingeben

UIDesignRequiresCompatibility:

• Wo setzen: Xcode → Target → Build Settings → Suche "UIDesignRequiresCompatibility"
• Oder: Info.plist → Key UIDesignRequiresCompatibility → Wert YES
• Was passiert wenn gesetzt: App behält iOS 25 und älter Look – kein Liquid Glass, alte Tab Bar, alte Navigation Bar
• Was passiert wenn nicht gesetzt: App erhält automatisch Liquid Glass auf allen nativen UI-Komponenten
• Zeitplan: Das Flag wird in iOS 27 (Xcode 27) ignoriert und ist dann wirkungslos

Xcode 26.0.1

Quelle: Xcode 26.0.1 Release Notes

• Bug Fixes

Xcode 26.1 / 26.1.1

Quelle: Xcode 26.1.1 Release Notes

• Stabilitätsverbesserungen

Xcode 26.2

Quelle: Xcode 26.2 Release Notes

• Predictive Code Completion verbessert (LLM-basiert)
• Bug Fixes

Xcode 26.3 (Swift 6.2)

Quelle: Xcode 26.3 Release Notes

• Swift 6.2 eingeführt
• Weitere IDE-Verbesserungen

Xcode 26.4 (Swift 6.3)

Quelle: Apple Developer

• Swift 6.3
• Breitere On-Device-Debugging-Unterstützung
• SDKs für iOS 26.4, iPadOS 26.4, tvOS 26.4, macOS 26.4, visionOS 26.4

Xcode 26.4.1 (Swift 6.3.1)

Quelle: Xcode 26.4.1 Release Notes

• MetricKit-Crash-Fix (fehlende Symbole auf iOS/macOS/visionOS < 26.4)
• Swift Compiler: Stack-Allocation-Bug in async-Funktionen behoben
• Empfehlung: Apps, die mit Xcode 26.4 gebaut wurden und MetricKit verwenden, müssen mit Xcode 26.4.1 neu gebaut werden

Xcode 26.5 (Swift 6.3.2) – Aktuelle Version

Quelle: Medium (CodeX), Apple Developer

• Swift 6.3.2
• Bug Fixes und Stabilitätsverbesserungen

Simulator

• Liquid Glass Einschränkungen (konkret):
• Echte Lichtbrechung/Spiegelung: Nicht dargestellt (Simulator zeigt vereinfachte Transparenz)
• Gyroscope-basierte Bewegungsreaktionen: Nicht vorhanden
• Hintergrundreaktion auf dynamische Inhalte (z.B. Video hinter Glass): Eingeschränkt
• Konsequenz: Immer auf echtem Gerät finales Testing durchführen
• Accessibility testen im Simulator:
• Simulator → I/O → Accessibility → Reduce Transparency: Hier aktivieren
• Oder: Simulator Gerät → Einstellungen → Bedienungshilfen → Darstellung → Transparenz reduzieren
• Allgemeine Performance-Verbesserungen im Simulator

Debugging

• Breitere On-Device-Debugging-Unterstützung (ab Xcode 26.4)
• Instruments Neuerungen für Metal 4:
• Neue Tensor-Profiling-Ansicht für MTLTensors (ML-Debugging)
• Verbesserte GPU-Timeline für Metal 4 Command Encoders
• LLDB: Verbesserte Unterstützung für Swift 6 Concurrency-Debugging (Actor-States, Task-Trees)
• Verbesserte Instruments-Integration allgemein

Testing

Swift Testing Framework vs. XCTest:

Parallel-Test-Execution aktivieren:

// Swift Testing: Automatisch parallel (kein Code nötig)
@Test("Async Fetch")
func testFetch() async throws {
    let result = try await NetworkService.fetch()
    #expect(result.count > 0)
}

// Tests die NICHT parallel laufen sollen:
@Test(.serialized)
func testDatabaseWrite() {
    // Läuft seriell
}

Migration von XCTest zu Swift Testing:

// XCTest
class MyTests: XCTestCase {
    func testExample() {
        XCTAssertEqual(1 + 1, 2)
    }
}

// Swift Testing Äquivalent
@Test("Beispiel Test")
func example() {
    #expect(1 + 1 == 2)
}

UI-Tests mit Liquid Glass:

• UI-Tests prüfen Glass-Effekte nicht direkt (kein visueller Snapshot-Test in Xcode UI Tests)
• Für visuelle Tests: Snapshot-Testing-Bibliotheken (z.B. SnapshotTesting) auf echtem Gerät nutzen
• Accessibility-Tests funktionieren normal: XCUIElement.exists, isHittable usw.

Apple Intelligence

Apple Intelligence ist mit iOS 26, iPadOS 26 und macOS Tahoe 26 allgemein verfügbar.

Unterstützte Geräte (iOS 26):

• iPhone 15 Pro und neuer
• iPhone 16 Familie (alle Modelle)
• iPhone 17 Familie (alle Modelle)
• iPhone Air

Funktion | Status | Quelle

---|---|---

Writing Tools (Umschreiben, Korrekturlesen, Zusammenfassen) | ✅ Verfügbar | Apple

Image Playground | ✅ Verfügbar | Apple

Genmoji | ✅ Verfügbar | Apple

Siri mit Produktwissen | ✅ Verfügbar | Apple

Siri Onscreen-Awareness | ✅ Verfügbar | Apple

Clean Up (Fotos) | ✅ Verfügbar | Apple

Priority Notifications | ✅ Verfügbar | Apple

Foundation Models Framework | ✅ Verfügbar | WWDC25 Session 286

ChatGPT-Integration in Siri | ✅ Verfügbar | Apple

Für Entwickler relevant:

Foundation Models Framework – Vollständige API-Übersicht:

• LanguageModelSession – Hauptklasse für alle Interaktionen
• LanguageModelSession.isAvailable – Verfügbarkeit prüfen (statische Property)
• session.respond(to:) – Einfache Abfrage mit await
• session.streamResponse(to:) – Streaming für Echtzeit-UI
• @Generable – Structured Output Annotation für eigene Typen
• @Guide – Beschreibung für einzelne Properties in @Generable-Typen
• Tool Protokoll – Eigene Tools/Funktionen für das Modell bereitstellen
• LanguageModelSession(instructions:) – System-ähnliche Anweisungen
• LanguageModelSession(tools:) – Session mit Tool-Binding

App Intents für Siri:

App Intents sind der Mechanismus, mit dem Apps ihre Funktionen für Siri, Spotlight und Kurzbefehle sichtbar machen.

import AppIntents

// Einfacher App Intent
struct CreateNoteIntent: AppIntent {
    static var title: LocalizedStringResource = "Notiz erstellen"
    static var description = IntentDescription("Erstellt eine neue Notiz")
    
    @Parameter(title: "Titel") var noteTitle: String
    @Parameter(title: "Inhalt") var noteContent: String?
    
    func perform() async throws -> some IntentResult & ProvidesDialog {
        let note = NoteManager.create(title: noteTitle, content: noteContent ?? "")
        return .result(dialog: "Notiz '\(note.title)' erstellt")
    }
}

// Entity für Siri-Sichtbarkeit
struct NoteEntity: AppEntity {
    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Notiz"
    static var defaultQuery = NoteEntityQuery()
    
    var id: UUID
    var title: String
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(title: "\(title)")
    }
}

Warum App Intents implementieren?

• Apps ohne App Intents erhalten keinen Siri-Support in iOS 26
• Wichtig für Spotlight-Suchbarkeit
• Ermöglicht Kurzbefehle-Integration
• Siri Onscreen-Awareness: Siri kann über App-Inhalte informiert werden

Writing Tools APIs:

// Writing Tools in eigene TextEditor-Views integrieren
TextEditor(text: $attributedText)
    .writingToolsBehavior(.complete) // Vollständige Writing Tools
    // oder .limited für eingeschränkte Writing Tools
    // oder .disabled um Writing Tools zu deaktivieren

Image Playground APIs:

import ImagePlayground

// Image Playground Sheet öffnen
struct ContentView: View {
    @State private var showImagePlayground = false
    @State private var generatedImage: UIImage?
    
    var body: some View {
        Button("Bild generieren") {
            showImagePlayground = true
        }
        .imagePlaygroundSheet(isPresented: $showImagePlayground,
                              concept: "Ein süßer Hund im Mondlicht") { image in
            generatedImage = image
        }
    }
}

Einschränkungen Image Playground:

• Nur auf Geräten mit Apple Intelligence verfügbar
• isAvailable prüfen vor Nutzung
• Nicht auf Intel-Macs verfügbar

App Store & TestFlight & AppStore Connect

App Store SDK-Pflicht ab 28. April 2026 ✅ In Kraft

Ab dem 28. April 2026 werden alle neuen App-Einreichungen und Updates ohne iOS 26 SDK (Xcode 26) abgelehnt.

Wichtig: Die Deployment-Target-Einstellung ist unabhängig. Bestehende Nutzer auf iOS 16+ werden nicht beeinflusst.

Liquid Glass Auswirkung: Apps, die mit dem iOS 26 SDK gebaut werden, erhalten automatisch Liquid Glass auf nativen UI-Komponenten (sofern UIDesignRequiresCompatibility nicht gesetzt ist).

Was prüft Apple Review bei Liquid Glass?

• Korrekte Darstellung auf iOS 26 (nativer Look und Feel)
• Keine kaputten Layouts durch falsch implementierte Custom NavigationBars
• Das UIDesignRequiresCompatibility-Flag wird akzeptiert, aber nicht dauerhaft empfohlen
• Accessibility muss funktionieren: Reduce Transparency, VoiceOver

Quelle: Apple Upcoming Requirements, 9to5Mac

DeclaredAgeRange Framework ✅ Bestätigt

Was macht das Framework?

DeclaredAgeRange ist ein privacy-erster Weg für Apps, das Alter eines Nutzers zu erhalten, ohne das genaue Geburtsdatum zu kennen. Das Alter wird aus dem Apple ID des Nutzers abgeleitet.

Warum wurde es eingeführt?

• Texas (SB 2420): Gesetz verlangt altersangemessene Erfahrungen und Altersverifikation ab 1. Januar 2026
• Australien, Brasilien, Singapur: Apple blockiert ab 24. Februar 2026 den Download von 18+ Apps für nicht-verifizierte Nutzer

Welche Apps müssen es implementieren?

• Apps mit 17+ oder 18+ App Store Rating in Texas, Australien, Brasilien oder Singapur
• Apps, die standortbasierte Altersprüfung benötigen
• Für vollständige Funktionalität: iOS 26.2 SDK (Xcode 26.2) erforderlich

Technische Anforderungen:

1. Entitlement com.apple.developer.declared-age-range in .entitlements-Datei aktivieren
2. Apple Developer Program Membership erforderlich

Vollständiges Code-Beispiel:

import DeclaredAgeRange
import SwiftUI

struct AgeGatedView: View {
    @State private var ageRange: AgeRange?
    @State private var showsAgeGatedContent = false
    
    var body: some View {
        VStack {
            if showsAgeGatedContent {
                Text("Altersgerechter Inhalt")
            } else {
                Button("Inhalt freischalten") {
                    Task { await requestAge() }
                }
            }
        }
    }
    
    func requestAge() async {
        do {
            // Altersprüfung anfragen (öffnet System-Dialog)
            let response = try await AgeRangeService.shared.requestAgeRange(
                ageGates: [13, 16, 18]
            )
            
            switch response {
            case .declinedSharing:
                // Nutzer hat Ablehnung – Zugang verweigern oder einschränken
                showsAgeGatedContent = false
                
            case .sharing(let range):
                // range.minimumAge: Bestätigtes Mindestalter
                // range.declarationType: .selfDeclared oder .guardianDeclared
                if range.minimumAge >= 18 {
                    showsAgeGatedContent = true
                }
            }
        } catch {
            // Fehlerbehandlung
        }
    }
}

SwiftUI Environment Variante:

@Environment(\.requestAgeRange) private var requestAgeRange
let response = try await requestAgeRange(ageGates: [13, 16, 18])

Datenschutzaspekte:

• Das genaue Geburtsdatum wird nie an die App übermittelt
• Nur die Altersgruppe (13+, 16+, 18+) wird zurückgegeben
• Deklarationstyp: .selfDeclared (Nutzer selbst) oder .guardianDeclared (Family Sharing)
• Einschränkung: Falsche Altersangaben können nicht erkannt werden – kein Ersatz für behördliche Altersverifikation
• Nicht für High-Assurance-Zwecke geeignet (Altersverifizierung mit Ausweisdokument)

App Store Anforderungen:

• Entitlement muss beantragt werden (über Apple Developer Portal)
• Privacy Manifest muss com.apple.developer.declared-age-range listen

Referenz: Apple Developer – Declared Age Range, Age assurance developer Q&A

TestFlight

• Aktuelle stabile Version: TestFlight 4.2.1 (Stand: 29. Mai 2026)
• Best Practices für iOS 26:
• TestFlight-Builds auf echten iOS-26-Geräten testen (nicht nur Simulator)
• Liquid Glass in TestFlight-Build validieren bevor App Store Einreichung
• Foundation Models Features in TestFlight: Tester brauchen Apple Intelligence aktiviert
• DeclaredAgeRange: Sorgfältig in TestFlight testen – echte Apple-ID-Altersangaben werden verwendet
• Empfehlung: TestFlight-Build vor App-Store-Einreichung testen – gleiche Validierungsprüfungen, aber iterierbar ohne Auswirkung auf die Live-App

Bekannte Probleme

Migration auf Apple 26

Priorisierte Migrations-Checkliste

Kritisch (App Store-Einreichung ohne Adoption nicht möglich)

• [x] Xcode 26 als Build-Tool verwenden ✅ Pflicht seit 28. April 2026
• Warum: Ohne Xcode 26 werden App Store Einreichungen abgelehnt
• Was tun: Xcode 26.5 (oder aktueller) installieren
• [ ] iOS 26 SDK als Target-SDK setzen (Deployment Target kann niedriger bleiben)

Hoch (UI bricht oder verhält sich falsch)

• [ ] Liquid Glass evaluieren ✅ Bestätigt
• Warum: Ohne Prüfung können Custom Navigations kaputt aussehen
• Was tun: Auf physischem Gerät testen
• Custom Backgrounds in UINavigationBar, UITabBar, UIToolbar prüfen
• safeAreaInsets nach Floating-Tab-Bar-Einführung neu evaluieren
• UIDesignRequiresCompatibility = true als temporäre Maßnahme (entfällt in iOS 27)

• [ ] UIScene-Lifecycle implementieren – Pflicht in iOS 27
• Warum: In iOS 27 (April 2027 Deadline) müssen alle Apps UIScene verwenden
• Was tun: SceneDelegate erstellen, UIApplicationSceneManifest in Info.plist
• Risiko bei Nicht-Umsetzung: App startet in iOS 27 nicht mehr

Mittel (Deprecated APIs – müssen bis iOS 27 ersetzt sein)

• [ ] UIScreen.main ersetzen ✅ Bestätigt
• Ersatz: view.window?.windowScene?.screen
• Risiko: Crash in iOS 27 bei Entfernung der API
• [ ] actionSheet → confirmationDialog ✅ Bestätigt
• Risiko: API funktioniert in iOS 27 nicht mehr
• [ ] SceneKit → RealityKit ✅ Bestätigt (SceneKit vollständig deprecated)
• Risiko: SceneKit wird in iOS 27 entfernt
• [ ] TLS-Kompatibilität von Drittbibliotheken prüfen (TLS 1.3 ist Standard)
• Bibliotheken die TLS 1.0/1.1 verwenden können Verbindungsfehler verursachen
• [ ] AppDelegate-only Code auf UIScene migrieren (gilt auch für SwiftUI-Apps)

Niedrig (Nice to Have / Neue Features evaluieren)

• [ ] Foundation Models Framework evaluieren
• Welche Features der App könnten On-Device-KI nutzen?
• isAvailable prüfen und Fallback implementieren
• [ ] glassEffect() für Custom Controls implementieren
• Für konsistentes Liquid Glass Design
• [ ] Chart3D evaluieren
• Bestehende Charts die von 3D profitieren könnten
• [ ] WebView migrieren
• UIViewRepresentable-Wrapper durch natives SwiftUI WebView ersetzen
• [ ] TextEditor auf AttributedString migrieren
• Für Rich Text Editing in eigenen Apps
• [ ] App Intents implementieren
• Für Siri-Sichtbarkeit und Spotlight-Integration
• [ ] Swift Testing evaluieren
• Neue Tests mit @Test und #expect schreiben
• Bestehende XCTest-Tests können parallel laufen
• [ ] MetricKit Apps mit Xcode 26.4.1 neu bauen (kritisch wenn betroffen)

Fazit

iOS 26 und die Apple Plattformen 26 sind seit September 2025 produktiv und haben mit iOS 26.5.1 (Juni 2026) ihren vorerst letzten Patch-Stand erreicht.

Die wichtigsten Erkenntnisse für Entwickler:

1. Liquid Glass ist nicht optional – Seit dem 28. April 2026 müssen alle Apps mit dem iOS 26 SDK gebaut werden, womit Liquid Glass automatisch wirksam wird. Das Kompatibilitäts-Flag UIDesignRequiresCompatibility ist temporär und entfällt in iOS 27.

1. Foundation Models Framework ist die zentrale neue Möglichkeit für On-Device-KI – kostenlos, privat, Swift-native. Nur auf Apple-Intelligence-Geräten verfügbar – immer isAvailable prüfen.

1. Swift 6 Strict Concurrency wird durchgesetzt und erfordert bei Legacy-Code aktive Migration. Typed Throws und ~Copyable sind neue Werkzeuge für sichereren Code.

1. MetricKit-Entwickler müssen auf Xcode 26.4.1 upgraden, um einen bekannten Crash-Bug zu beheben.

1. UIScene-Lifecycle muss jetzt implementiert werden – in iOS 27 (Deadline April 2027) ist es Pflicht.

1. WWDC 2026 (8. Juni 2026) kündigt iOS 27 an. Die Migrations-Checkliste für UIScene-Lifecycle und Liquid Glass sollte vor dem nächsten Beta-Zyklus abgearbeitet sein.

Archiv: iOS 26 Beta-Historie

Die Beta-Phase von iOS 26 verlief von Juni bis September 2025.

Quelle: BetaWiki, MacRumors, Apple Developer Releases

iPadOS 26 Beta-Historie

Identische Build-Nummern wie iOS 26 in der Beta-Phase.

macOS 26 Tahoe Beta-Historie

Parallel zu iOS 26 – Beta 1 am 9. Juni 2025, RC am 9. September 2025, Release am 15. September 2025.

watchOS 26 Beta-Historie

Quelle: BetaWiki

Letzte Aktualisierung: 06. Juni 2026

Quellen: Apple Developer Releases, Apple Support – iOS 26 Updates, iOS 26 Release Notes, macOS Tahoe Release Notes, watchOS 26 Release Notes, Xcode 26 Release Notes, WWDC25 Foundation Models Session 286, WWDC25 Foundation Models Session 301, WWDC25 SwiftUI Session 256, WWDC25 Build SwiftUI App Session 323, WWDC25 Metal 4 Session 205, WWDC25 Chart3D Session 313, WWDC25 WebKit for SwiftUI Session 231, WWDC25 App Intents Session 275, Apple Declared Age Range, Swift.org – Swift 6, MacRumors, 9to5Mac, Eclectic Light Company