SwiftUI - watchOS 27

What's New in SwiftUI for watchOS 27

watchOS 27 is not a giant SwiftUI API release, but the important changes are concrete. Reorderable containers arrive on watchOS for the first time, AsyncImage caching reduces repeated artwork fetches, and lazy @State initialization avoids wasted setup work in short-lived views.

June 15, 2026 5 minute read watchOS 27
WWDC26 watchOS 27 Apple Watch hero image
Apple's watchOS 27 guide frames the platform around glanceable, wrist-first app experiences.

watchOS focus

Reordering arrives

Apple explicitly calls out watchOS support for the new reorderable container APIs.

 Cached images

AsyncImage now respects HTTP caching, which helps repeated small artwork on watchOS.

 Lazy State

The State macro change avoids eager setup work in short-lived watch views.

Reordering Comes to watchOS

In the main SwiftUI session, Apple says reorderable containers bring reordering to watchOS for the first time. That is useful for small ordered sets: favorites, complications, workout intervals, timers, routines, and shortcuts. Keep the collection short enough that direct manipulation remains comfortable.

The API is the same shape as the larger platforms: mark the generated items as reorderable, then put the reorder container on the parent that owns the mutation. The closure receives the difference; your model still decides how that move is committed.

Requires watchOS 27 SDK
Fallback for watchOS 26

Use explicit move-up and move-down controls, or send ordering to the paired iPhone app. Avoid building a custom drag system for older watchOS releases unless reordering is the core feature. 

List {
    ForEach(favorites) { favorite in
        FavoriteRow(favorite)
    }
    .reorderable()
}
.reorderContainer(for: Favorite.ID.self) { difference in
    favorites.apply(difference: difference)
}

Keep New Interactions Small

Reordering is new on watchOS, but that does not make every list a drag surface. Use it for short ordered collections where the order is the feature. For longer editing flows, keep explicit move controls or send the work to a larger screen.

A good rule: if the user cannot understand the whole ordered set without scrolling for a long time, the watch is probably the wrong place for direct reordering. Use the new API for favorites and quick preferences, not full project organization.

Lazy @State Initialization

Lazy @State initialization is especially helpful for watch views that are reconstructed often during navigation or timeline updates.

Before this toolchain change, an observable class created inline for @State could do work even when SwiftUI did not keep that view instance. With the new macro-backed behavior, the class is created only when SwiftUI needs the state storage. That matters on watchOS because tiny views are cheap to describe but expensive work in their initializers still shows up as sluggish navigation.

Back-deployed 
struct TimerPresetRow: View {
    let preset: TimerPreset
    @State private var model = PresetRowModel()

    var body: some View {
        Button(preset.title) {
            model.start(preset)
        }
    }
}

Cached Image Loading

AsyncImage caching is a different change, but it also helps watch apps when the same artwork, route image, or contact image reappears.

The useful part is that ordinary HTTP caching now works by default. A feed that scrolls away from a contact image and then back to it should not repeatedly hit the network when the server cache headers allow reuse. Build with Xcode 27 when you need to supply a custom request or URL session.

Requires watchOS 27 
AsyncImage(url: contact.avatarURL) { image in
    image.resizable().scaledToFill()
} placeholder: {
    ProgressView()
}

Sources