TLDR
iPhone Duo is Apple's first foldable iPhone widely referred to as the iPhone Fold before Apple confirmed the name. The device reaches stores on October 23, 2026 in more than 70 countries, including France. For your app, that means one user journey may now span more than one screen size, display state, or window configuration.
Shipping your app is a good starting point, but it is not proof that the experience works well on a foldable device. The most important risks are usually not dramatic crashes. They are smaller failures that interrupt real tasks: a layout that no longer fits, a button users cannot reach, a draft that disappears, a dialog that targets the wrong record, or a keyboard that hides the final action.
Start your iPhone Duo compatibility review with these five areas.
Scope and method. Research checked September 10, 2026. The five risks below are proposed QA scenarios derived from Apple's own developer documentation and from established browser behavior. None of them has been reproduced on an iPhone Duo device or simulator, because the device is not yet on sale. Treat each one as a hypothesis to test rather than a defect to fix. As of the September 10 check, Apple's developer hub listed Xcode 27.1 beta as arriving later in September. You can write the test cases now and run the Duo-specific checks once Apple's supported environment is available.
1. Layout breaks when the window size changes (size classes and scene geometry)
A detail panel may look perfect when iPhone Duo is fully open, then become cramped or unusable when the app shares the display. On a foldable device, rotation is only one of several ways the available space can change.
For native iOS apps, Apple's Tech Talk 111461 recommends using size classes and current scene geometry instead of making layout decisions based only on orientation or a single "main screen." Custom navigation, sidebars, detail panels, and full-screen views are good places to start reviewing.
For mobile websites, the equivalent problem is relying on a device name or a cached viewport width instead of responding to the space currently available to the page. Native iOS size classes do not apply to CSS layouts.
Try this: Select a record, open its detail view, and then reduce the available space without leaving that view. In a native app, test supported display configurations and Split View when the tooling is available. For websites, begin by resizing around your existing breakpoints, then repeat the check in Safari on iPhone Duo when possible.
Pass condition: The same record remains selected, essential content stays readable, and users can still reach navigation controls.
A polished wide-screen layout is not useful if the Back button disappears when space gets tighter.
2. Safe-area insets are not symmetrical on a foldable iPhone
A close button can appear on screen and still be impossible to tap. That is not a cosmetic issue. It is a functional defect.
For native apps, Apple's safe-area guidance specifically warns against assuming that opposite screen edges have equal insets. Review custom headers, bottom action bars, floating controls, and dismiss buttons across the configurations your app supports.
If your app adapts to different device positions, review Apple's reserved-region guidance as well. Avoid treating the fold or hinge as a fixed-width area that you can guess and subtract from the layout.
For mobile web, check every edge independently wherever your page uses CSS safe-area values. MDN documents the env() function, but the existence of these variables does not confirm that Safari on iPhone Duo exposes a specific fold, hinge, or posture API.
Try this: Open a full-screen view or dialog that includes controls near the top, bottom, or sides. Change the configuration, test both rotation directions where relevant, and activate the controls. Do not rely on screenshots alone.
Pass condition: Every critical action remains visible, recognizable, and reachable, including when users have enlarged text enabled.
3. Unsaved state is lost when the device folds or unfolds
A screen can redraw perfectly when iPhone Duo changes configuration while the customer's work quietly disappears. That makes state continuity during the transition more important than a large collection of static screenshots.
iPhone Duo has two displays, and folding or unfolding the device changes the space available to your app. That can move the interface across size-class and layout boundaries during the same user journey. The outer display stays in the compact-width world of a conventional iPhone, while the inner display provides regular width and height. Apple recommends designing around available space rather than making layout decisions from a specific device shape or orientation.
Apple's standard containers handle many of these changes for you. NavigationSplitView and other system navigation containers adapt across Duo's different configurations, including collapsing columns when space becomes more constrained.
The risk is in custom UI. If your implementation replaces one view hierarchy with another when the available space crosses a layout boundary, it may accidentally reset local state such as unsaved field values, scroll position, selection, or validation feedback. This is a failure scenario to test, not a claim that iOS automatically discards state when the device folds.
For mobile web, the equivalent risk is a breakpoint being crossed during the same Safari session. If that breakpoint causes a component to unmount and remount, uncontrolled inputs, validation messages, or open controls can reset. Responsive resizing is useful preparation, but Duo-specific validation still needs the actual display and window configurations Apple provides in its testing environment.
Try this: Start a task that is expensive to redo, such as a multi-step checkout, a long form, or a filtered list with an active selection. Enter values, trigger a validation error, then fold or unfold the device before submitting. Repeat the transition in both directions. Then repeat after backgrounding and restoring the app so you can distinguish transition-related state loss from ordinary lifecycle restoration issues. Use test data and a non-production transaction path.
Pass condition: The user continues from where they stopped. Entered values are still in place, validation feedback still points to the correct field, the selected record is still selected, and the task can be completed without starting over.
A layout that redraws perfectly is still a failure if the customer has to retype the address.
4. Dialogs sized to the display overflow in Split View
Split View changes the space available to your app. A dialog that is sized using the full iPhone Duo display can overflow or become unusable inside the smaller window where it actually appears.
For native apps, Apple's multiple displays and scenes guidance covers dynamic window sizes and multiple instances of an app's interface. If your app supports multiple scenes, test carefully which record, document, or account each action affects.
For mobile web, test dialogs, modals, and embedded flows in narrower Safari windows. If two browser windows are available, distinguish between state that should remain separate per window, such as current navigation, and state that may intentionally be shared, such as an account session or shopping cart.
Browser windows are not SwiftUI scenes, so avoid treating them as technically identical in your test documentation.
Try this: Open an edit dialog in a narrow configuration. If your app supports a second window, open a different record there, then return to the original edit dialog.
Pass condition: The full dialog remains usable, including its error messages and dismiss action. Saving updates the intended record, not the one that happens to be active elsewhere.
Shared state should follow your product requirements, rather than simply whatever behavior is easiest to automate.
5. The software keyboard hides the submit button (visual viewport vs layout viewport)
A form may look fine until the user tries to submit it with the keyboard open. That is the moment that matters.
For native iOS apps, test keyboard avoidance while the available space changes. Pay particular attention to long forms, fixed bottom actions, validation states, and the fold-adaptive layouts your app genuinely supports.
For mobile web, the visual viewport and the layout viewport may not change in the same way. As MDN explains in its VisualViewport reference, opening the software keyboard or zooming can reduce the visible area without changing the layout viewport equivalently. Fixed-position buttons and sticky action bars deserve extra scrutiny.
Try this: Focus the last field in a form, trigger an error, and keep the keyboard open. Change the available space, then try to read the error, correct the input, and reach Submit. Repeat with enlarged text or browser zoom where appropriate, and check what happens when the keyboard is dismissed.
Pass condition: The user can see the active field and validation message, correct the problem, and complete the task without being trapped in the form.
Prioritize the checks that affect real users
You do not need to treat every visual difference on a foldable device as a release blocker. Start with the failures that can cost users time, money, or trust:
- Lost form data or interrupted journeys
- Updates applied to the wrong record
- Duplicate submissions or transactions
- Critical actions that become inaccessible
- Dialogs, errors, or controls that users cannot reach
For every issue, capture the starting configuration, the transition that triggered the problem, the app build, and the exact environment used. A screenshot of the final state is useful, but a recording that shows the journey breaking is usually more actionable.
Where Thunders fits in
You do not have to wait for the October 23 release to start. Thunders is an AI test automation platform that tests web, mobile, API, and desktop applications from one place, including iOS and Android apps on real devices and emulators. You describe the journey in plain language, and Thunders generates the test, runs it, and keeps it working as your UI changes.
We are actively preparing iPhone Duo support, with testing on both emulator and physical device environments coming after launch. If foldable coverage is on your roadmap, this is the right time to get in touch so we can guide you on the next steps and have your test suite ready when support lands.
In the meantime, you can put the foundation in place today:
- Automate your existing iOS, Android, and responsive web checks now, so you have a reliable baseline before Duo testing begins
- Move from one-off testing to continuous testing, running your critical journeys on every release so a fix for one device never silently breaks another
- Extend the same suite to iPhone Duo configurations as support becomes available, instead of rebuilding your test strategy every time new hardware ships
Quality is not a single pass before launch. The teams that ship with confidence are the ones testing continuously, on every build, across every environment their users actually have.
Create a free Thunders account to start automating your current checks today, or book a demo and our team will walk you through the setup, the environments we cover, and the next steps for iPhone Duo.
For the web portion of your review, Thunders' responsive testing guide provides broader groundwork for testing across browsers and viewport sizes. Keep that preparation evidence separate from completed iPhone Duo validation.
