iPhone Duo Simulator Is Here: The Developer Checklist from Apple's Own Sessions

In my first iPhone Duo post I said the audit was a documentation-and-code review, because there was no way to run any of it in Simulator. That stopped being true on September 18, when Apple released the first Xcode 27.1 beta. The device ships October 23, so there are about five weeks left.

Apple has now published enough that the work can be listed in full. This post is that list: what the beta gives you, what it does not, and every area Apple’s own sessions say an app has to take care of, with the session that covers each one. Code samples are quoted from those sessions, not written by me.

What Xcode 27.1 gives you, and what it doesn’t

Piece	Detail and source
Xcode	27.1 beta 1, build 27A9269 (iClarified)
Host requirement	Apple silicon Mac, macOS 26.6 or later (MacRumors)
SDKs	iOS 27.1, iPadOS 27.1, and Swift 6.4 (AppleInsider)
Simulator	An iPhone Duo runtime, driven from Device Hub with controls to open, close, rotate and fold the device (Apple)
Previews	A Display group in the canvas, for previewing content on a device’s alternative display (AppleInsider)
Design	Figma and Sketch kits for iPhone Duo, in Apple Design Resources (Apple)

The SDK version decides how much of the device an app gets. Apple’s Prepare your app for iPhone Duo session says the iOS 27 SDK extends an app to the left of the status bar on the inner display, and the iOS 27.1 SDK reaches the screen edge and lays standard navigation and toolbar buttons out vertically. That settles the rebuild question from the launch coverage: an unmodified build can run on Duo, per The Mac Observer, but the full-screen vertical layout needs a rebuild against 27.1.

The beta has three known limits, per Apple’s release notes as reported by AppleInsider. StandBy is not available, running and debugging most app extensions is not currently supported, and the first Simulator launch can take several minutes. I have not confirmed which extension types are affected, so I treat widgets and share extensions as unverified. A Simulator pass is also not a substitute for hardware, and camera behavior in particular needs a real device.

Layout, bars and safe areas

This is where most existing apps will spend their time, and none of it is Duo-only work.

Size classes, not orientation or idiom. Per Apple, the outer display is regular vertical and compact horizontal in portrait, and compact in both in landscape. The inner display is regular in both, and it does not honor supported interface orientations. Apple’s design session says to design for two size classes, compact width and regular width, and to avoid fixed widths and breakpoints tied to specific screens.

Stop reading the main screen. Apple says referencing the main screen is ambiguous on a two-display device and will be deprecated. Its replacement, from the session:

// Before
let screenScale = UIScreen.main.scale

// After
let screenScale = traitCollection.displayScale

Safe areas are asymmetric. Controls move to the side, so insets on opposite edges are not equal. From the same session:

// Don't assume insets on opposite sides are equal
let width = view.bounds.width - view.safeAreaInsets.left * 2

// Handle each side independently
let width = view.bounds.inset(by: view.safeAreaInsets).width

Vertical buttons can land on the left or the right in landscape and in Split View, so nothing should assume a side. Foreground content stays inside the safe area, and backgrounds extend past it.

Use system containers so the bars adapt. In Raise the bar with iPhone Duo, Apple’s step one is to rebuild and use the bars that navigation containers provide: NavigationStack, NavigationSplitView and TabView in SwiftUI, and UINavigationController and UITabBarController in UIKit. A hand-built UIToolbar, UINavigationBar or UITabBar is not considered for the vertical bar. Toolbar items should have both an icon and a title, because the title is used in overflow menus, and text-only items stay horizontal.

The same session covers the rest of the bar work:

Area	What Apple says
Ordering	Back or close at the top, prominent actions next, remaining items below a spacer
Custom views	Set an axis with `axisBehavior`, `.verticalPreferred` or `.horizontalOnly`, and prefer symbol-only items
Badges	Use the badge API to turn a text-and-symbol item into a symbol-only one
Overflow	Move custom overflow into `ToolbarOverflowMenu` or `additionalOverflowItems`, and reserve the ellipsis symbol for overflow
Priority	Set `visibilityPriority` so frequent actions such as Compose survive overflow longer
Compression	Choose whether toolbar items or the tab bar stay visible longer with `toolbarVerticalCompressionBehavior`
Opt out	Single-page, bottom-heavy layouts like a calculator, and sheets with one close button, can disable the vertical bar

Corners and the inner display. Apple recommends the concentricity APIs from iOS 26 to match screen corners, ConcentricRectangle in SwiftUI and UICornerConfiguration in UIKit. For the inner display, its design session offers three options: split views that keep the same hierarchy as the outer display, a rearranged two-column layout, or a sidebar tab bar for information-dense apps. Functionality should never depend on a pose.

Two-pane layouts have an API. Arrangement views arrive in iOS 27.1. From Strike a pose with adaptive layouts:

ArrangementView {
  PlayerView()
} secondary: {
  UpNextView()
}
.arrangementViewStyle(.split)

