What's New in SwiftUI for macOS 27

Documents Are the Main macOS Story

The new document API maps cleanly to Mac apps: package formats, autosave, edited state, exports, progress, and direct disk work are first-class concerns. Apple describes writable documents as producing snapshots and handing those snapshots to an async writer that can compare against a previous snapshot.

The practical change is separation of responsibilities. The document object owns observable state for the UI, the snapshot captures a stable version for saving, and the writer performs disk work off the main actor. For package documents, comparing the new snapshot with the previous snapshot lets you write only the files that actually changed.

struct PackageWriter: DocumentWriter {
    typealias Snapshot = ProjectSnapshot

    nonisolated func write(
        snapshot: sending ProjectSnapshot,
        to destination: URL,
        previous: sending ProjectSnapshot?,
        progress: consuming Subprogress
    ) async throws {
        try await writeChangedFiles(snapshot, previous: previous, to: destination)
    }
}

Incremental AppKit Adoption Is Better Supported

Apple's interop session focuses on macOS but says the concepts apply elsewhere. The migration path is small: make shared models observable, host SwiftUI where the UI is changing anyway, and keep AppKit for mature views that still earn their place.

This is relevant to SwiftUI in macOS 27 because the new pieces do not require an all-or-nothing rewrite. A document window can keep its AppKit outline view, add a SwiftUI inspector, and share one observable model between both layers.

@Observable
final class ColorModel {
    var hue = 0.4
    var saturation = 0.8
    var brightness = 0.9
}

final class InspectorController: NSViewController {
    let model = ColorModel()

    override func loadView() {
        view = NSHostingView(rootView: ColorInspector(model: model))
    }
}

Use SwiftUI scenes from an existing NSApplicationDelegate when the new surface is naturally a window, settings panel, or menu bar extra. Use a hosting view for one embedded region.

Mac Chrome Needs Real Ranking

The Mac has room, but not infinite room. Toolbar item priority, overflow menus, and pinned actions help wide Mac windows and narrow companion windows share the same view code. The SwiftUI session also calls out the appearsActive environment value for dimming custom sidebar/footer content when a Mac or iPad window is inactive.

Use the priority APIs even when the main Mac window looks spacious. Document apps often open inspectors, compact utility windows, and secondary windows where toolbar decisions become visible. The active-window environment value keeps custom chrome aligned with the system dimming behavior.

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

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

Menus and Gestures Can Move Gradually

The interop session demonstrates SwiftUI in the main menu and AppKit gesture recognizers inside SwiftUI. That matters for Mac apps because menu structure, keyboard shortcuts, and pointing-device gestures often predate the SwiftUI view layer. Move one piece at a time rather than rewriting the app shell.

The menu example is intentionally small: a command can be declared in SwiftUI while the action still calls existing application code. That makes it a migration tool for real Mac apps, not just a clean-slate pattern.

CommandMenu("Project") {
    Button {
        openExportPanel()
    } label: {
        Label("Export", systemImage: "square.and.arrow.up")
            .labelStyle(.titleAndIcon)
    }
}

State and Image Loading Are Runtime Work

macOS apps often have long-lived windows, but they also create transient inspectors, popovers, search panels, and preview panes. The lazy @State initialization change means observable classes stored in @State are not constructed until SwiftUI actually needs the state storage.

AsyncImage also respects HTTP caching by default on OS 27. That is useful for package browsers, asset catalogs, remote documentation panes, and any Mac UI that repeatedly shows the same thumbnails.

struct AssetInspector: View {
    let asset: Asset
    @State private var model = InspectorModel()

    var body: some View {
        AsyncImage(url: asset.previewURL)
            .task { await model.loadDetails(for: asset) }
    }
}