iPhone Duo app development: what to test before October 23

iPhone Duo app development has a hard deadline. Apple confirmed the device becomes available October 23, and every iOS team shipping to it needs a toolchain, a layout audit, and a test pass finished before that date.

What is iPhone Duo, and when does it ship?

Apple's own developer news post on the launch is direct about the date: "When iPhone Duo becomes available on October 23, it will run iOS 27.1." That release "builds on the foundation of iOS 27" with features Apple describes as purpose-built for the foldable design, which matters for planning: it's a point release your existing iOS 27 codebase already targets, with a device-specific layer added on top, rather than a new major OS version carrying its own multi-year adoption curve.

What's new in Xcode 27.1 beta for iPhone Duo?

The same announcement lays out the tooling side in one sentence: Xcode 27.1 adds development support for iPhone Duo, including updated SDKs and a simulator that supports the device's new poses and orientations, with a beta available later in September. That beta has since shipped, alongside Figma and Sketch design kits and in-person workshops on optimizing apps for Apple's new set of screen sizes. A beta is still a beta, though, and the release notes are specific about where it falls short.

The simulator: new poses, and what doesn't work yet

Three known issues stand out in Xcode 27.1's release notes. StandBy is unavailable in the iPhone Duo simulator runtime. Running and debugging most app extensions is unavailable there too. And initial simulator launch can take several minutes, which is worth knowing before a CI job times out waiting on it rather than after. None of these are workarounds you need to build around long term. They're beta gaps Apple has already logged, and a team hitting one should check its issue number against the release notes before assuming it's a local configuration problem.

SDK and platform versions bundled with the beta

Xcode 27.1 beta includes Swift 6.4 and SDKs for iOS 27.1, iPadOS 27, tvOS 27, watchOS 27, macOS 27, and visionOS 27, and it requires a Mac running macOS Tahoe 26.6 or later. On-device debugging works back to iOS 17, tvOS 17, watchOS 10, and visionOS, so older test hardware isn't automatically stranded by this beta the way it was by some earlier Xcode versions. One project-specific gotcha: apps using iOS 27.1 APIs can throw compile errors when built for Mac Catalyst, and Apple's documented workaround is wrapping the affected code in #if !targetEnvironment(macCatalyst):

#if !targetEnvironment(macCatalyst)
    myIOS271OnlyCode()
#endif

A second, related issue shows up even earlier: projects that target iOS 27.1 can show no Mac Catalyst run destination at all, and Apple's fix there is adding a Mac Catalyst 27.0 minimum deployment in target settings. If your team is still working through Xcode 27's Apple-silicon-only requirement, this beta layers directly onto that same baseline. And because Xcode 27.1 rides on the same Swift 6.4 that made Swift Build the new default in Swift Package Manager, a team already dealing with that build-system change is exactly the team that needs to plan for this beta in the same pass.

What does Apple's Human Interface Guidelines say about designing for iPhone Duo?

Apple published a dedicated HIG page for this, and its central argument is that a foldable screen doesn't need a layout designed per pose.

Two size classes cover every pose

"A compact width layout for the outer display and a regular width layout for the inner display give you the fundamentals for every pose," Apple's iPhone Duo design guidelines state. The instruction that follows is just as direct: don't reinvent your app when it resizes, and let the existing layout expand based on available space instead. If your layout code already branches correctly on size class rather than device model, most of the heavy lifting here is already done. If it branches on device model or hardcoded width, that's the audit item.

Reserved regions: the fold and the two cameras

The HIG describes three reserved regions a layout has to account for: the outer front-facing camera, which is always present and expands into the Dynamic Island; the inner front-facing camera, present only when that camera is active; and the folding region, which divides the inner display when the device is partially open. Apple gives an API for handling all three: SwiftUI's GeometryProxy.reservedRegions(kind:options:layoutDirectionBehavior:) and ReservedRegion, or UIKit's UIView.reservedRegions(kind:options:), which returns UIView.ReservedRegion values, per Apple's technology overview for iPhone Duo. Building with an older Xcode has a real cost here too: Apple's guidance states that building with Xcode 26 or earlier means your app doesn't extend under the status bar and camera at all, so upgrading isn't optional if you want the full screen space.

Vertical toolbars and tab bars

Toolbars, tab bars, and navigation controls move to the side on the outer display, and do the same on the inner display when it's held sideways. The one exception is the inner display in portrait, which keeps standard horizontal bars. When two apps share the inner display through Split View, each one places its controls along its own outer edge, so the left app's controls sit on the left and the right app's on the right. For layout containers, Apple offers the arrangement view: a split or overlay container for a primary and secondary view, available as SwiftUI's ArrangementView or UIKit's UIArrangementViewController. Whether that container fits naturally into an existing HStack/VStack/ZStack structure or a UIKit view hierarchy is often the deciding factor in whether a screen needs a rewrite or a wrap, which is the same fork a team hits when choosing between SwiftUI and UIKit for a new screen. Apple's Device Hub in Xcode previews an app across these poses without needing a physical device.

