WWDC 2025: Liquid Glass, Swift 6.2 and an LLM Inside Your App

Apple has just done something it hasn't done since iOS 7 in 2013: a top-to-bottom redesign of the interface across its entire ecosystem. It's called Liquid Glass and, together with the new naming convention (iOS 26, not iOS 19), it's the clearest signal that Apple considers this the start of a new era.

But beneath the glass there are changes that matter much more to those of us who write code for a living. Swift 6.2 acknowledges that strict concurrency went too far and partially reverses course with "Approachable Concurrency". Apple opens its on-device LLM to developers with the Foundation Models framework. And Xcode 26 integrates ChatGPT directly into the editor.

I spent the whole night watching sessions after the keynote. Here's what you need to know.

Liquid Glass: the biggest visual redesign since iOS 7

Let's start with what everyone has seen: Liquid Glass is Apple's new design language, inspired by visionOS. Translucent toolbars, controls with depth, dynamic reflections, glass layers that react to the content behind them. It's beautiful. It's striking. And it's going to be a headache for many teams.

What matters for developers:

• If you use standard UIKit and SwiftUI components, adaptation is largely automatic. UINavigationBar, UITabBar, UIToolbar and their SwiftUI equivalents adopt Liquid Glass without code changes. App icons have a new multi-layer format with depth, created with the new Icon Composer tool.
• Apple gives a one-year grace period. You can disable Liquid Glass in your app and keep the previous look for one cycle. But the implicit deadline is clear: by autumn 2026, your app must have the new look.
• If you have heavy custom UI (custom bars, overlays, hand-drawn controls), you have work to do. Translucent materials, depth effects and the new bar styles require manual review.

The naming change is significant: it's no longer iOS 19, it's iOS 26. All platforms share the year number: iOS 26, iPadOS 26, macOS 26 (Tahoe), watchOS 26, visionOS 26, tvOS 26. Apple wants the number to represent when it will be available to users, not an internal sequential version.

For enterprise apps with long support cycles, this simplifies communication with product managers and clients: "we support iOS 26 and 25" is more intuitive than "we support iOS 19 and 18".

Swift 6.2: Apple acknowledges it went too far

This is the section that interests me most. And the one that will most affect teams who, like us, have spent months wrestling with Swift 6's strict concurrency.

Approachable Concurrency is Apple's response to massive community feedback: Swift 6 was right in its goal (data race safety) but the execution was too aggressive for mobile apps. Too many compiler errors for problems that didn't exist in practice. Too much ceremony for code that didn't need concurrency.

Swift 6.2 changes the mental model:

Your code is single-threaded by default. New projects in Xcode 26 have Default Actor Isolation set to MainActor. Everything runs on the main actor unless you explicitly say otherwise. No more dancing with @MainActor on every view, every ViewModel, every callback.

// Swift 6.2 with Approachable Concurrency
// This class runs on MainActor by default. No annotations needed.
class UserViewModel {
    var users: [User] = []

    func fetch() async {
        // This runs on the main actor (the caller's context)
        users = await api.fetchUsers()
    }

    @concurrent
    func processInBackground() async {
        // THIS runs in the background. You mark it explicitly.
        let result = heavyComputation()
        // ...
    }
}

@concurrent is the new annotation for saying "I want this to run on the concurrent thread pool". It's opt-in, not opt-out. The principle is progressive disclosure: you start single-threaded, introduce concurrency when you need it.

nonisolated(nonsending) is the new default behaviour for nonisolated async functions: they run in the caller's context, not jumping to the global executor. This eliminates an entire category of Sendable errors that appeared when an async function executed in an unexpected context.

What this means in practice: if you enabled Swift 6 language mode and ran into hundreds of errors, Swift 6.2 with Approachable Concurrency should eliminate a significant portion of them. Apple even includes automatic migration tools.

My recommendation: if you were waiting to migrate to Swift 6, now is the time. Swift 6.2 with Approachable Concurrency is what Swift 6 should have been from the start.

Other language updates:

• InlineArray: fixed-size arrays with inline storage, no heap allocation. Syntax: var buffer: [50 of UInt8].
• Span: a safe alternative to buffer pointers for contiguous memory access.
• Improved interoperability with C++, Java (swift-java project in active development), and JavaScript.
• Swift Testing: now supports custom attachments for failure triage and exit tests to verify code that must terminate under specific conditions.

Foundation Models: an on-device LLM for your app

This is Apple's big AI bet for developers. The Foundation Models framework gives direct access to Apple Intelligence's on-device LLM (a ~3B parameter model) via a native Swift API.

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(
    to: "Summarise this text in 3 key points: \(text)"
)
print(response.content)

Key capabilities:

• On-device, no network: runs entirely on the device. Data never leaves. Works offline. For enterprise apps with privacy requirements, this is exactly what was needed.
• Structured generation: with @Generable and @Guide you define Swift types that the model returns directly. No string parsing — you get typed structs.
• Tool calling: the model can invoke functions you define in your code. Give it tools (search a database, call an API) and the model decides when to use them.
• Streams: the model generates types partially as it processes, to show incremental results in the UI.
• Playground in Xcode 26: experiment with prompts directly in Xcode without writing app code.

Important limitations: the on-device model is not designed for general knowledge or advanced reasoning. It excels at summarisation, classification, entity extraction, reformulation and directed tasks. For open-ended questions about the world, you need a cloud model. Only available where Apple Intelligence is available.

