What's New in SwiftUI

Document Apps Get Real Disk Control

SwiftUI's expanded Document API is the biggest architectural change. Apple now separates a document object, a snapshot, and async reader/writer types. That gives document apps direct control over package structure, progress reporting, incremental writes, and export formats without blocking the main actor.

@Observable
final class SketchDocument: WritableDocument {
    static let writableDocumentTypes: [UTType] = [.sketchPackage, .png]

    @MainActor
    func snapshot(contentType: UTType) async throws -> sending SketchSnapshot {
        SketchSnapshot(layers: layers, canvasSize: canvasSize)
    }

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

The practical migration target is not "rewrite every document app." Start where large packages, image exports, or repeated autosaves currently make the UI feel heavy.

Toolbars Become Resize-Aware

iPad and Mac windows already resize. iOS 27 adds more pressure because SwiftUI iPhone apps can become resizable in more contexts, and Xcode 27 previews expose resize handles. SwiftUI now lets you say which actions must stay visible, which actions belong in overflow, and when navigation chrome should minimize on scroll.

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

        ToolbarOverflowMenu {
            ExportButton()
            ResetButton()
        }

        ToolbarItem(placement: .topBarPinnedTrailing) {
            ShareButton()
        }
    }
    .toolbarMinimizeBehavior(.onScrollDown, for: .navigationBar)

Treat this as a ranking exercise. Primary editing and sharing actions should survive narrow widths; setup and destructive actions usually belong in overflow.

Reordering, Drag Containers, and Swipes

Reorderable Collections

Reordering is no longer tied to List. Add .reorderable() to the generated items and .reorderContainer to the container that owns the move. The drag-and-drop code-along shows the same model extending to multi-item drags and custom transfer rules.

LazyVGrid(columns: columns) {
    ForEach(stickers) { sticker in
        StickerCell(sticker)
    }
    .reorderable()
}
.reorderContainer(for: Sticker.ID.self) { difference in
    stickers.apply(difference: difference)
}

Swipe Actions Outside List

Swipe actions also move beyond List. For row-like custom layouts, add the normal .swipeActions to each row and place .swipeActionsContainer() on the scroll container.

ScrollView {
    LazyVStack(spacing: 8) {
        ForEach(messages) { message in
            MessageRow(message)
                .swipeActions(edge: .trailing) {
                    Button("Archive") { archive(message) }
                    Button("Flag") { flag(message) }
                }
        }
    }
}
.swipeActionsContainer()

Presentation APIs Get the Sheet Pattern

Alerts and confirmation dialogs now support item bindings, matching the pattern SwiftUI developers already use for sheets. That makes command-driven UI cleaner: set an optional model value, let SwiftUI present, then clear it.

@State private var itemToDelete: LibraryItem?

var body: some View {
    LibraryGrid(items: items) { item in
        itemToDelete = item
    }
    .confirmationDialog("Delete?", item: $itemToDelete) { item in
        Button("Delete", role: .destructive) {
            delete(item)
        }
    }
}

AsyncImage Caching

AsyncImage now uses standard HTTP caching by default, honoring server cache headers without app code. Xcode 27-built apps can pass a custom URLRequest and provide a custom URLSession with .asyncImageURLSession when they need cache policy or capacity control.

AsyncImage(request: URLRequest(
    url: artworkURL,
    cachePolicy: .returnCacheDataElseLoad
))
.asyncImageURLSession(ArtworkStore.imageSession)

Lazy @State Initialization

Apple also calls out a separate data-flow fix that will remove accidental work in many apps: classes stored in @State are initialized lazily, once per view lifetime. That behavior comes from State becoming a macro and is back-deployed to iOS 17, macOS 14, and aligned releases when you build with the new toolchain.

Lazy Stacks and Scrolling

For long custom scrollers, the lazy stack session is a useful companion: prefer stable estimates, avoid forcing offscreen views to load early, and use the new prefetch behavior intentionally for expensive content.

Platform Map