Handling reserved regions in code

There's no pose enum for the fold or the cameras to switch on. Apple's model is a region you query: GeometryProxy.reservedRegions(kind:options:layoutDirectionBehavior:) in SwiftUI and UIView.reservedRegions(kind:options:) in UIKit both return regions with the same four properties, frame, margins, isActive, and kind. kind is .occlusion for a camera or .division for the fold, and a region can exist in the array and still be inactive: the fold's division region is there even when the device is fully open, and only turns isActive on once it's partway closed. Both APIs are iOS 27.1+ and still in beta. The snippets below assume an iOS 27.1 deployment target; if your app also ships to earlier versions, wrap each call in if #available(iOS 27.1, *).

Reserved regions in SwiftUI

The signature, from the reservedRegions method's reference page, is func reservedRegions(kind: ReservedRegion.Kind, options: ReservedRegion.QueryOptions = [], layoutDirectionBehavior: LayoutDirectionBehavior = .mirrors) -> [ReservedRegion]. A layout reacting to the fold checks .division and isActive directly:

GeometryReader { proxy in
    let foldRegions = proxy.reservedRegions(kind: .division)

    if let fold = foldRegions.first, fold.isActive {
        MySplitContent(avoiding: fold.frame)
    } else {
        MyFullWidthContent()
    }
}

Swap .division for .occlusion to get the camera regions instead.

Reserved regions in UIKit

UIKit's reservedRegions method mirrors the SwiftUI shape: UIView.ReservedRegion has the same frame, margins, isActive, and kind, typed with CGRect and UIEdgeInsets.

let foldRegions = view.reservedRegions(kind: .division)

if let fold = foldRegions.first(where: { $0.isActive }) {
    layoutPanes(avoiding: fold.frame) // your own layout code
}

Adopting ArrangementView

A split or overlay container replaces the HStack/VStack or view-controller-containment code teams used to write by hand for a primary/secondary screen.

Split and overlay styles in SwiftUI

ArrangementView's reference page documents nonisolated struct ArrangementView<Primary, Secondary> where Primary : View, Secondary : View, built with init(primary:secondary:) and styled through arrangementViewStyle(_:):

ArrangementView {
    PrimaryView()
} secondary: {
    SecondaryView()
}
.arrangementViewStyle(.split.axes(.horizontal))

Swap .split for .overlay and the two views stack instead of dividing the display, useful for something like controls over a video rather than beside it.

UIArrangementViewController in UIKit

UIArrangementViewController's reference page documents a UIViewController subclass with setViewController(_:for:animated:) per placement and updateArrangement(_:animated:) for the style:

let arrangementVC = UIArrangementViewController()
arrangementVC.setViewController(PrimaryViewController(), for: .primary)
arrangementVC.setViewController(SecondaryViewController(), for: .secondary)
arrangementVC.updateArrangement(.split.axes(.horizontal))

Where not to put one

Apple's placement guidance for arrangement views is specific: don't put one inside a navigation split view, a list, or a scroll view, since part of its content can become unreachable. Screens already inside one of those containers need a custom layout instead.

Handling the camera switch mid-session

Which of iPhone Duo's two front cameras actually faces the user changes as someone opens or closes the device. Code that assumes AVCaptureDevice.position == .front always means the camera facing the user will sometimes be wrong.

The low-effort path: the virtual front camera

Apps that just want "the front camera" get it from a discovery session, as Apple's full walkthrough on choosing a camera by the direction it faces shows:

let discoverySession = AVCaptureDevice.DiscoverySession(
    deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera],
    mediaType: .video,
    position: .front
)
let frontCamera = discoverySession.devices.first

On iPhone Duo those device types resolve to the virtual front camera, which streams from whichever sensor currently faces forward. That's enough for a simple selfie preview.

Tracking direction with AVCaptureDeviceDirectionCoordinator

Apps capturing from both physical cameras directly need to track direction themselves. AVCaptureDeviceDirectionCoordinator takes a preview view, the device types to watch, and a change handler that fires with an AVCaptureDeviceDirectionMap:

let coordinator = AVCaptureDeviceDirectionCoordinator(
    view: previewView,
    deviceTypes: [.builtInOuterUltraWideCamera, .builtInInnerUltraWideCamera]
) { directionMap in
    let forwardFacing = directionMap.forwardFacingDeviceDescriptors
    guard let camera = forwardFacing.first else { return }
    // Reconfigure the capture session with `camera` here.
}

Act on forwardFacingDeviceDescriptors and backwardFacingDeviceDescriptors, not position. Apple's own code comment warns that assigning isVideoMirrored raises an exception while automaticallyAdjustsVideoMirroring is still on, so turn that off first:

if connection.isVideoMirroringSupported {
    connection.automaticallyAdjustsVideoMirroring = false
    connection.isVideoMirrored = isFacingForward
}

