WWDC 2025 Summary

Key Updates for iOS Engineers

This comprehensive summary of WWDC 2025 is specifically crafted for iOS engineers who want to quickly understand the most impactful changes and new capabilities announced at Apple’s developer conference. Having watched most of Apple’s WWDC 2025 sessions and conducted thorough research, I’ve focused this analysis on iOS development priorities while acknowledging the broader ecosystem updates across visionOS, macOS, andeg, device management. Whether you’re planning your next app update, evaluating new frameworks for upcoming projects, or simply staying current with Apple Intelligence and the latest technologies, this document provides the essential insights you need to make informed development decisions and leverage the newest iOS capabilities effectively.

TL;DR

WWDC 2025 brings major updates across Apple’s development ecosystem:

iOS 26 introduces Liquid Glass design system and AI-powered features
Swift 6.2 enhances concurrency and cross-platform capabilities
Xcode 26 adds AI integration and performance improvements
SwiftUI expands with 3D support and modern design tools
UIKit modernizes with reactive programming features
New AI frameworks enable on-device LLM integration
ARKit advances with shared experiences and spatial computing
New developer tools streamline app creation and testing
Enhanced gaming and content safety features

Major iOS Update with New Design

Liquid Glass Design System

iOS 26 (not anymore iOS 19) brings the biggest redesign since iOS 7. Liquid Glass is the new UI material look – a dynamic, glass-like appearance with transparency and fluid light effects. This unified design extends across all platforms, from buttons and switches to tab bars, sidebars, and navigation bars.

Swift

Concurrency and Performance

Swift has received significant improvements in both performance and concurrent programming. Several key enhancements make concurrent code more approachable and safer.

Default Main-Actor Module Isolation

New projects now default to isolating their app modules to the main actor. This can also be enabled in existing projects via the Swift Compiler – Concurrency build setting Default Actor Isolation = MainActor. All top-level code and types are then implicitly @MainActor, reducing boilerplate and lowering the risk of accidental data races.

Concurrent Methods

You can now mark instance or static methods with @concurrent, allowing the compiler to automatically schedule them on background executors. This offloads work from the main actor, improving UI responsiveness. The compiler enforces safety by disallowing access to main-actor–isolated state from within @concurrent methods unless explicitly marked nonisolated.

`nonisolated(nonsending)`

Swift 6.2 introduces nonisolated(nonsending), which changes how nonisolated synchronous functions behave. They now inherit the caller’s actor isolation instead of always running on the global executor. This improves the experience when incrementally adopting concurrency and reduces unexpected data-race warnings.

Approachable Concurrency

Xcode 26 adds the Approachable Concurrency build setting, which opts your module into gradual actor isolation, stricter sendability checks, and new concurrency diagnostics. It also enables nonisolated(nonsending) by default. This makes adopting Swift concurrency safer and more incremental. To preserve the old behavior (executing outside any actor), you can annotate functions with @concurrent.

Nonisolated Library APIs

Library authors gain the ability to annotate entire classes or individual methods as nonisolated, indicating these methods are safe to call from any actor without forcing the entire class onto one actor. This enables writing performant, thread-safe frameworks without scattering dispatch calls throughout the codebase.

InlineArray

Swift 6.2 introduces InlineArray, a fixed-size array type that stores elements contiguously inline rather than using copy-on-write optimization. This provides predictable memory layout and better performance for small, fixed-size collections. The array size is specified as a compile-time constant, and elements are stored directly in the array’s memory footprint. Memory layout is determined by element type and count. The type supports standard array literal syntax for initialization. Unlike regular Swift arrays which are stored on the heap with copy-on-write semantics, InlineArray stores its elements directly on the stack (or inline within the containing object). This eliminates heap allocations and reduces memory overhead for small collections, making it ideal for performance-critical code where predictable memory usage is important.

Span

Swift 6.2 introduces Span, a safe pointer type that combines direct memory access with Swift’s memory safety guarantees. Unlike raw pointers, Span includes bounds information to prevent out-of-bounds access and is non-escapable, meaning it cannot outlive the memory it references—eliminating use-after-free bugs. The mutable variant, MutableSpan, allows safe in-place modification. Designed for Swift interoperability with C and C++, Span enables safe calls to annotated functions and offers a safer alternative to raw pointers—retaining performance while avoiding common C-style pitfalls like buffer overflows and dangling references.

Standard Library Updates

The standard libraries were partially modernized (e.g., more concrete types for Notifications).

Xcode 26

Performance and AI Integration

The new Xcode version offers numerous productivity and performance improvements. Xcode 26 is significantly leaner and faster – the download is ~24% smaller than before, projects (workspaces) load up to 40% faster, and editor latency when typing has been reduced by ~50% in complex cases.

AI-Supported Development