Apple’s rule of thumb is split when both views must stay visible, and overlay when one is clearly in front and the other can be partly covered. Two things to avoid: a NavigationSplitView inside an ArrangementView, and an ArrangementView inside a List or ScrollView. Where a control has to be placed by hand around the hinge or a camera, reservedRegions(kind:) returns those regions, .division for the fold and .occlusion for cameras.

Hinge, scenes and cameras

Three areas are where a Duo-specific code path appears, and each has a way to get it wrong.

The hinge drives effects, not layout. From Leverage multiple displays and scenes:

.onHingeChange { _, context in
    // A null hinge means the device doesn't have one
    if let hinge = context.hinge, hinge.status == .partiallyOpen {

    }
}

UIHingeInteraction is the UIKit equivalent. Apple’s guidance is to check for a null hinge, reset any value when the hinge is not being read, and use arrangement and region APIs for layout instead of hinge data.

Scenes. Duo is the first iPhone to support multiple instances of an app’s UI, and new windows can be created only on the inner display. Request them with UIWindowSceneActivationAction, and handle the error, because availability is dynamic. An app that already supports multiple scenes on iPad has a head start. Scene accessories let an app show content on both displays at once, including a CameraCaptureAccessory that puts supplementary UI on the outer display while the camera runs on the inner one.

Cameras. Per Build a great camera experience, Duo has two front cameras, an outer ultrawide that supports 4K at 120 fps and an inner under-display ultrawide at 1080p up to 60 fps. Both report .front, but the displays can face opposite directions, so a front camera is not always facing the person. The Virtual Front Camera switches between them and tops out at 1080p and 60 fps, without depth. Apps that need the individual cameras, or depth, take on the switching and should adopt AVCaptureDeviceDirectionCoordinator. Apple also says to adopt the rotation coordinator and then disable sensor orientation compensation.

Where AI-assisted work fits

In the first post I used Xcode Intelligence on the size-class rewrite. It was useful for the mechanical part, finding every UIScreen.main reference and drafting the replacement, but it could not check its own output, because there was nothing to run a Duo layout against.

That is the AI angle, and it is about verification. An AI-drafted layout change is only as trustworthy as the loop that tests it. Apple’s Prepare session also says Xcode 27.1 includes an App Resizability skill, formerly App Modernization, with support for SwiftUI and iPhone Duo. I have not run it, and I am not going to claim what it changes in a real codebase. Its existence is the point: Apple expects the mechanical adaptation work to be tool-assisted.

Whoever writes the test, a person or a tool, should include the display change mid-session. A layout that looks right in each pose at launch can still lose state when the display changes underneath it, and a screenshot per pose will not catch that.

The checklist, and where to get help

Area	What to check	Apple session
Build	Rebuilt against the iOS 27.1 SDK in Xcode 27.1	Prepare your app
Layout	Size classes only, no orientation, idiom or fixed-width branches	Prepare your app, Design
Screens	No `UIScreen.main`, use the window scene or trait collection	Prepare your app
Safe areas	Each side handled independently, backgrounds extend past them	Prepare your app
Bars	System containers, icon and title on every item, overflow and priority set	Raise the bar
Navigation	`NavigationSplitView` or `UISplitViewController`, sidebar tab bar where it fits	Prepare your app
Custom layout	`ArrangementView` for split or overlay, `reservedRegions(kind:)` for hinge and cameras	Adaptive layouts
Hinge	Null hinge handled, used for effects only	Multiple displays and scenes
Scenes	Errors handled on new-window requests, inner display only	Multiple displays and scenes
Camera	Virtual or individual cameras chosen, direction and rotation coordinators adopted	Camera experience
Multitasking	Split View tested by dragging the app to each side	Prepare your app
Extensions	Listed, and marked unverified in this beta	AppleInsider

If I had to order it, the build, size-class and UIScreen.main work comes first, because it is the same work Apple has asked for since iPad multitasking. Safe areas and bars come next, since they change what every screen looks like. The hinge, scenes and camera work only matters to apps that use those features.

Apple has built more support around this than for a typical release, all from the iPhone Duo developer hub:

Six sessions, all linked in the table above and the references: design, preparing your app, bars, adaptive layouts, multiple displays and scenes, and cameras.
Group Labs on September 16 and 17. The recordings are posted: September 16 and September 17.
Q&As on September 23, per the hub: Photos and Camera at 7 to 9 a.m. and 6 to 8 p.m. PT, and SwiftUI and UIKit each at 8 to 10 a.m. and 5 to 7 p.m. PT. That is the place to bring the questions this beta cannot answer.
Workshops held around the world, listed on the events page.
Documentation and guidelines: Preparing your app for iPhone Duo and the Human Interface Guidelines.

What Xcode 27.1 gives you, and what it doesn’t

Layout, bars and safe areas

Hinge, scenes and cameras

Where AI-assisted work fits

The checklist, and where to get help

References