What's New in SwiftUI for iOS 27

Resizable iPhone Layouts

Apple's SwiftUI session explicitly calls out iOS 27 iPhone app resizing and Xcode 27 resize handles in Live Previews. The code impact is straightforward: stop assuming a single compact phone canvas. Prefer layout rules driven by size, space, and content rather than device idiom.

This is still SwiftUI work even when the app looks unchanged at normal iPhone size. Views that branch on horizontalSizeClass, available width, and content density will survive iPhone Mirroring, iPhone-on-iPad, and preview resizing better than views that assume every iPhone screen is one fixed column.

struct LibraryLayout: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass

    var body: some View {
        let columns = horizontalSizeClass == .compact ? 2 : 4

        ScrollView {
            LazyVGrid(columns: Array(repeating: GridItem(.flexible()), count: columns)) {
                ForEach(items) { item in
                    LibraryTile(item)
                }
            }
        }
    }
}

Rank the Top Bar

iOS is where toolbar overflow hurts first. The OS 27 APIs let you keep undo, redo, and share where users can reach them while moving secondary commands into overflow. Use minimization only when the content area benefits from it, such as feeds, editors, galleries, and document canvases.

Treat the toolbar as a priority list, not a bag of buttons. The system can collapse low-priority items as the view narrows, but only if you mark the commands that must stay visible and move optional commands into an explicit overflow menu.

NavigationStack {
    FeedView()
        .toolbar {
            ToolbarItemGroup {
                FilterButton()
                SortButton()
            }
            .visibilityPriority(.high)

            ToolbarOverflowMenu {
                ManageDownloadsButton()
                ResetLayoutButton()
            }
        }
        .toolbarMinimizeBehavior(.onScrollDown, for: .navigationBar)
}

Rows Without List Lock-In

On iPhone, custom feeds often need row gestures without List styling. In iOS 27, two separate changes matter: swipe actions can be coordinated by a custom scroll container, and reordering can move to stacks or grids.

Swipe Actions in Custom Scroll Views

Use this when the UI is still row-like, but the visual design is not a system List: inbox rows, store carts, media queues, saved items, and compact task feeds.

The row keeps the familiar .swipeActions modifier. The new part is the container modifier on the scroll view, which coordinates swipe state across all rows in that custom scroller.

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

Reorderable Stacks and Grids

Reordering is the better fit when the user is arranging content, not dismissing a row: photo picks, board columns, launcher tiles, dense media cards, and inspector panels.

The generated children opt into dragging with .reorderable(). The parent container receives the difference and applies it to the source array, so model mutation stays in one place.

LazyVGrid(columns: columns) {
    ForEach(cards) { card in
        CardTile(card)
    }
    .reorderable()
}
.reorderContainer(for: Card.ID.self) { difference in
    cards.apply(difference: difference)
}

Image Loading

iOS apps with feeds, stores, and image-heavy lists benefit from the AsyncImage change immediately: it now respects HTTP caching by default. Build with Xcode 27 when you need per-request cache policy or a custom URL cache.

Previously, scrolling back to an image could trigger another download path unless the app built its own cache around AsyncImage. With the OS 27 behavior, server cache headers are enough for the common case. Use the request-based initializer only when a feed needs a specific cache policy.

AsyncImage(request: URLRequest(
    url: product.artworkURL,
    cachePolicy: .returnCacheDataElseLoad
))

Item-Based Confirmation

Alerts and confirmation dialogs now follow the same item-binding pattern SwiftUI developers already use for sheets. On iPhone, that keeps command-driven UI small: store the selected model value, present the dialog, and let SwiftUI clear the presentation when the item goes away.

@State private var messageToDelete: Message?

var body: some View {
    MessageList(messages) { message in
        messageToDelete = message
    }
    .confirmationDialog("Delete message?", item: $messageToDelete) { message in
        Button("Delete", role: .destructive) {
            delete(message)
        }
    }
}

Lazy @State Initialization

The lazy @State initialization change is a separate win on iPhone because short-lived parent view updates used to waste work when a child view stored an observable class in State.

This is a toolchain behavior change, not a new iOS-only visual API. If a child view declares an observable object in @State, SwiftUI can now avoid constructing that object until the state storage is actually used for the view lifetime.

struct FeedFilterView: View {
    @State private var model = FeedFilterModel()

    var body: some View {
        FilterControls(selection: $model.selection)
    }
}