Particularly noteworthy: Xcode 26 integrates AI support directly into the IDE. There’s built-in support for Apple Intelligence and ChatGPT that helps with writing code, debugging, or documentation. Through Xcode’s new Coding Tools, you can use AI features contextually—e.g., generate code or test cases, fix errors, or request explanations—directly in the editor. ChatGPT can be used immediately in Xcode without an account, and if needed, your own API keys (other AI services or local models) can be integrated.

Enhanced Localization Workflow

Xcode 26 brings major localization improvements with String Catalogs that automatically collect strings from SwiftUI and String(localized:). Features include pluralization, language-specific translations.

New features include automatic comment generation for translators using on-device AI, a #bundle macro for framework localization, and symbol generation for type-safe string references like Text(.introductionTitle). A new refactoring tool lets developers switch between string extraction and symbol-based workflows.

Additionally, there’s a revamped navigation in Xcode, improvements in the localization workflow, and complete Voice Control for writing Swift code through voice input.

Playgrounds

Xcode 26 introduces enhanced playground capabilities with the playground macro, accessible by importing the Playgrounds module. This macro can be used via #Playground syntax, similar to #Preview, providing a streamlined way to create interactive code exploration environments.

SwiftUI

Design System Integration

SwiftUI has been expanded and optimized in many areas. Developers can now seamlessly adopt the new design with SwiftUI – many standard controls automatically receive the Liquid Glass look, and Apple offers new API modifiers to add glass effects to custom views.

Migration Considerations

Developers should implement Liquid Glass gradually, starting with thorough testing of navigation elements. Focus on navigation bars and tab bars first, as they’re central to the new design. Test across different devices and orientations, document any issues, and maintain app stability throughout the transition. For apps that need more time to adapt, you can temporarily disable Liquid Glass by setting UIDesignRequiresCompatibility to YES in your app’s Info.plist. However, this is only a temporary solution as Apple will remove this fallback in iOS 27, so it’s best to start updating your UI as soon as possible.

WebKit Integration

Xcode 26 introduces a new WebKit API for SwiftUI that simplifies embedding web content without UIKit or AppKit wrappers. The WebView component renders web content as a single SwiftUI view, with an observable WebPage model integrated with SwiftUI’s data flow.

The API loads remote URLs, HTML strings, and .webarchive files, customizable through modifiers and bindings. It supports custom URL schemes via URLSchemeHandler for intercepting requests and serving local content—ideal for offline HTML rendering or native-web integration.

Rich Text Editing

SwiftUI now provides rich-text editing with TextEditor and AttributedString. Bind to AttributedString instead of String for formatting options like fonts, colors, and alignment.

The system supports multi-range selection via AttributedTextSelection using Swift’s RangeSet API, enabling multiple simultaneous selections. It also handles bidirectional text for multilingual input. Create custom formatting rules with AttributedTextFormattingDefinition and share rich text between apps using Transferable for copy-paste and drag-and-drop operations.

3D and Spatial Features

A highlight is the extension into the third dimension: SwiftUI can now also display views and scenes in 3D. With SwiftUI Spatial Layout and RealityKit integration, 3D surfaces and animations can be created as easily as 2D layouts.

UIKit

Modern Reactive Programming

UIKit also received major updates that make it more modern and reactive. Most important new feature: UIKit now directly integrates the Swift Observation model (@Observable). This enables reactive programming patterns where UI updates are automatically triggered when observed objects change. Developers can now use observable objects in layoutSubviews() methods, and UIKit will automatically invalidate and update the UI when those objects change—unveiling the same “magic” as SwiftUI where view model changes trigger automatic updates. However, this isn’t actually magic but intelligent usage of the Swift compiler’s observation system, which tracks property access and automatically generates the necessary update logic.

Enhanced Lifecycle Management

Additionally, there are new lifecycle hooks: UIKit now introduces updateProperties() that runs just before layoutSubviews() during each layout pass. This method (overridable in UIView/UIViewController) allows processing state changes and property updates independently from layout logic, enabling finer-grained updates and avoiding unnecessary layout passes. It automatically tracks any @Observable objects you read and can be manually triggered by calling setNeedsUpdateProperties().

Animation Improvements

For animations, UIKit offers the new .flushUpdates option: When animations are started with this flag, UIKit automatically handles all pending view updates at the beginning and end of the animation.

Apple Intelligence & AI Frameworks

Foundation Models Framework

At WWDC 2025, Apple ignited the next level of its on-device AI and gave developers direct access to its large AI models. Specifically, the Foundation Models Framework was introduced – a new Swift API that allows third-party apps to use the powerful Large Language Model (LLM) behind Apple Intelligence. This framework runs privately and offline on macOS, iOS, iPadOS, and visionOS, enabling features like personalized suggestions, content generation, summarization, and more—without increasing app size.

Guided Generation

Uses Swift macros @Generable to produce structured outputs like Swift types instead of raw text, ensuring reliability via constrained decoding.

Streaming Output

