iPhone Duo app development: the iOS 27.1 fold APIs in practice

To make an existing app look right on iPhone Duo, rebuild it with Xcode 27.1 against the iOS 27.1 SDK and make every screen size itself from its own bounds. Then let the system move your bars to the side, and keep controls off the fold with the new reserved-region APIs. For an app that already resizes well on iPad, that is most of iPhone Duo app development. Apps that skip the rebuild still run, but leave part of the display empty.

Apple’s first foldable went on sale on 23 October 2026.¹ Below are the iOS 27.1 iPhone Duo APIs as Apple documents them, a layout pattern for each posture, Safari 27.1’s fold APIs, and how to test fold layouts while Apple’s command-line tools have no posture controls.

Our worked examples are Bitfold, a retro game console app, and Football Kick, a one-finger football game. 9io, a product engineering studio, made both for iPhone Duo. They’re on their way to the App Store, and both play free in a browser (Bitfold, Football Kick).

What happens to apps that aren’t rebuilt with the iOS 27.1 SDK

Every iPhone app runs on iPhone Duo. How much of the display it uses depends on the SDK it was built with.²³

9to5Mac’s write-up on announcement day showed older builds sitting inside a black background, and iOS 27.0 builds still leaving blank space.⁴ Apple’s developer news post of 5 October asks teams to recompile with Xcode 27.1.⁵ Test the rebuild before you ship it, because your bars may turn vertical.² Submitting iPhone Duo screenshots earns your product page a badge saying the app is optimised for iPhone Duo, and from April 2027 every app or game submitted must include them.⁵

How to support iPhone Duo: start with resizing

Most of the work is resizing. A fold can resize your app in the middle of a session, and Apple says apps that already resize well on iPad, on Mac or in iPhone Mirroring are well on their way.⁶² These are the patterns it asks you to remove:

• Size from the view or window, never from UIScreen.main.bounds, and re-read the size whenever it changes. In SwiftUI, use GeometryReader or onGeometryChange.
• Don’t make layout decisions from device orientation or userInterfaceIdiom, don’t treat regular width as iPad, and delete checks against known iPhone heights.
• Check full-bleed images and video set to fill, which can lose important content on the wider displays.

Apple’s engineers add that referring to the main screen is ambiguous with two displays and will be deprecated in a future release.³ Design for two size classes, compact width on the outer display and regular width on the inner one.⁷³ The two displays share one aspect ratio, so content scales proportionally between them.¹ Macworld gives it as 1:1.4 and Wikipedia as 1.41:1, and Macworld notes that this makes the outer display exactly half of the inner one.⁸⁹

Bars move to the side when they come from system containers such as NavigationStack, NavigationSplitView and TabView, or UIKit’s navigation and tab bar controllers. Custom bars built from UIToolbar, UINavigationBar or UITabBar stay put.⁶ Give every toolbar item a title and a symbol, because vertical bars show symbols and title-only items stay horizontal. toolbarVerticalBehavior(_:) in SwiftUI and preferredVerticalBarBehavior in UIKit keep a sheet’s bar horizontal on the outer display.⁶ With bars along one edge, handle each safe-area inset on its own.³

Any app can share the inner display with another, each taking half. iPhone Duo is also the first iPhone to run several windows of one app, but only the inner display can open new ones, so handle the error when it can’t. UIWindowSceneActivationAction hides itself in that case.¹⁰¹¹

For a first pass, ask Xcode 27.1’s coding assistant to get your app ready for iPhone Duo. Its App Resizability skill scans for the patterns above, and xcrun agent skills export shares it with other coding agents. Apple says it finds most issues but not every one.²³

Reserved regions keep content off the crease and cameras

iOS 27.1 calls the parts of a view that your content shouldn’t use reserved regions.¹² A division splits a view, like the fold when the phone is partially open. An occlusion covers part of it, like the Dynamic Island or a camera. The outer front camera always occludes, and the inner one only does while it’s in use.⁶

In SwiftUI, call reservedRegions(kind:options:layoutDirectionBehavior:) on the GeometryProxy from a GeometryReader. In UIKit, call reservedRegions(kind:options:) on a UIView. Each region’s frame is in the view’s own coordinates, in points, with Apple’s margins already included.¹² Details worth building around:

• You get active regions by default. The fold is active only while the phone is partially open, and when the phone is flat it’s inactive with a width of zero.¹³ Pass .includeInactive to leave room ahead of time, so the layout doesn’t jump when someone folds the phone.
• Frames are mirrored for right-to-left languages unless you pass LayoutDirectionBehavior.fixed.
• Use an even number of grid columns so content divides cleanly at the fold.⁷
• Lists, scroll views and collection views don’t split their content around the fold, so a row can run across it.¹²

