What's New in SwiftUI at WWDC 2026: The Complete Developer Guide for iOS 27 and Xcode 27

WWDC 2026 delivered one of SwiftUI's most substantive annual updates since the framework launched in 2019. Rather than a single headline feature, iOS 27's SwiftUI release moves four surfaces at once: lists get first-class reordering, documents get a new reader/writer protocol family, toolbars get an overflow model with explicit priority, and error presentation finally gets a binding you can hand an Error directly. Layered on top are Liquid Glass automatic adoption, @State lazy initialization, AsyncImage caching, a new cross-fade navigation transition, and deep integration with Xcode 27's on-device AI coding agents.

This is the definitive developer breakdown — every new API, every code sample, and every decision you need to make before iOS 27 ships this fall.

1. Refreshed Look and Feel: Liquid Glass Automatic Adoption (Session 269, 2:12)

The most immediately visible change requires zero code changes from most developers. Liquid Glass design gained a few changes here and there, and fortunately, SwiftUI adopts many of them automatically. You don't need to write additional code for things like glass tint, as they are automatically applied to your app's user interface.

That said, apps using both UIKit and SwiftUI require attention. UIKit's UIGlassEffect and SwiftUI's .glassEffect() modifier do not automatically synchronize visual identity across a mixed codebase. Apps that span both frameworks — still the majority of large production applications — should audit their GlassEffectContainer boundaries to ensure coherent morphing behavior under the updated compositing pipeline.

Developers who built separate accessibility code paths to compensate for iOS 26's contrast issues should test whether iOS 27's intensity slider and design streamlining resolve the underlying issue, or whether those custom workarounds still need to be maintained.

New: appearsActive Environment Value

SwiftUI now exposes an appearsActive environment value that lets views respond to whether their window is the active, focused window — useful on iPadOS and macOS where multiple windows may be on screen at once.

struct SidebarFooterView: View {
    @Environment(\.appearsActive) private var appearsActive

    var body: some View {
        MyAccountView()
            .opacity(appearsActive ? 1 : 0.5)
    }
}

New: Prominent Tab Role

SwiftUI also introduces a new prominent tab role. You can use the prominent role for trailing-separated tabs, similar to search.

TabView {
    Tab { EventsTab() }
    Tab { HolidaysTab() }
    Tab(role: .prominent) {
        CartTab()
    }
}

Resizability and Live Preview Resize Handles

In Xcode 27, Live Previews now have resize handles that allow you to test how your app responds to being interactively resized. This allows you to instantly preview how an app will behave when using iPhone Mirroring, or when running it as an iPhone app on iPad.

UIKit adds new layouts that adapt for iPhone Mirroring, and widgets can now be customized through App Intents and dynamic styling.

2. Toolbar Enhancements (Session 269, 6:15)

Toolbars gain three new APIs in iOS 27 that solve the long-standing problem of toolbar items getting clipped or dropped on smaller devices.

visibilityPriority(_:) and ToolbarOverflowMenu

Apple introduced a collection of new toolbar view modifiers that allow us to control toolbar visibility more precisely. You can choose which toolbar items should have higher visibility priority on smaller devices, hide secondary items in the overflow menu, and pin an item to the trailing position of the top bar.

StickerPageView()
    .toolbar {
        ToolbarItemGroup {
            UndoButton()
            RedoButton()
        }
        .visibilityPriority(.high)

        ToolbarOverflowMenu {
            ChoosePhotoButton()
            ExportAsImageButton()
            ClearAllStickersButton()
        }

        ToolbarItem(placement: .topBarPinnedTrailing) {
            ShareButton()
        }
    }

ToolbarOverflowMenu groups actions that should collapse into a "more" menu when the bar runs out of room. topBarPinnedTrailing is a new placement that keeps a critical control — like a Share button — anchored at the trailing edge regardless of available space.

toolbarMinimizeBehavior(_:for:): Auto-Minimize on Scroll

ScrollView {
    StickerListView()
}
.toolbarMinimizeBehavior(.onScrollDown, for: .navigationBar)

This new modifier hides the navigation bar as the user scrolls down and restores it when they scroll back up — a pattern previously requiring manual UIKit override.

3. The New Document API (Session 269, 8:06)

The biggest architectural addition in this year's SwiftUI is a ground-up redesign of how document-based apps handle file I/O. FileDocument and ReferenceFileDocument remain for backward compatibility, but the new protocols are clearly the future.

Why the Old Model Fell Short

