iPhone Duo Developer Guide: How to Build and Upgrade iOS Apps
Apple announced its first foldable phone on September 9, 2026, at an event it called “Surprise and Shine.” The device is called the iPhone Duo. It opens like a small book, with a 5.4 inch screen on the outside and a 7.6 inch screen on the inside. Pre orders start October 16 and the phone ships October 23, at a starting price of $1,999.
For most people, this is simply a bigger phone that folds. For iOS developers, it is something more disruptive. It is the first time an iPhone does not have one fixed screen size. It has two, plus a range of in between states as the device opens and closes.
That single fact changes how you should think about building an iPhone app.
Apps that were written assuming a phone has one predictable width will look wrong on the iPhone Duo.
- Buttons may sit in the wrong place.
- Text may get cut off.
- Navigation bars may end up in odd spots.
None of this happens because the app is broken in the traditional sense. It happens because the app was never designed to ask a simple question:
how much space do I actually have right now?
This guide walks through what changed, what iOS developers and CTOs need to know, how to build a new iOS app the right way, how to upgrade an old one, and how to avoid the mistakes that are already showing up in early Duo testing. It is written for developers, technical leads, and software companies that need to plan real work, not just read about a new gadget.
One note before we start. Some technical details about iPhone Duo, such as exact RAM, the full behavior of every new API, and some Apple Pencil capabilities, are still being confirmed as documentation catches up with the announcement. Where that is the case, we say so directly instead of presenting a guess as a fact.
What the iPhone Duo Means for iOS Developers
The headline spec is the 7.6 inch inner display. But the more important change for developers is the shift in screen geometry itself.
A normal iPhone gives you one screen, one predictable set of dimensions, and an orientation that is either portrait or landscape. The iPhone Duo gives you three distinct situations to design for.
- The 5.4 inch outer display, used when the phone is closed
- The 7.6 inch inner display, used when the phone is open
- The partially folded state, where the device sits at an angle, similar to a small laptop
Apple’s own developer guidance is blunt about this.
- The outer display behaves like a compact width environment.
- The inner display behaves like a regular width environment, with enough room for two column layouts such as a list next to a detail view.
Apple has told developers, in plain terms, not to build a separate screen for every possible fold position. Build one interface that adjusts to the space it has.
That is a meaningful shift in mindset. Code that looks like this is exactly what Apple is asking developers to move away from.
if isFolded {
// Folded UI
} else if isOpen {
// Open UI
} else {
// Partially folded UI
}This kind of branching gets messy fast, and it breaks the moment Apple introduces a new pose or a new device size.
The better question to ask in your code is not “what is the current fold state” but “how much horizontal and vertical space do I have available right now.”
iPhone Duo Specifications Developers Should Actually Care About
Not every spec on the announcement slide matters for app development. Camera megapixels and battery life are important for marketing, but they rarely change how you write layout code. Here is the shortlist that actually affects development work.
The most important line in that table is the first two. Do not treat the inner display as simply a larger iPhone screen. It is closer, in spirit, to the kind of layout space you would design for on an iPad. If your team has ever built a two pane iPad interface, that experience is directly useful here.
The End of Fixed Width App Design
A lot of existing iOS code quietly assumes the screen will always be roughly the same size. You see this in patterns like:
.frame(width: 375)or
let width = UIScreen.main.bounds.widthThese assumptions were mostly safe for a decade of iPhones, because even with different screen sizes, the overall shape of the problem stayed the same. One screen, one orientation at a time, predictable proportions.
The iPhone Duo breaks that safety net. UIScreen.main in particular becomes unreliable, because on a multi display device it may not refer to the screen your view is actually on. The safer approach is to read the screen from the current window scene, and to let your layout respond to the space that is actually available rather than a number you hardcoded during development.
The mental shift is small to describe and genuinely useful in practice. Stop asking “what is the device width.” Start asking “how much space does my view have right now, and how should it look at that size.”
Size Classes Matter More Than Orientation
Plenty of iOS apps still make layout decisions based on portrait versus landscape. That worked reasonably well when orientation was a decent stand in for available space.
On the iPhone Duo, this stops being reliable. Apple’s guidance is direct: the inner display does not consistently honor orientation the way a normal iPhone does, and developers should use size classes instead of orientation as the main layout signal.
In SwiftUI, this means leaning on the environment value most developers already know but may not use consistently:
@Environment(\.horizontalSizeClass) var horizontalSizeClassFrom there, your view can decide how much it needs to show.
if horizontalSizeClass == .regular {
// Two pane layout, more detail visible
} else {
// Single pane, compact layout
}This single change, adopted properly across a codebase, removes most of the guesswork that used to come from checking device models or orientation values by hand.
The Hinge Creates a Layout Problem Older iPhones Never Had
Every iPhone before this one had a single flat surface, so developers never had to think about a physical seam running through the middle of their interface. The iPhone Duo introduces exactly that.
Apple’s documentation describes reserved regions for the hinge area and for the camera housing. Developers can query these regions directly rather than guessing where the physical constraints sit. In practical terms, this means checking where the fold falls before placing important content there, so a button, a text field, or a piece of key information does not end up sitting right on the seam.
This matters most for:
- Forms and text entry
- Buttons and primary actions
- Charts and graphs
- Drawing and annotation tools
- Video players and their controls
- Document editors
- Games
- Camera based apps
A button that technically renders on top of the hinge is not a crash. It is a bad experience, and on a $1,999 device, users will notice quickly.
SwiftUI Is the Natural Fit for iPhone Duo Development
If your team is starting something new, SwiftUI deserves serious weight in that decision. It already encourages iOS developers to describe what a layout should look like given the space it has, rather than manually placing every element by coordinate. That approach lines up closely with how Apple wants iPhone Duo apps to behave.
Useful tools here include NavigationSplitView and NavigationStack for adaptive navigation, ViewThatFits and AnyLayout for components that need to change shape rather than just resize, GeometryReader for reading available space directly, and the standard safe area APIs for handling insets that are no longer guaranteed to be symmetrical.
Picture a simple product catalog app. On the outer display, it shows a product list. On the inner display, the same screen can show the product list on one side and full product detail on the other, without becoming two separate apps or two separate code paths. The business logic underneath does not change. Only the presentation adapts.
What developers should learn, in order
Learn now: horizontal and vertical size classes, safe area handling, NavigationStack, NavigationSplitView, adaptive containers, GeometryReader, Dynamic Type, and scene based state management.
Learn next: reserved region APIs for the hinge and cameras, the new arrangement view components for split and overlay presentations, vertical toolbar behavior, scene accessories for secondary display content, and using Instruments to profile resize performance.
Learn when your project actually needs it: PencilKit, a custom SwiftUI Layout for bespoke adaptive components, multi window management, complex collection view layouts, and snapshot testing across multiple screen sizes.
UIKit Still Matters, and It Is Not Obsolete
Plenty of serious, revenue generating apps still run on UIKit, and that is not going to change overnight because a new device shipped. The important thing is not switching frameworks. It is modernizing how your app handles geometry, regardless of which framework it uses.
UIKit developers should focus on Auto Layout done properly, UIStackView for content that needs to redistribute itself as space changes, UITraitCollection for detecting size class changes instead of relying on device orientation, UISplitViewController for two pane layouts that collapse naturally on the outer display, and a proper UIWindowScene based lifecycle instead of an old AppDelegate only setup.
A UIKit app built on solid Auto Layout and a modern scene lifecycle will likely need targeted fixes rather than a rewrite. A UIKit app built on fixed frames, manual layout math, and an AppDelegate only lifecycle is going to need real engineering time, and that is worth planning for honestly rather than discovering during QA.
Apple Pencil Opens New Possibilities, But Not for Every App
USB C Apple Pencil support is coming to the iPhone Duo, on both displays, later in 2026. It is not available at launch alongside the phone itself.
This does not mean every app should rush to add drawing support. For a huge number of apps, it would add complexity without adding real value to the user.
Where it does make sense is fairly specific: note taking apps, education apps, PDF markup and annotation tools, contract signing and document workflows, design and whiteboarding tools, and field work apps where someone needs to sketch or mark something up on site.
The right question for a product team is not “can our app support Apple Pencil.” It is “would handwriting or precise drawn input actually improve how our users get their work done.” If the answer is genuinely yes, PencilKit is the framework to look at, and it is worth double checking that any custom gesture recognizers in your app will not fight with Pencil input once it lands.
Two Pane Layouts Are the Real Opportunity
The extra room on the inner display is not just about fitting more on screen. Used well, it lets an app expose useful information that was previously hidden behind a tap.
A simple closed state list, for example:
Orders: Order 1001, Order 1002, Order 1003
can become, once opened:
Orders and Order Details, side by side: the order list on the left, and customer information, products, payment, and delivery status on the right, updating as the user taps between orders.
This pattern shows up across almost every business category:
A CRM can go from a customer list to a customer list next to a full customer profile. A finance app can go from a portfolio summary to a portfolio next to transaction history. A healthcare app can go from a patient list to a patient list next to patient details. A logistics app can go from a map to a map next to delivery information. A project management tool can go from a list of projects to a project list next to tasks and details.
None of these require rebuilding the app from scratch. They require designing the detail view so it can live either as a full screen push, on the outer display, or as a side panel, on the inner display, using the same underlying data and business logic either way.
Building a New App for iPhone Duo, Step by Step
If your team is starting fresh, the biggest mistake is treating foldable support as something to bolt on near the end. It works far better as part of the architecture from day one.
Step 1. Decide if the extra space actually helps your users. Do not add a two pane layout just because the hardware supports one. Add it where it genuinely improves the workflow.
Step 2. Build your design system around flexible constraints, not fixed artboards. Figma files built for one fixed width will fight you the whole way through implementation.
Step 3. Choose SwiftUI as the default for new screens, reaching for UIKit or a hybrid approach only where you have a specific, well understood reason to.
Step 4. Build components that work in more than one context. A product card should look right in a compact list, a wider grid, and a two pane detail view, without three separate implementations.
Get Expert App Devs’s stories in your inbox
Join Medium for free to get updates from this writer.
Step 5. Keep your state separate from your view hierarchy. Opening or closing the device should never wipe out a user’s typed text, scroll position, or place in a multi step form.
Step 6. Plan for multitasking early, and actually test how your app behaves when Split View shrinks its available width mid session.
Step 7. Only add Apple Pencil support if it is a genuine product decision, backed by a real use case, not a feature added because the hardware allows it.
Step 8. Test early, on the simulator during development and on physical hardware well before release, not in the final week.
Upgrading an Existing iOS App
Most companies reading this are not starting from zero. They have an app already in production, real users, and real revenue riding on it. For that situation, an audit first approach works better than jumping straight to a rewrite.
Phase 1, technical audit. Search your codebase for fixed widths and heights, hardcoded positions, orientation based branching, any use of UIScreen.main, old AppDelegate only lifecycle code, and custom navigation controllers that were built by hand.
Phase 2, dependency audit. Check every third party SDK your app relies on. A clean, modern UI layer can still misbehave if one dependency underneath it has not been updated for adaptive layouts.
Phase 3, UI audit. Go screen by screen and ask honest questions. Does this screen resize cleanly. Does navigation still make sense. Are safe areas handled per edge rather than assumed to be equal. Would this screen actually benefit from a two pane layout on the inner display. Are buttons still reachable and away from the hinge.
Phase 4, adaptive layout migration. Replace fixed layouts with Auto Layout or SwiftUI’s adaptive containers, and move size class checks in ahead of orientation checks.
Phase 5, navigation and multitasking. Review any custom navigation you built in house, and actually test Split View rather than assuming it works.
Phase 6, state preservation. Confirm that opening or closing the device does not lose a user’s progress mid task.
Phase 7, accessibility. Test VoiceOver, Dynamic Type at large sizes, Reduce Motion, Increase Contrast, and Switch Control across the different poses, not just the default one.
Phase 8, performance. Profile scrolling and resize transitions specifically, since a smooth phone experience can still feel janky the moment the screen size changes mid animation.
Phase 9, physical device testing. The simulator is useful during development, but hinge feel and Apple Pencil behavior genuinely need real hardware before you sign off.
Phase 10, release. Update App Store screenshots for the new display sizes and do a final pass on the actual target device before shipping.
This is a realistic, sequenced plan, not a checklist to rush through in a week. Most teams will spend real calendar time in phases one, three, and four.
Should You Patch, Refactor, Migrate, or Rebuild?
Existing iOS apps can be evaluated, modernized, and tested step by step instead of automatically being rebuilt from scratch.This is the question every CTO ends up asking, and the honest answer is that it depends on the condition of the existing codebase, not on how new the iPhone Duo happens to be.
Patch the UI when the app is already reasonably modern and only a small number of screens have layout problems.
Refactor the architecture when the underlying business logic is solid but the app still relies on an AppDelegate only lifecycle or custom navigation that predates current best practice.
Move selected screens to SwiftUI when the app has clean module boundaries and the team already has SwiftUI experience, without needing to touch the rest of the app.
Go hybrid, combining UIKit and SwiftUI, when the app is large enough that some screens genuinely benefit from SwiftUI’s adaptive behavior while others, especially custom drawing or complex collection views, are better left in UIKit for now.
Rebuild only when the app has deeply coupled legacy code, heavy reliance on fixed layouts throughout, deprecated APIs everywhere, unsupported third party UI frameworks, and fragile state management that nobody fully trusts anymore.
The important discipline here is not letting a new device push a team toward a rebuild it does not actually need. Rebuild because the existing architecture is genuinely holding you back, not because iPhone Duo is new and exciting.
The iPhone Duo Testing Checklist
Testing an iPhone Duo app takes more ground than testing a normal iPhone release. It is worth treating this as its own checklist rather than folding it into your usual QA pass.
Device states: closed, fully open, partially folded, flat or propped, outer display in portrait, outer display in landscape.
Interface elements: navigation bars, tab bars, toolbars, sheets, alerts, forms, lists, grids, charts, web views, and the status and Dynamic Island area.
Input methods: touch across all edges including near the hinge, Apple Pencil once it is available, a hardware keyboard, standard gestures, and Touch ID.
Accessibility: VoiceOver across every pose, Dynamic Type at its largest sizes, Reduce Motion, Increase Contrast, and Switch Control.
Localization: longer text in languages like German and Finnish, right to left layouts for Arabic and Hebrew, and correct currency and date formats.
Performance: scrolling behavior during a resize, the smoothness of open and close transitions, video playback on both displays, camera behavior across poses, Split View alongside another app, and memory use with two displays active.
Lifecycle: state preservation when folding and unfolding, correct behavior moving from background to foreground during a pose change, app switching while in Split View, and state restoration after the app is terminated and relaunched.
Skipping any one of these categories tends to show up later as a support ticket rather than a bug report, which is a more expensive way to find the same problem.
Ten Mistakes Developers Are Already Making
Designing for one screen size. Test and design for the range, not a single fixed target.
Hardcoding dimensions. Fixed widths and heights are the single most common source of broken layouts on this device.
Assuming safe areas are symmetrical. They are not guaranteed to be equal on the iPhone Duo, and code that assumes otherwise will misalign content on one side.
Ignoring the hinge. Content and controls placed without checking the reserved region will sit awkwardly on the fold.
Treating the inner display as just a bigger iPhone. It behaves more like a small tablet, and layouts should reflect that.
Writing separate code for every fold position. This creates a maintenance burden that grows every time Apple adds a new pose or a new device.
Relying on orientation as the main layout signal. Use size classes instead, since orientation is no longer a reliable proxy for available space.
Losing state during a fold. Keep application state separate from temporary view state so a fold does not erase a user’s work.
Testing only in the simulator. Some behavior, especially around the hinge and Apple Pencil, only shows up on physical hardware.
Ignoring third party libraries. A single outdated dependency can undo an otherwise well built adaptive layout.
What Software Companies Should Prioritize
For an agency or software company, the iPhone Duo is not just another device to add to a compatibility list. It is a real opportunity to offer a structured service, provided the team actually builds the underlying skill first.
A sensible priority order looks like this. Update development environments and get comfortable with the current SDK first, since this is genuinely urgent and low effort. Audit fixed layouts across client codebases, since this tells you the real scope of work before you quote anything. Prepare a proper Duo testing process and get comfortable with Xcode’s simulated fold states. From there, train developers in SwiftUI, review older UIKit applications for modernization needs, standardize navigation patterns across projects, and build accessibility testing into the normal QA cycle rather than treating it as optional.
Lower down the list, but still worth planning for, is identifying genuinely valuable Apple Pencil use cases, profiling performance during resize transitions, checking third party SDK compatibility across your active client projects, and preparing updated App Store assets.
From a service offering point of view, this creates a fairly clear list of things a company like Expert App Devs can sell: iPhone Duo app audits, foldable readiness reviews, UIKit to SwiftUI migration, legacy app modernization, Apple Pencil integration for the clients where it genuinely fits, dedicated iOS QA testing, performance optimization work, and short term architecture consulting for CTOs trying to decide between patching and rebuilding.
The audit and the adaptive UI development work are the most immediately sellable, because almost every existing iOS client needs some version of that assessment regardless of what they eventually decide to do about it.
A Simple iPhone Duo Readiness Score
For technical discovery calls, a simple scoring framework helps turn a vague conversation into something concrete. Score each area out of its weight, then add up the total out of 100.
A score between 80 and 100 means the app is mostly ready, with only minor polish left. A score between 60 and 79 means some targeted improvements are needed, but the core is sound. A score between 40 and 59 points to real modernization work, likely spanning a few months. A score below 40 usually means the architecture itself needs to change before the app can handle this device well.
Questions Every CTO Should Ask Before Approving a Duo Project
Before signing off on budget or timeline for iPhone Duo work, it is worth getting straight answers to a short list of questions.
- Does the app use fixed screen dimensions anywhere in its layout code.
- Does it still reference
UIScreen.main. Can the UI resize without breaking. - Does navigation adapt cleanly between compact and regular width.
- Would the main workflow genuinely benefit from a two pane layout.
- Does the app preserve user state when the available space changes.
- Are the third party SDKs in use actually compatible with the current SDK.
- Is the app using a modern scene based lifecycle.
- Does it handle asymmetric safe areas correctly.
- Has anyone checked how content sits around the hinge.
- Does the app run properly inside Split View.
- Is Apple Pencil support worth adding for this particular product.
- Should the plan be to patch, refactor, migrate, or rebuild.
- Can the QA team actually test every device state that matters.
- And does the development team understand adaptive layout well enough to execute without constant rework.
Getting real answers to these before work starts saves a lot of time during the project itself.
The Real Lesson Here
The iPhone Duo does not mean every iOS app needs to be rebuilt. It means developers need to stop treating the screen as a fixed, known quantity.
A user might start on the outer display, open the device to a two pane layout, run the app next to another one in Split View, use an Apple Pencil, resize the window without noticing, and then close the phone again. Through all of that, the app should keep working and never lose what the user was doing.
That is the actual engineering challenge, and it is a good one to get right, because it is not just about this one device. The broader direction of the industry is toward flexible screens and changing app environments, and the skills that make an app work well on the iPhone Duo are the same skills that will matter on whatever comes after it.
For new apps, build adaptively from the very first screen. For existing apps, audit honestly before deciding anything. For legacy apps, modernize in stages rather than all at once. And for software companies, this is a good moment to turn foldable readiness into an actual service line rather than something you figure out reactively when a client calls asking why their app looks broken on a $1,999 phone.
Frequently Asked Questions
#1. Does every iOS app need to be rebuilt for iPhone Duo?
ANS: No. An app already built with adaptive layouts, proper safe area handling, and a modern lifecycle may only need small, targeted fixes. Older apps built around fixed dimensions and custom navigation will likely need more substantial work.
#2. What is the single most important skill for iPhone Duo development?
ANS: Adaptive layout. That covers size classes, safe area handling, and building interfaces that respond to available space rather than a fixed device size.
#3. Should our team learn SwiftUI specifically for this?
ANS: It helps. SwiftUI is well suited to adaptive interfaces, but UIKit remains a valid choice, especially for large existing apps where a full rewrite is not justified.
#4. Do we need separate code for every fold position?
ANS: No, and Apple’s own guidance actively discourages this. Design around size classes instead, and let one adaptive interface handle the different poses.
#5. Does our app need Apple Pencil support?
ANS: Only if handwriting, drawing, or precise annotation is genuinely part of how your users work. For most apps, it is not worth the added complexity.
#6. Should we convert our whole UIKit app to SwiftUI?
ANS: Not automatically. A hybrid approach, keeping stable UIKit screens as they are and moving select screens to SwiftUI, is often more practical than a full conversion.
#7. How should we actually test for this device?
ANS: Cover every device state, test Split View directly, run a full accessibility pass, check state restoration after folding and unfolding, and confirm performance during resize transitions. Use physical hardware for anything involving the hinge or Apple Pencil, since the simulator cannot fully reproduce either.
A note on accuracy: this guide separates what Apple has confirmed from what is still being verified through developer documentation and early reporting. Details such as exact RAM, some newer API behavior, and full Apple Pencil capabilities were still being finalized at the time of writing. Treat anything in that category as subject to change once Apple publishes complete documentation, rather than as a locked specification.