Camera capture accessories on the outer display

iPhone Duo can show system-controlled content on the outer display next to a capture interface, like a script scrolling while someone records themselves reading it. Apple's article on registering a camera capture accessory covers the setup; SwiftUI needs one modifier:

struct CameraView: View {
    @State private var script = ScriptModel()

    var body: some View {
        CameraPreview()
            .sceneAccessory {
                CameraCaptureAccessory {
                    ScriptView(model: script)
                }
            }
    }
}

UIKit uses UISceneAccessory.cameraCapture(sceneConfiguration:userInfo:) and registerSceneAccessory(_:) instead. The system controls when the accessory is visible: closing the device, backgrounding the app, or stopping capture can all remove it without warning, so watch for that rather than assuming it's always there:

CameraCaptureAccessory {
    ScriptView(model: script)
}
.onAvailabilityChange { isAvailable in
    showsScriptControls = isAvailable
}

CameraCaptureAccessory also takes an isEnabled binding for a user-facing toggle. Apple's testing note is blunt: the simulator has no camera, so test this on a physical device before shipping.

Problems you'll hit, and the fixes Apple documents

Everything here comes from Xcode 27.1's release notes and the technology overview's documented gotchas.

The two Mac Catalyst issues come from Xcode 27.1's Mac Catalyst known issues.

How to prepare your iOS app for iPhone Duo

1. Install Xcode 27.1 beta and run your app in the Duo simulator

Get the beta running on a Mac with macOS Tahoe 26.6 or later, and launch your current build in the iPhone Duo simulator runtime before touching any code. The first launch will be slow, so don't schedule this for the middle of a release crunch.

2. Audit fixed-width layouts and screen-dimension assumptions

Search your codebase for hardcoded widths, device-model checks, and anywhere layout logic branches on a specific screen size instead of on size class. Apple's guidance is explicit that compact and regular width classes are what your layout should key off.

3. Handle reserved regions with the ReservedRegion API

Wire up reservedRegions for the outer camera, inner camera, and folding region using the SwiftUI and UIKit examples above. Skipping this step is the fastest way to end up with content hidden behind a camera cutout in review.

4. Decide where an arrangement view fits your existing layouts

Walk your primary/secondary screen pairs against the split and overlay examples above, and mark which ones map onto ArrangementView or UIArrangementViewController and which need a custom layout, keeping the navigation-split-view and list caveat in mind. Doing this once, deliberately, beats discovering it screen by screen during QA.

5. Re-test toolbars, tab bars, and camera-facing logic

Confirm your navigation bars move to the side on the outer display and on the inner display held sideways, and stay horizontal in inner-display portrait. If your app captures camera input, retest the outer, inner, and rear camera paths using the direction-coordinator code above, since the active camera can change mid-session as the device opens or closes.

An audit like this is also a reasonable moment to check whether the team doing it has the bandwidth. If a capacity gap is the blocker, HighCircl's guide to hiring senior iOS developers covers what to test for before October 23 closes the window.

For the wider set of platform releases landing around the same time, Platform and language release notes: what breaks and what to fix tracks what else is shipping this quarter.

FAQ

Does my app need the iOS 27.1 SDK to run on iPhone Duo?

Not to run at all, but to use the full screen. Apple's guidance states that apps built with Xcode 26 or earlier don't extend under the status bar and camera on iPhone Duo. To get the new layout behavior, reserved-region APIs, and arrangement views, you need to build with Xcode 27.1 and the iOS 27.1 SDK.

What happens if I don't update before October 23?

Apple doesn't say existing builds stop working: iOS 27.1 builds on iOS 27, so an app built with an earlier SDK should still run. It won't take advantage of the device's full screen space or foldable-specific layout behavior until you rebuild against the newer SDK.

Can I test iPhone Duo support without the physical device?

Yes. Xcode 27.1 beta's simulator supports the device's poses and orientations, and Apple's Device Hub previews your app across those poses directly in Xcode. StandBy, most app extensions, and camera capture accessories aren't testable in the simulator yet, so budget separate device time for those once hardware ships.

Is StandBy supported on iPhone Duo yet?

Not in the simulator. Xcode 27.1's release notes list StandBy as unavailable in the iPhone Duo simulator runtime as a known issue. Apple hasn't published anything suggesting that's a permanent limitation on the device itself, only that the beta simulator doesn't support it yet.

Do I need to change my camera code for iPhone Duo?

Only if it assumes a camera's position tells you which way it faces. iPhone Duo's two front cameras can end up facing either direction as the device opens or closes, so code built around AVCaptureDevice.position == .front will sometimes point the wrong way. Apple's fix is AVCaptureDeviceDirectionCoordinator, which reports forwardFacingDeviceDescriptors and backwardFacingDeviceDescriptors instead of relying on position. If your app only needs "the front camera" without switching sensors, the virtual front camera handles that for you.