The old FileDocument protocol merged the document's in-memory representation with its read/write logic into a single type, and it operated on Data rather than directly on a URL. Large documents — think video editors, vector graphics tools, or any document with many embedded assets — had to hold the entire file in memory just to save a change. Progress reporting was limited. Multiple export formats were awkward.

WritableDocument and ReadableDocument

The expanded SwiftUI Document API gives you direct control over the structure of your saved documents. For reading and writing, conform to WritableDocument and ReadableDocument, which offer asynchronous, incremental disk operations and progress reporting via the Foundation Subprogress API.

The two top-level protocols are ReadableDocument and WritableDocument. A read-only type conforms to ReadableDocument alone. A read-write type conforms to both, and Apple provides a Document typealias that bundles the two so you can adopt the pair without naming each one. Both are class-bound (: AnyObject), which is the visible signal that documents are reference types in this model. The actual disk I/O moves into a reader and a writer abstraction, DocumentReader and DocumentWriter, each parameterized by the snapshot type your document serializes.

protocol ReadableDocument : AnyObject
protocol WritableDocument : AnyObject

The key design insight is snapshot-based diffing. When you save, your document produces a lightweight snapshot that represents the in-memory state at that moment — @MainActor, async, throws. The DocumentWriter then receives the snapshot and a previous snapshot, enabling incremental writes: only the changed portions of a large file need to be serialized.

@Observable
final class StickerDocument: WritableDocument {

    static let writableContentTypes: [UTType] = [.stickerDocument]

    @MainActor
    func snapshot(contentType: UTType) async throws -> sending PageSnapshot {
        makeSnapshot()
    }

    func writer(configuration: sending WriteConfiguration) -> sending Writer {
        Writer(contentType: configuration.contentType)
    }
}

struct Writer<Snapshot>: DocumentWriter {
    typealias Snapshot = PageSnapshot
    let contentType: UTType

    nonisolated func write(
        snapshot: sending PageSnapshot,
        to destination: URL,
        previous: sending PageSnapshot?,
        progress: consuming Subprogress
    ) async throws {
        if contentType.conforms(to: .stickerDocument) {
            // write custom format
        } else if contentType.conforms(to: .png) {
            let context = CGContext(/* ... */)
            context.draw(/* ... */)
        }
    }
}

Writing directly to destination: URL is the big shift from the old model — you have the file URL, you can use any I/O library, and you can write incrementally with reported progress.

DocumentCreationSource: Custom New-Document Flows

The DocumentCreationSource API lets you declare multiple creation sources with a NewDocumentButton for each.

@main
struct Stickers: App {
    var body: some Scene {
        DocumentGroupLaunchScene("Create a Sticker Page") {
            NewDocumentButton("New Sticker Page", source: .blank)
            NewDocumentButton("Sticker Page from Photo…", source: .photo)
        }
        DocumentGroup { document in
            StickerPageDocumentView(document)
        } { configuration, context in
            StickerDocument(configuration: configuration, context: context)
        }
    }
}

extension DocumentCreationSource {
    static let blank = Self(id: "blank")
    static let photo = Self(id: "photo")
}

This replaces the previous pattern of a single "new document" entry point with no creation context passed through to the document initializer.

FileWrapperDocumentReader and FileWrapperDocumentWriter

For documents of small and medium size that need no custom logic, SwiftUI ships FileWrapperDocumentReader and FileWrapperDocumentWriter, each backed by a file wrapper and described by Apple as the efficient choice for the simple case. If your document doesn't need incremental writing or complex diffing, these concrete types mean you don't have to implement DocumentReader/DocumentWriter manually.

4. Presentation and Interaction (Session 269, 15:18)

Drag-to-Reorder: Now Declarative, Works in Any Container

Previously, reordering in SwiftUI required onMove, manual index math, and was limited to List. iOS 27 replaces that entire pattern.

New reorderable container APIs let people drag to rearrange items in any container — not just List — using the same code across List, LazyVGrid, and more. Reordering comes to watchOS for the first time.

Reordering via drag and drop is easier than before with the new reorderContainer view modifier. It also works with List, ScrollView, lazy stacks, and custom layouts. Just apply the reorderable view modifier and handle the reordering action.

struct ContentView: View {
    @State private var landmarks: [Landmark] = []

    var body: some View {
        VStack {
            ForEach(landmarks) { landmark in
                LandmarkView(landmark)
            }
            .reorderable()
        }
        .reorderContainer(for: Landmark.self) { difference in
            difference.apply(to: &landmarks)
        }
    }
}

The ReorderDifference type handles the index math for you. For multi-section containers, there is an overload that takes a collection identifier type, so moves across sections are expressible without custom logic.