Split views, tab bars, sheets, alerts, context menus and toolbar buttons already move clear of the fold.¹²¹¹ Most apps only need to read regions in custom views that place their own controls, such as a floating button or a game’s HUD.

For two related views, use ArrangementView in SwiftUI or UIArrangementViewController in UIKit.¹⁴ A split arrangement keeps them side by side or stacked, on separate sides of the fold, like the Podcasts Now Playing view beside its transcript. An overlay arrangement layers one over the other on a flat display and moves them apart when the phone folds, which suits playback controls over a video.¹³¹⁴ Keep navigation containers outside an arrangement view, and don’t nest one in a list or scroll view.

Hinge state and the hinge angle API

In SwiftUI, the onHingeChange modifier passes you the previous and new DeviceHingeContext. Its hinge is a DeviceHinge with a status of closed, partiallyOpen or fullyOpen and an angle as a SwiftUI Angle, or nil on a device without a hinge.¹⁵¹⁰ In UIKit, add a UIHingeInteraction to a view. Each update carries a UIHinge, whose angle is in radians and whose status adds an unknown case.¹⁵

Apple’s engineers describe hinge data as live and suited to interactions and effects, and send layout to the region and arrangement APIs. Their demo bends the pitch of a guitar app with the hinge, like a whammy bar.¹⁰ Apple’s reference adds that the rate and precision of angle updates are system policy and can change, so read status when that’s all you need.¹⁵

Football Kick reads the fold’s position from iOS and listens for hinge changes, so nothing about the fold is hard-coded. As you fold the phone up, the goal swings into place and the floodlights come on, and when you score the hinge lights up like goal-line technology.¹⁶

Telling closed, book, laptop and flat apart

There is no book or laptop status, so a phone held like a book and one folded like a laptop both report partially open. To tell them apart, look at the fold’s division region. Held like a book, the fold runs from top to bottom with content either side. In a laptop posture it runs across the middle, and content stacks above and below.¹² Safari 27.1 draws the same line for web pages.¹⁷

Keep that decision in a small pure function, so a unit test can call it with any fold rectangle. This sketch uses only documented SwiftUI calls, and FoldLayout and GameLayout are our own names:

enum FoldLayout { case flat, book, laptop }

func foldLayout(fold: CGRect?) -> FoldLayout {
    guard let fold else { return .flat }      // no active fold in this view
    return fold.height > fold.width ? .book : .laptop
}

// In the view that places your controls:
GeometryReader { proxy in
    let fold = proxy.reservedRegions(kind: .division).first?.frame
    GameLayout(mode: foldLayout(fold: fold), fold: fold)
}

Apple’s own example on the ReservedRegion page makes the same check.¹²

Foldable iPhone app design, posture by posture

Apple’s design guidance is to build layouts that resize and to adjust them a little when the phone folds, moving only what has to move so people can still find their controls.⁷ Its designers suggest one optional layout for a single pose. On a table, media can sit on the upright half and controls on the flat half, as long as every pose keeps the same controls.¹¹ Games should stay playable in every pose, and Apple prefers a change of aspect ratio to black bars.⁷

Bitfold keeps the game running through every change of shape, with a soft click as the hinge snaps into the new layout. Folded like a laptop, it’s a clamshell with the game on the top half and the controls and a companion screen below, and Bitfold draws the console’s own hinge over the fold region iOS reports, so it lands exactly on the real one. Folded like a book, the console opens into two pages, because a button that straddles the crease is hard to press.²⁰

Football Kick started from the laptop posture. Stood on a table, the bottom half is the pitch and the top half the goal, both drawn from one virtual camera so the ball crosses the hinge without a jump. In version 1.0, which we’re finishing now, two players can share a shootout, with the shooter swiping on the flat half and the keeper diving on the standing one.¹⁶

Launch-week roundups describe other apps splitting the laptop posture the same way. Telkino puts a Mac’s screen on the upright half with a trackpad and keys below.¹⁸ Tiny Computers turns the bottom half into a working keyboard.²¹ There are more in our list of the best iPhone Duo apps. Apple also suggests supporting your app sideways on the outer display, because people may set the phone down like a tent.³

iPhone Duo in Safari: the Device Posture and Viewport Segments APIs