My take: for enterprise use cases — classifying support tickets, extracting data from free text, summarising documents, generating predefined responses — the Foundation Models framework is extremely valuable. Privacy by design, no API costs, no network latency. It's the kind of AI a CTO can approve without consulting the DPO.

Xcode 26: integrated ChatGPT and build improvements

ChatGPT comes to Xcode with no account or API key required. Developers can use the model to write code, debug and document directly in the editor. You can also integrate other LLMs via your own API keys.

Beyond AI, Xcode 26 brings practical improvements:

• Swift Build open-source: Apple unifies the build systems between Xcode and Swift Package Manager. This is huge for CI/CD and server builds.
• UI test recording: you interact with your app and Xcode automatically generates the test code, including video recording to identify failures. This dramatically lowers the barrier to UI testing.
• Improved String Catalogs: automatically generate Swift symbols for autocompletion, and add context comments for translators.
• Swift extension for VS Code: new project panel, DocC tools, background indexing by default, and integrated LLDB support.
• Containerization framework: create, download and run Linux containers on Mac. Optimised for Apple Silicon. For teams that need local server environments for testing, this eliminates the Docker dependency.

SwiftUI: Chart3D, automatic Liquid Glass and accessibility

SwiftUI automatically adopts Liquid Glass in its standard components. Navigation bars, tab bars and toolbars gain the translucent effect without code changes.

Chart3D is the most visual addition: Swift Charts now supports three-dimensional charts. PointMark, RuleMark and RectangleMark accept a Z axis to position data in space. For scientific, financial or IoT data apps, this enables visualisations that previously required third-party libraries.

SF Symbols 7 arrives with more than 6,900 symbols, new animations and gradient support. The new multi-layer app icons are created with Icon Composer, a dedicated tool that generates the depth layers needed for Liquid Glass.

Accessibility Nutrition Labels: declarative accessibility

This update particularly excites me because it connects directly to the European Accessibility Act, which just came into force this June. Apple introduces Accessibility Nutrition Labels, a declarative system for apps to publish their level of accessibility support.

It's conceptually similar to the App Store's Privacy Nutrition Labels: you declare which accessibility features your app supports (VoiceOver, Dynamic Type, reduce motion, etc.) and that information is shown to users.

For enterprise apps in Europe, this aligns perfectly with EAA requirements. It's no longer just about complying in code — it's about publicly declaring your level of compliance.

App Intents: deeper with Apple Intelligence

App Intents continues to expand as the central framework for system integration. The most relevant updates:

• Shortcuts with Apple Intelligence: Shortcuts can now directly invoke the on-device LLM or Private Cloud Compute. A user can create a shortcut that uses AI to compare class transcriptions with their notes.
• Intelligent Actions: a new type of shortcut enabled by Apple Intelligence that allows more sophisticated contextual actions.
• Improved Spotlight: searches files, folders, events, apps and messages, all ranked by relevance using AI. Can execute tasks directly (send email, create note, play podcast).

More relevant updates

• macOS 26 Tahoe: Liquid Glass comes to the Mac. Improved iPhone Mirroring. Spotlight completely redesigned with AI.
• iPadOS 26: true resizable and movable windows, Mac-style menu bar accessible with swipe, native Preview app for PDFs, Files with list view and adjustable columns.
• watchOS 26: Workout Buddy (AI virtual coach analysing heart rate, distance, pace and Activity Rings). Smart Stack with contextual suggestions. One-handed gestures for Series 9/10/Ultra.
• visionOS 26: compatibility with PlayStation VR2 Sense controllers and Logitech Muse (stylus). Improved spatial widgets. More realistic Personas.
• Translation API: full programmatic access to Apple's translation models, including live translation during FaceTime calls.
• Network framework: native Swift Concurrency integration. Declarative syntax for defining the protocol stack. Send/receive as async functions.
• MLX: Apple's open-source framework for numerical computation and ML on Apple Silicon. Run models like DeepSeek directly on Mac with M3/M4 Ultra.

Conclusion: what to do now

WWDC 2025 is a WWDC of course correction and new vision. Liquid Glass marks a new visual era. Swift 6.2 fixes what Swift 6 broke. And the Foundation Models framework opens the door to on-device AI without privacy compromises.

If I had to choose three concrete actions for an enterprise iOS team:

1. Enable Approachable Concurrency and Default Actor Isolation on MainActor. If you were stuck with the Swift 6 migration, Swift 6.2 is your moment. The mental model is much simpler: everything on main actor, @concurrent when you need background. Start with a test module.
2. Evaluate the Foundation Models framework for your use cases. Text classification, summarisation, entity extraction, predefined response generation — all on-device, no API costs, no latency, no privacy concerns. Build a prototype this week.
3. Review your app with Liquid Glass enabled. If you use standard components, adaptation should be mostly automatic. If you have custom UI, identify what needs work now. You have a year's grace, but don't leave it until September 2026.

It's been a WWDC with a lot of substance beneath the shine of the glass. Liquid Glass grabs the headlines, but Approachable Concurrency and Foundation Models are the changes that will impact your daily code. Time to explore.

Need help with adoption?

💡 Do you have a project that needs migration? We can help you make the transition efficiently and without interrupting your development flow.

📩 Contact us here for more information.