iOS 26 Features for iOS Engineers (2026): Liquid Glass, Foundation Models, Shipped APIs

Liquid Glass: the .glassEffect() modifier

Liquid Glass is a translucent, refractive material the system applies to controls, navigation chrome, and floating surfaces. Adopting it is one modifier on the right surface — the system handles refraction, blur, and motion-aware highlights:

import SwiftUI

struct PlayerControls: View {
    @State private var isPlaying = false

    var body: some View {
        HStack(spacing: 24) {
            Button(action: { /* prev */ }) {
                Image(systemName: "backward.fill")
            }
            Button(action: { isPlaying.toggle() }) {
                Image(systemName: isPlaying ? "pause.fill" : "play.fill")
            }
            .font(.title)
            Button(action: { /* next */ }) {
                Image(systemName: "forward.fill")
            }
        }
        .padding(20)
        .glassEffect(in: Capsule())  // ← the Liquid Glass material
        .shadow(radius: 12, y: 4)
    }
}

// Container surfaces (sheets, cards) — opaque variant
struct DetailSheet: View {
    var body: some View {
        VStack { /* content */ }
            .padding()
            .glassBackgroundEffect()  // for full-bleed container backgrounds
    }
}

// Tinted variant
Button("Subscribe") { /* ... */ }
    .padding()
    .glassEffect(.regular.tint(.blue), in: Capsule())

The constraint senior engineers learn first: Liquid Glass needs actual content underneath to refract. Applied to a view over a solid background, you get a blur but no refraction — the visual story breaks. The rule of thumb from WWDC25 'Meet Liquid Glass' (developer.apple.com/videos/play/wwdc2025/10054): apply Liquid Glass to floating controls and navigation chrome, leave it off content that is the content.

Foundation Models: on-device LLM in Swift

Foundation Models (iOS 26+, macOS 26+) gives Swift code direct access to Apple Intelligence's on-device language models. No network call, no API key, no third-party SDK. The hard constraint is hardware — Apple Intelligence requires iPhone 15 Pro / Pro Max or any iPhone 16, M1+ iPads, M1+ Macs.

import FoundationModels

// Simplest case — text completion
func summarise(_ article: String) async throws -> String {
    let session = LanguageModelSession()
    let response = try await session.respond(
        to: "Summarise this article in 3 bullet points: \(article)"
    )
    return response.content
}

// Tool calling — structured outputs via Generable
@Generable
struct Recipe {
    @Guide(description: "The dish name") let name: String
    @Guide(description: "List of ingredients with measurements") let ingredients: [String]
    @Guide(description: "Numbered cooking steps") let steps: [String]
}

func parseRecipe(from text: String) async throws -> Recipe {
    let session = LanguageModelSession(
        instructions: "Extract a recipe from the user's freeform text."
    )
    let response = try await session.respond(
        to: text,
        generating: Recipe.self
    )
    return response.content
}

// Streaming — partial responses
func streamSummary(_ article: String) async throws {
    let session = LanguageModelSession()
    let stream = session.streamResponse(
        to: "Summarise: \(article)"
    )
    for try await partial in stream {
        print(partial)  // each new token chunk
    }
}

// Availability gating
import FoundationModels

func smartFeature() async {
    guard SystemLanguageModel.default.isAvailable else {
        // Fall back to remote API or hide the feature
        return
    }
    // ... use the model
}

WWDC25 'Meet the Foundation Models framework' (developer.apple.com/videos/play/wwdc2025/10250) is the canonical reference; WWDC25 'Code-along: Bring on-device AI to your app with Foundation Models' walks the API surface end-to-end. Documentation: developer.apple.com/documentation/foundationmodels.

Real-world adoption notes: model latency on M1 / A17 Pro is good for short generations (under 2s for typical summaries) but degrades sharply over 1k output tokens. Memory footprint is ~3GB resident while a session is active — design around that on iPhone where the OS will jetsam an app holding 3GB in the background.

MetricKit: signpost aggregation and the per-release dashboard

MetricKit's iOS 26 addition is aggregated signpost telemetry via MXSignpostMetric. Your app emits signposts (os_signpost) tagged with categories you care about; iOS aggregates them, sends them up via the existing MetricKit pipeline, and your MXMetricManagerSubscriber receives bucketed counts and percentiles.

import MetricKit
import os.signpost

// 1. Emit signposts in the hot path
let log = OSLog(subsystem: "com.example.app", category: .pointsOfInterest)
let signpostID = OSSignpostID(log: log)

os_signpost(.begin, log: log, name: "Launch", signpostID: signpostID)
// ... launch work ...
os_signpost(.end, log: log, name: "Launch", signpostID: signpostID)

// 2. Subscribe to MetricKit reports
final class MetricsService: NSObject, MXMetricManagerSubscriber {
    override init() {
        super.init()
        MXMetricManager.shared.add(self)
    }

    func didReceive(_ payloads: [MXMetricPayload]) {
        for payload in payloads {
            // iOS 26+: payload.signpostMetrics surfaces the aggregated signposts
            if let signposts = payload.signpostMetrics {
                for metric in signposts {
                    print(metric.signpostName)  // "Launch"
                    print(metric.signpostIntervalData?.histogrammedNumberOfSignpostIntervals)
                }
            }
        }
    }
}

This replaces the pattern most large iOS orgs had of self-hosted log shipping. Apple's MetricKit pipeline runs on the device's existing diagnostic-submission cadence — daily, batched. Documentation: developer.apple.com/documentation/metrickit.

Adopt now vs wait: an honest deployment matrix

Continuity Camera, Handoff, and the productivity-app refinements

iOS 26 added refinements to Continuity Camera (using your iPhone as a Mac webcam) and Handoff. The API-level changes most relevant to iOS apps:

• Continuity Camera APIs (UIKit). AVCaptureDevice now exposes the iPhone-as-webcam stream to macOS apps; the iOS-side API is mostly unchanged from iOS 17. The new bit: device-side hooks for Center Stage / Studio Light / Reactions toggles via AVCaptureDevice.formats and the new continuityCaptureDevice property. Useful if you build a video-conferencing app that wants to expose the controls.
• Handoff with NSUserActivity. The advertise / accept handshake is the same shape as iOS 8+. iOS 26 added userInfo size budget reporting via NSUserActivity.userInfoSize — you can now check if your activity payload is approaching the system's silent-truncation threshold.
• Universal Links + deep-link routing. iOS 26 added .didReceiveLink() to the App scene-modifier set for SwiftUI apps. Before, deep-link handling required an .onOpenURL closure or AppDelegate-based routing; the new modifier is more declarative and integrates with NavigationStack path bindings cleanly.

These are incremental for most consumer apps — productivity apps with cross-device flows benefit most. WWDC25 'What's new in NSUserActivity and Continuity' covers the changes; the iOS & iPadOS 26 release notes (developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-26-release-notes) name each delta with the deprecation status.

iOS 26 release notes references

Apple's release notes are the authoritative source for shipped APIs and known regressions. For iOS 26 specifically:

• iOS & iPadOS 26 release notes: developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-26-release-notes
• SwiftUI iOS 26 changes: developer.apple.com/documentation/Updates/SwiftUI
• WWDC25 session videos: developer.apple.com/videos/wwdc2025
• FoundationModels framework: developer.apple.com/documentation/foundationmodels