Safari on iPhone Duo runs the same WebKit engine as every other iPhone, so responsive sites already work.¹⁷ Across poses, the Safari 27.1 viewport runs from 382 to 951 CSS pixels wide and from 368 to 902 tall. The outer display is 382 wide upright and 594 sideways, the inner display is 669 upright and 951 sideways, and each of two windows side by side gets 385. WebKit asks for fluid layouts and feature detection in place of user-agent sniffing.

Safari 27.1 also previews two foldable APIs behind feature flags, which you turn on in Settings > Apps > Safari > Advanced > Feature Flags.¹⁷

• Device Posture API. The device-posture media query and navigator.devicePosture.type report folded when the phone is partly folded like a book or a laptop, and continuous when the screen is flat, whether open or closed. A change event fires when the posture changes.
• Viewport Segments API. The horizontal-viewport-segments and vertical-viewport-segments media queries match two segments side by side (a book) or stacked (a laptop). Six environment variables, viewport-segment-width, viewport-segment-height, viewport-segment-top, viewport-segment-right, viewport-segment-bottom and viewport-segment-left, each take a column and a row index. In JavaScript, window.viewport.segments returns one DOMRect per segment.

A posture-aware rule can sit on top of a layout that already works without it:

/* Laptop posture: the player's controls fill the lower segment. */
@media (vertical-viewport-segments: 2) {
  .player-controls {
    position: fixed;
    inset: env(viewport-segment-top 0 1) 0 0 0;
  }
}

Visitors won’t have the flags on, and WebKit says both APIs may still change, so treat such rules as progressive enhancement. On the outer display, Safari 27.1 doesn’t draw page content behind the side controls. It fills that strip with the page’s background colour, so check how that colour looks beside your header.¹⁷

Testing fold layouts when the Simulator can’t be scripted

Xcode 27.1’s Device Hub has an iPhone Duo simulator with Closed, Partially Open and Open buttons below the bezel, and holding Option while dragging the slider folds it to any angle.²² Apple suggests opening every view, sheet and popover in each pose, rotating the phone in each one, and dragging your app to both sides of Split View.⁶³

As of 26 October 2026, we found no Apple documentation for setting posture or hinge angle from the command line or a UI test. Apple’s command-line guide lists no posture commands for simctl or devicectl, and XCUIDevice has orientation but no hinge or posture control.²³ Contributors to the Maestro UI testing project have documented the gap in issue 3617, opened on 21 September and still open on 26 October. They report that simctl in the Xcode 27.1 beta has no command for fold posture or hinge angle, and that orientation changes through devicectl and XCUIDevice report success and do nothing on iPhone Duo.²⁴ An Apple forums thread asking for a supported way to unfold the Simulator has no reply from Apple.²⁵ The community tool duoctl folds it with the same events Device Hub sends, through private interfaces checked only against Xcode 27.1, so it may break with the next release.²⁶

The Simulator also boots closed, so a test run that never touches the controls sees only the outer display.²⁵ Both of our games test their fold layouts in code. Bitfold’s geometry tests check its unfolded layouts, and its CI captures screenshots on iPhone, iPhone Duo and iPad.²⁰ Football Kick has a layout test that places its HUD on every iPhone and iPad size and in every iPhone Duo posture, and fails if an element is off screen, overlaps another or sits on the fold.¹⁶ Both keep their logic in Swift packages with no UI framework, where tests reach it without a device.

To do the same in your app, make each layout decision a function of the container’s size and the fold rectangle, like foldLayout(fold:) above. Log the division frames in Device Hub once per posture and keep them as test fixtures. Then assert at every size and posture that nothing is off screen, nothing overlaps and no tappable element touches the fold. Keep Device Hub for the visual pass, including one run in a right-to-left language.

A checklist for iPhone Duo app development

1. Build with Xcode 27.1 and the iOS 27.1 SDK, and run the App Resizability skill.
2. Remove UIScreen.main sizing, orientation and idiom checks, and hard-coded device sizes.
3. Use system navigation containers and bars, give every toolbar item a title and a symbol, and handle each safe-area inset on its own.
4. Keep tappable controls out of divisions and occlusions, and use arrangement views for two panes.
5. Use an even number of grid columns, and leave room for inactive regions.
6. Use the hinge angle for effects, and handle a nil hinge.
7. Handle the error when a new window can’t open on the outer display.
8. Test fold layout functions at every size and posture, then check each screen in Device Hub.
9. On the web, feature-detect posture and segments, and check the strip beside the outer display’s controls.
10. Add iPhone Duo screenshots to App Store submissions before April 2027.

Frequently asked questions