Rather than streaming token deltas, Apple introduces snapshots—partially generated Swift objects—that integrate smoothly with SwiftUI and reduce UI complexity.

Tool Calling

The model can autonomously call developer-defined tools, extending capabilities with world knowledge or user data. Built on Guided Generation, this allows type-safe execution of app logic, such as querying weather or maps.

Stateful Sessions

Supports multi-turn interactions using transcripts, with instructions to guide model behavior, helping differentiate between developer guidance and user prompts.

Specialized Adapters

Custom adapter training lets advanced developers fine-tune the on-device model for specialized tasks using Apple’s toolkit, but requires retraining with each model update.

Visual Intelligence

Besides the LLM, Apple has also expanded the system’s Visual Intelligence: App developers can now tap into iOS’s visual object recognition (e.g., recognizing objects/images in the camera or photos) via App Intents.

ARKit and Spatial Computing

Shared AR Experiences

There were also exciting new features for AR and VR developers. ARKit (iOS) and RealityKit were further improved, particularly in interaction with the Vision Pro headset (visionOS 26) and multi-user AR.

Enhanced Spatial Understanding

Additionally, Apple has expanded ARKit’s spatial understanding (Room Tracking): Apps can consider the properties of the current room and adapt content accordingly.

Cross-Platform Integration

For cross-platform 3D apps, the integration of SwiftUI, RealityKit, and ARKit is much tighter: There’s now a unified coordinate space to move views and 3D entities between UIKit/SwiftUI UI and AR worlds.

New Developer Tools, Frameworks & Features

Icon Composer

Apple introduces Icon Composer, a new tool for creating multi-layer icons using the Liquid Glass design system. It lets developers design adaptive icons for iPhone, iPad, Mac, and Apple Watch from a single source, customize visual effects, preview in multiple modes (Default, Dark, Mono), and integrate directly into Xcode. Includes updated shapes, a refined grid, and export options for marketing.

Build System Improvements

Additionally, Apple has opened up the build process: Xcode now internally uses an open-source build system called Swift Build, which has been published on GitHub.

Graphics and Gaming

In the graphics and games area, Metal 4, Apple’s next-generation low-level graphics API, is exclusive to Apple Silicon. Metal 4 enables novel graphics techniques.

App Services and Platform Features

Background Tasks

Apple’s WWDC 2025 session “Finish Tasks in the Background” introduces new ways to extend app functionality beyond the foreground, focusing on efficient and responsible use of system resources. A major highlight is the new BGContinuedProcessingTask API in iOS/iPadOS 26, which allows apps to continue user-initiated tasks—like exports or uploads—even after the app moves to the background. The system provides built-in UI for task progress and cancellation, while developers must continuously report progress and handle expiration events gracefully.

AlarmKit Framework

Apple introduces AlarmKit, a new framework for creating alarm and timer experiences in apps. It provides customizable schedules, UI components, and system integration for managing one-time and repeating alarms, timers, and snooze functionality. The framework handles permissions and offers built-in components for both standard views and widgets.

Youth Protection

Away from gaming, Apple introduces new tools for youth protection and personalized content. Particularly noteworthy is the Declared Age Range API: Developers can now ask the user (or parents) for an age level, which is given in broad categories (e.g., under 13, 13-17, 18+). With this age rating, apps can automatically adapt their content or functions to the age group – for example, hide certain features for children or show age-appropriate recommendations. Important: The age is handled in a privacy-friendly way – parents can explicitly allow the sharing of the age group, no exact birth date is needed, and the setting can be revoked at any time.

Digital Identity Verification

Apple is expanding its digital identity verification capabilities in iOS 26 with Verify with Wallet on the Web. This feature enables users to verify their age and identity using state-issued licenses or Digital IDs in a private and secure manner. While this functionality was previously available in apps, Apple is now extending it to web applications through support for the W3C Digital Credentials API and FIDO CTAP protocol.

The implementation leverages the new IdentityDocumentServices and IdentityDocumentServicesUI frameworks, allowing apps to register as identity document providers. The system supports mobile documents (mdocs) as defined in the ISO/IEC 18013-5 standard, with built-in security features like signature validation and certificate verification. This expansion enables more secure and privacy-preserving age verification across both native apps and web applications.

About the Author

iOS Development & Apple Platform Expertise

As a freelance iOS developer and Apple platform expert with professional experience dating back to 2010, I support companies in delivering scalable, high-quality iOS solutions that integrate cleanly into complex system landscapes. I also advise on the strategic integration of Apple’s latest technologies.

My background spans industries such as metasearch, telecommunications, medical devices, fashion, online marketplaces, e-commerce, media, and sports tech.

Workshops & Training

On request, I offer targeted formats tailored to your audience and needs:

For development teams

Technical deep dives, workshops, and presentations on new APIs, frameworks, and best practices.

For product managers and decision-makers

Concise management summaries focused on relevance, use cases, and strategic insights.