It's worth noting that reorderable and swipeActions are no longer limited to specific containers. This is not merely an expansion of their applicable scope; it also reflects further integration of the underlying interaction logic.

Lazy Drag Containers

For large collections, a new lazy drag system avoids materializing payloads before a drag begins. dragContainer(for:itemID:in:_:) marks the container and accepts a payload closure. draggable(containerItemID:containerNamespace:) on each child carries only an identifier — the actual payload is requested only when the drag starts, not when the row renders.

Swipe Actions on Any View (Not Just List)

Add swipeActionsContainer to any ScrollView to enable swipe actions across your layout.

ScrollView {
    LazyVStack {
        ForEach(stickers) { sticker in
            StickerListItemView(sticker: sticker)
                .swipeActions {
                    DeleteButton(sticker: sticker)
                }
        }
    }
}
.swipeActionsContainer()

Previously, .swipeActions only functioned inside a List. You can now use it in ScrollView, lazy stacks, or any custom container.

Item-Binding Confirmation Dialogs and Alerts

Confirmation dialogs and alerts now support the same item-binding pattern used by sheets, so presentations appear automatically when a bound value is set.

struct StickerCanvasView: View {
    var stickers: [Sticker]
    @State private var stickerToDelete: Sticker?

    var body: some View {
        ZStack {
            ForEach(stickers) { sticker in
                PlacedStickerView(sticker: sticker)
            }
        }
        .confirmationDialog(
            "Delete?", item: $stickerToDelete
        ) { sticker in
            DeleteStickerButton(sticker)
        }
    }
}

The item: binding pattern means you set stickerToDelete = someSticker and the dialog appears automatically — no isPresented Bool to manage separately.

Cross-Fade Navigation Transition

Navigation gains a new cross-fade transition that we can use alongside zoom. We still can't control navigation transitions manually, but now we have more built-in options: automatic, zoom, and cross-fade.

.sheet(isPresented: $showSheet) {
    Text("Sheet Content")
        .presentationDetents([.medium])
        .navigationTransition(.crossFade)
}

5. Data Flow and Performance (Session 269, 19:58)

@State Lazy Initialization for @Observable Types

This is a genuinely important fix for apps using the @Observable macro. Previously, if a @State property was initialized with an @Observable class instance, that instance was created eagerly — meaning it could be created before the view was actually needed, and recreated unnecessarily.

@State now supports lazy initialization, text selection on iOS has been enhanced, and alert / confirmationDialog now provide Binding<T?> support.

@Observable class StickerStore { }

struct StickerStoreView: View {
    // store is now lazily initialized, only
    // created once for the lifetime of the view
    @State private var store = StickerStore()

    var body: some View {
        // ...
    }
}

There is one edge case to watch: if you assign a @State property in an init, remove the default value to avoid a compiler error about accessing self before initialization.

// ❌ Compiler error
struct StickerPageView: View {
    @State private var page = StickerPage()
    let title: String

    init(title: String) {
        self.page = StickerPage(title: title) // Error
        self.title = title
    }
}

// ✅ Correct
struct StickerPageView: View {
    @State private var page: StickerPage // No default value
    let title: String

    init(title: String) {
        self.page = StickerPage(title: title)
        self.title = title
    }
}

AsyncImage Caching and Custom URLSession

AsyncImage now supports standard HTTP caching by default, respecting server Cache-Control headers without any code changes. For apps that need explicit cache control, a new asyncImageURLSession(_:) modifier lets you inject a custom URLSession with configured URLCache parameters.

AsyncImage also receives a performance improvement by introducing caching. You can even control the cache by configuring a custom URLSession with a specific cache size.

@Observable class StickerStore {
    static let imageSession: URLSession = {
        let config = URLSessionConfiguration.default
        config.urlCache = URLCache(
            memoryCapacity: 64 * 1024 * 1024,
            diskCapacity: 256 * 1024 * 1024)
        return URLSession(configuration: config)
    }()
}

ForEach(pets) { pet in
    AsyncImage(request: URLRequest(
        url: pet.imageURL,
        cachePolicy: .returnCacheDataElseLoad)
    )
}
.asyncImageURLSession(StickerStore.imageSession)

Layout Performance: Up to 2x Faster

SwiftUI updates include reorderable containers and swipe actions for any container, layouts that resize up to twice as fast, lazy state initialization, and a new document infrastructure with first-class URL access.

The session also mentioned that SwiftUI continues to optimize layout and container-related implementations, bringing noticeable performance improvements in some scenarios.

New @ContentBuilder

A new @ContentBuilder attribute arrives for building reusable content-producing functions:

