WWDC 2025 What’s new in UIKit

Key highlights include:

• The new Liquid Glass design system with fluid animations


• iPad menu bar support with powerful new APIs


• Revolutionary Swift Observable integration that automatically tracks dependencies


• The new updateProperties method for better performance


• Enhanced SwiftUI integration through hosting scene delegates


• HDR improvements for colors and custom content


• Strongly typed notifications


• SF Symbols 7 drawing capabilities

The New Design System: Liquid Glass Material

The most visually striking change in iOS 26 is the introduction of Liquid Glass, a translucent, dynamic material that brings life to your app's interface with specular highlights and refraction effects. This new material has been applied across UIKit's standard components including navigation bars, search fields, alerts, popovers, and split views.

Key Design Improvements

Fluid Navigation Transitions: Navigation animations are now interruptible, allowing users to interact with content without waiting for animations to complete. This creates a more responsive user experience.

New Design Tools: Apple has introduced several tools to help you adopt the new design:

• 
  Background Extension View: Allows content to surface under the sidebar's glass platter


• 
  Glass Material: For custom components


• 
  Scroll Edge Effect: Content gracefully fades as it scrolls under glass platters

To get hands-on experience with these changes, Apple recommends watching "Build a UIKit app with the new design" and "Get to know the new design system."

Enhanced Split View Controllers and Inspectors

UISplitViewController now includes first-class support for inspectors - additional detail views that provide context about selected content. Think of how Preview shows metadata alongside photos in the secondary column.

New capabilities include:

• 
  Resizable columns by dragging separators


• 
  Smart pointer adaptation that indicates resize directions


• Improved container view controller flexibility

Menu Bar Support Comes to iPad

One of the most significant additions is bringing the macOS menu bar to iPad. Users can now swipe from the top to reveal the full app menu, even without a hardware keyboard.

Menu Bar Features

The iPad menu bar supports all standard menu features:

• Images and submenus


• Inline sections and checkmarks


• All app commands (not just those with keyboard shortcuts)


• Disabled but visible unavailable commands for discoverability

New Menu APIs

Main Menu System Configuration: This powerful new API allows apps to:

• Customize which system commands appear by default


• Access pre-made, localized menu elements


• Configure and style individual menu groups


• Share menu definitions between apps and extensions
  

// Example configuration

let configuration = UIMainMenuSystemConfiguration()

configuration.includeSystemCommands([.print])

configuration.excludeSystemCommands([.toggleInspector])

configuration.findCommandStyle = .search

Enhanced Actions: iOS 26 introduces new standard actions:

• 
  performClose (Cmd-W) for closing scenes or tabs


• "New from clipboard" for creating documents without paste alerts


• Text alignment, sidebar, and inspector toggle actions

Focus-Based Deferred Menus: For dynamic content that changes based on context, you can now create deferred menu elements that populate from the responder chain.

Revolutionary Architecture: Swift Observable Integration

The biggest architectural change is UIKit's built-in support for Swift Observable objects. This integration happens automatically in update methods like layoutSubviews, tracking Observable references and invalidating views as needed.

Automatic Observation Tracking

// Observable model automatically tracked

class MessageModel: Observable {

    var showStatus: Bool = true

    var statusText: String = "5 unread"

}



override func viewWillLayoutSubviews() {

    super.viewWillLayoutSubviews()

    // UIKit automatically tracks dependencies

    statusLabel.alpha = model.showStatus ? 1.0 : 0.0

    statusLabel.text = model.statusText

}

This feature can be back-deployed to iOS 18 by adding UIObservationTrackingEnabled to your Info.plist.

New updateProperties Method

UIKit introduces updateProperties to both UIView and UIViewController. This method:

• Runs before layoutSubviews but independently


• Allows property updates without forcing layout


• Automatically tracks Observable objects


• Can be manually triggered with setNeedsUpdateProperties
  

Update Pass Flow

The new update flow works like this:

1. 
   Traits Update: View traits are updated


2. 
   updateProperties: New method runs here


3. 
   layoutSubviews: Traditional layout logic


4. 
   Display Pass: Drawing occurs

Improved Animations with flushUpdates

iOS 26 introduces the flushUpdates animation option that automatically handles updates before and after animations:

UIView.animate(withDuration: 0.3, options: [.flushUpdates]) {

    // Make changes to Observable objects

    model.isExpanded = true

    // No need to call layoutIfNeeded!

}

SwiftUI Integration: Hosting Scene Delegate

UIKit apps can now use SwiftUI scenes through the new UIHostingSceneDelegate protocol. This enables:

• Incremental SwiftUI adoption


• Access to visionOS immersive spaces and volumes


• Seamless mixing of UIKit and SwiftUI in the same app

HDR Enhancements

HDR support extends beyond images to colors and custom content:

HDR Colors: Create colors with exposure values that automatically adjust to display capabilities:

let hdrRed = UIColor(red: 1.0, green: 0.0, blue: 0.0, exposure: 2.5)

HDR Color Pickers: Enable HDR selection in UIColorPickerViewController and UIColorWell by setting maximum exposure values.

Smart HDR Fallback: The intelligent HDR-to-SDR fallback now works with video and custom content using the UITraitHDRHeadroomUsage trait.

Strongly Typed Notifications

UIKit now represents notifications as dedicated NotificationCenter.Message types, providing type safety:

// Strongly typed notification handling

NotificationCenter.default.addObserver(for: .keyboardWillShow) { message in

    let duration = message.animationDuration

    let keyboardFrame = message.keyboardFrame

    // No userInfo casting needed!

}

SF Symbols 7 Integration

New drawing capabilities for SF Symbols include:

• 
  Draw Off/On effects: Animated symbol appearance/disappearance


• 
  Variable Draw mode: Progress indicators along paths


• 
  Magic Replace transitions: Special animations between related symbols


• 
  Gradient rendering mode: Automatic gradient generation

UIKit adds easy symbol transitions for buttons:

buttonConfiguration.symbolContentTransition = .replace(.downUp)

Important Deprecations and Requirements

UIScene Lifecycle Mandatory: Starting with the release after iOS 26, apps built with the latest SDK must use UIScene lifecycle or they won't launch. Begin migrating now using Apple's tech note "Migrating to the UIKit scene-based life cycle."

Deprecated APIs: Many UIApplication-focused APIs are being deprecated in favor of UIScene-based alternatives.

File Handling Improvements

The openURL method now accepts file URLs, allowing you to hand off documents to external viewers. If no default app exists, openURL returns false, letting you handle fallbacks with Quick Look or other solutions.

Getting Started with iOS 26

To take advantage of these improvements:

1. 
   Compile with iOS 26 SDK and review your app's response to the new design


2. 
   Use standard containers like UISplitViewController for flexible layouts


3. 
   Implement menu bars with the new menu APIs


4. 
   Adopt updateProperties and observation tracking for better performance


5. 
   Plan your UIScene migration to meet upcoming requirements

Conclusion

iOS 26 represents a significant evolution for UIKit, bringing modern design aesthetics, powerful architectural improvements, and better integration with SwiftUI. The automatic Observable tracking alone will simplify countless lines of code, while the new design system ensures your apps feel fresh and contemporary.

These changes position UIKit for the future while maintaining the robust foundation developers have relied on for years. Start experimenting with these features today to create more powerful and delightful user experiences.