Prepare your app for iPhone Duo: what to fix first

There is plenty of material now on what the iPhone Duo APIs are. There is much less on the question a team actually has to answer this month: given a shipping date, what do we fix first, and what can wait?

This is that guide. The technical claims are Apple-sourced and linked. The effort estimates are ours, from doing this kind of migration — treat them as a starting point for your own planning, not a quote.

The date that changes the calculation

iPhone Duo goes on sale 23 October 2026, with pre-orders from 16 October, in more than 70 countries and regions, and in 28 more from 30 October.

The detail worth pausing on: it ships running iOS 27.1, not iOS 27. That is the SDK tier at which apps reach the edge of the screen and standard bar buttons lay out vertically. So every device in a customer’s hands on day one is running the OS that expects the most modern layout — and any app that has not been rebuilt will sit visibly inside that environment rather than filling it.

That is the deadline. Not “sometime in the 27 cycle.”

First decide which tier you are shipping

Apple defined exactly three levels of behaviour, and your SDK choice picks one:

The trap is treating this as a version bump. Moving to 27.1 claims the whole screen, which makes you responsible for the geometry at its edges — the hinge, the asymmetric safe areas, the vertical bars. An app that takes the SDK and skips the layout work can look worse than one that stayed on tier one.

So the honest sequence is: decide you are doing the work, then bump the SDK. Not the reverse.

Triage in three passes

Pass one — the four assumptions (half a day to two days)

These are not new APIs. They are old code that was correct until 9 September and is not any more. They account for most of what a user actually notices.

1. Fixed widths. The inner display is 626 × 890 points. Any constant tuned for a ~400-point phone is now wrong by more than half. → hard-coded dimensions
2. Orientation locks. The inner display does not honour supported interface orientations. If you locked to portrait, you are still going to be laid out in landscape. → orientation
3. Symmetric safe areas. Left and right insets differ now. width - insets.left * 2 produces visibly off-centre layout. → safe areas
4. Idiom checks. iPhone Duo reports the phone idiom with a regular-width display, so every idiom == .pad gate hides your good layout on the device that most needs it. → idiom assumptions

If you also ship on Android, the first two are shared work: Android 16 stopped honouring orientation locks and aspect-ratio limits on large displays in the same year Apple did. Designing apps for the foldable era covers both platforms and all nine shipping devices.

Three greps find most of it:

grep -rn "UIScreen.main" --include="*.swift" .
grep -rn "userInterfaceIdiom" --include="*.swift" .
grep -rn "\.frame(width:" --include="*.swift" .

Run Xcode 27.1’s App Resizability modernization skill first — it now covers SwiftUI as well as UIKit, and it does the mechanical share of this. Review every change rather than accepting the diff wholesale; replacing a fixed width with maxWidth: .infinity is right in a stack and wrong in a form field that now spans 626 points.

Pass two — let the system do the adapting (one to three days)

Standard containers are fully adaptive across every pose: NavigationSplitView, UISplitViewController, TabView, UITabBarController. Sheets, popovers, alerts and context menus adapt on their own.

If you are on those already, this pass is mostly configuration. One line is close to free value:

TabView { … }.defaultTabBarPlacement(.sidebar)

A five-item tab bar stretched across 626 points looks lost; a sidebar looks designed.

If you replaced the system bars with your own, this is where the cost lands. Custom UIToolbar content is not considered for vertical bar placement — you are outside the adaptive path until you move back onto the system containers.

Also in this pass: audit toolbar content for the vertical bar. A column holds far fewer items than a row, so set visibilityPriority on the actions you would defend in a usability test, and prefer symbol-only items.

Pass three — the new APIs (two days to two weeks)

Only now do the genuinely new things earn their place:

• ArrangementView — if you have a primary/secondary screen, this replaces a lot of manual pose handling and is the highest-leverage addition. → arrangements
• ReservedRegion — where the hinge divides the display, and where the under-display camera occludes it. Query it directly only when an arrangement is not enough: a canvas, a game board, a photo editor. → division regions
• Scene accessories — content on the outer display while the app runs on the inner. Strong for camera apps, pointless if it would only mirror.
• Multiple scenes — worth it when two instances side by side genuinely help. Skip it for a single linear flow.

What it costs, by app type

Our estimates, for the work through pass two — the point at which an app looks correct rather than merely functional.

The single biggest predictor is not framework. It is whether you already had an iPad target. Teams that did are usually surprised how little is left.

What you can safely defer

Not everything has to land by 23 October. Reasonable things to push:

• Reserved regions, unless you draw a full-bleed surface where the fold genuinely matters. Arrangements cover the common case.
• Scene accessories. A real feature, not a compatibility fix.
• Multiple scenes, unless two instances side by side is obviously useful for your app.
• Concentric corners. Polish. Real polish, but polish.

What should not be deferred is anything in pass one. Those are the ones users photograph and post.

If you genuinely do nothing

Your app still runs. Apple made sure of it — without the iOS 27 SDK it shows at a familiar size and aspect ratio, functional and unremarkable.

That is a defensible choice for a utility with a captive audience. It is a poor one for anything discretionary, competitive, or screenshot-driven, because the comparison will be made on a 7.6-inch display against apps that filled it.

A one-week plan

If you have a week before launch and an app in the middle of that table:

1. Day 1 — Install Xcode 27.1. Run the app in the Duo simulator via Device Hub. Walk every pose and write down what you see. Do not fix anything yet.
2. Day 1 — Run the checklist against what you saw and copy the audit report.
3. Day 2 — Bump to the iOS 27.1 SDK. Run App Resizability. Review its diff.
4. Days 2–3 — Pass one, in severity order.
5. Day 4 — Pass two: sidebar placement, toolbar audit, split view.
6. Day 5 — Re-walk every pose, including Split View at several widths and the transitions between poses. Most remaining bugs surface while folding, not after.

Pass three is next sprint’s problem, and that is fine.

Tooling for AI-assisted migration

If you are doing this work with an AI coding agent, iphone-duo-skills packages Apple’s guidance into nine installable agent skills — adaptive layout, vertical bars, hinge and scenes, camera, readiness review, plus React Native, Flutter and games — via npx skills add mirzaaghazadeh/iphone-duo-skills, and works with Claude Code, Cursor, Copilot and others.

That pairs well with the machine-readable copies of this site: every page here is available as clean Markdown by appending .md to its path, with the whole corpus at /llms-full.txt.

Where to check yourself

Everything above traces to Apple’s six iPhone Duo Tech Talks, and to the written Preparing your app for iPhone Duo guide Apple published on 18 September 2026. We keep a written index of all six — what each covers and which APIs it introduces — because video is hard to reference while you are coding. The written guide, the Human Interface Guidelines page and Xcode 27.1 beta are all now out — check them directly for anything you are about to depend on, and see what the beta can test.