@ContentBuilder
func stickerLibraryView() -> some View {
    // ...
}

This complements the existing @ViewBuilder and @SceneBuilder family, extending the result-builder pattern to more general content composition scenarios.

6. What's New in Xcode 27 for SwiftUI Developers (Session 258)

A Fully Redesigned Workspace and Toolbar

The Xcode 27 toolbar has been redesigned with new controls, a coding agent entry point, and is now fully customizable with reorderable items.

New Appearance Panel: Per-Project Themes

A new Appearance panel lets you dial in colors and fonts with sliders, choose from preset themes, and assign per-project themes for quick visual identification. For large teams working across multiple codebases simultaneously, per-project colour schemes alone will save context-switching confusion.

Smarter Inline Issues

Predictive issues now use a subtle appearance while typing to reduce distractions, upgrading to full-intensity warnings and errors only after a build. The old behaviour of hammering every keystroke with red underlines is replaced by a gentler "this might be wrong" hint that becomes a full error marker after compilation.

Instant Project Creation

Xcode 27 lets you instantly create untitled projects or open standalone Swift files with previews and playground results, making it easy to prototype on the fly. Creating a new SwiftUI app project is now a single action from the File menu with no wizard questions.

Coding Agents in the Editor

Agent conversations now live in the editor pane with full tab and split support, plus a new /plan command to scope work before making any code changes.

External agents can invoke 20 capabilities through Apple's MCP bridge, including file reads, builds, test runs, live diagnostics, and SwiftUI preview rendering, all delivered as structured JSON requests and responses. This means third-party agents from Anthropic (Claude), Google (Gemini), and OpenAI can now directly render and interact with your SwiftUI previews.

Notably, Xcode 27 also adds two dedicated SwiftUI skill packages for agentic sessions: SwiftUI Specialist and What's New in SwiftUI, which guide the coding agent through iOS 27's new APIs and SwiftUI conventions automatically.

Device Hub

Device Hub provides a unified window for running, inspecting, and evaluating your app across simulators and physical devices, including accessibility settings and iPhone Mirroring resize testing.

For SwiftUI developers specifically, Device Hub is the complement to Live Preview's new resize handles — you can test your adaptive layouts across simulators and physical devices from a single unified interface.

Organizer: New Storage and Hitch Metrics

In Xcode 27, there is a new Storage metric that shows how much space your app and your app's data have been taking up. The metric breaks down documents, data, and binary size.

The new hitches metric surfaces issues in more places than scrolling, like understanding how apps use Liquid Glass and SwiftUI views.

The redesigned Organizer surfaces high-impact issues first, adds storage and animation hitch metrics, introduces Metric Goals, and can generate agent-powered fix recommendations.

Top Functions View in Instruments

A new Top Functions view in Instruments quickly identifies the most expensive code paths, cutting investigation time when tracking down performance regressions.

Localization via Coding Agents

Coding agents in Xcode 27 can set up localization, create String Catalogs, and generate translations for multiple languages. What used to be hours of export/import/edit cycles can now be initiated with a natural language prompt to the agent.

7. Swift 6.4: What SwiftUI Developers Need to Know

Swift 6.4 includes an anyAppleOS availability shorthand, suppressible compiler warnings, async support in defer blocks, and improved type-checker diagnostics. Parts of the OS kernel are now being written in Swift.

The anyAppleOS availability shorthand is a welcome quality-of-life fix for developers who maintain cross-platform SwiftUI apps and have grown tired of enumerating #available(iOS x, macOS y, watchOS z, tvOS w, visionOS v, *) at every availability check.

8. The Bigger Picture: What This Year's SwiftUI Tells You

SwiftUI continues to move toward a more flexible and system-integrated framework. This year's updates may not completely change how we build apps, but they remove many small limitations around containers, navigation, toolbars, and document-based workflows.

There is also a clear industry-level signal in Apple citing Notion as a major app moving its UI from cross-platform web technologies to native SwiftUI for performance and consistency. Apple is actively recruiting high-profile apps to SwiftUI — which historically has meant the APIs needed to make those apps work are coming.

Developers who ship App Intents, on-device intelligence, and foldable-ready layouts early will be the ones Siri can actually use — and the ones that feel native on the next wave of hardware.

API Quick Reference for iOS 27 / SwiftUI

Related WWDC 2026 Sessions for SwiftUI Developers

All sessions are available free at https://developer.apple.com/videos/wwdc2026

Published June 10, 2026. Developer betas of iOS 27 and Xcode 27 are available now to Apple Developer Program members at developer.apple.com/download. Public betas launch in July 2026. All APIs are subject to change before final release this fall.