# FoldReady: iPhone Duo app compatibility consulting and automated foldable testing
Get your iOS app ready for iPhone Duo and foldable devices. Fixed-price Duo readiness audits, redesign and implementation, and FoldCheck, an automated compatibility tester for every fold pose.
Contact: vity5.diduk@gmail.com. Site: https://foldready.dev. Updated: 2026-09-12.

## iPhone Duo key facts
- Announced: September 9, 2026
- Ships: October 23, 2026
- Starting price: $1,999
- Outer display: 5.4 inches, 1398 x 2034 px, 460 ppi, compact width
- Inner display: 7.6 inches, 1878 x 2670 px, 430 ppi, regular width and height
- Poses to support: Six: closed, open and half folded, each in portrait and landscape; plus side-by-side multitasking
- Legacy apps: Apps built with an SDK older than iOS 27 run letterboxed; iOS 27 extends content past the status bar, iOS 27.1 reaches the screen edge
- Required tooling: Xcode 27.1, iOS 27.1 SDK, Device Hub simulator
- New layout API: ReservedRegion (SwiftUI) / UIViewReservedRegion (UIKit), kinds: division (fold), occlusion (camera)

## Services
- iPhone Duo readiness audit: every screen tested in all six poses plus side-by-side multitasking, prioritized fixes with screenshots, delivered in five business days. Fixed price. https://foldready.dev/#services
- Redesign and implementation: size-class layouts, ReservedRegion work, half-fold and multi-window behavior, shipped as pull requests. https://foldready.dev/#services
- Ongoing foldable QA: pose and size-class regression pass on each build. https://foldready.dev/#services
- FoldCheck: automated iPhone Duo and foldable compatibility tester, early access, free for the first apps. https://foldready.dev/#foldcheck

## FAQ
**Does my existing iOS app work on iPhone Duo without changes?**

Usually it launches and runs. Apple lets unmodified apps run on the inner display with limited screen usage that later SDKs extend, but layouts built for a single 6-inch portrait screen often show stretched controls, clipped content, wrong safe areas around the fold, and navigation that ignores the wider size class. It works, but it does not look like a Duo app, and reviews notice.
**What is an iPhone Duo readiness audit?**

We run your build in the Xcode 27.1 iPhone Duo simulator across all six poses: closed, open and half folded, each in portrait and landscape, plus side-by-side multitasking. Every screen gets screenshots and a prioritized list of layout, safe-area, ReservedRegion, orientation and multi-window issues, with concrete SwiftUI or UIKit fixes. You get the report within five business days.
**Which stacks do you support?**

SwiftUI and UIKit first. React Native and Flutter apps are supported for the audit and for layout fixes at the native and framework layer.
**How long does a full Duo redesign take?**

Most apps need one to three weeks. Apps with custom navigation bars, edge-to-edge canvases, or heavy hardcoded widths take longer. The audit gives you a fixed quote before any work starts.
**What is FoldCheck?**

FoldCheck is an automated compatibility tester for iPhone Duo and other foldable devices. It drives your app through every fold pose and size class, captures screenshots, flags clipped content, hardcoded dimensions, overlapping system UI and missing size-class handling, and proposes code-level fixes. It is in early access; join the list to get in first.
**Does this also cover iPad multitasking and other foldables?**

Yes. The same adaptive layout work makes your app behave in iPad Split View, Stage Manager and Mac Catalyst windows. FoldCheck is designed around poses and size classes rather than a single device, so it extends to future foldables.
**How much does it cost?**

Audits and redesigns are fixed price and quoted within 24 hours of your email. FoldCheck early access is free for the first apps on the list.

---

# How to prepare your iOS app for iPhone Duo: a 12-step checklist

Source: https://foldready.dev/guides/prepare-your-app-for-iphone-duo

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: To prepare an iOS app for iPhone Duo, replace idiom and orientation checks with size classes, adopt the iOS 27.1 ReservedRegion API for custom bars, remove hardcoded frame sizes, and test every screen in all six poses (closed, open and half folded, each in portrait and landscape) in the Xcode 27.1 Device Hub simulator.

Apple announced iPhone Duo, its first foldable iPhone, on September 9, 2026. It ships October 23, 2026. Existing apps launch on it without changes, but apps built against an SDK older than iOS 27 run letterboxed with limited screen usage, and most were designed for one compact portrait screen. This checklist covers what to change so an app feels native on both displays and in every pose.

## Before you start

- Install Xcode 27.1. The iPhone Duo simulator lives in Device Hub and has on-screen buttons to open, close, rotate and fold the device.
- Build with the iOS 27.1 SDK. The iOS 27 SDK extends content left of the status bar on the inner display; the 27.1 SDK reaches the screen edge and lays standard navigation and toolbar buttons out vertically.
- Watch Apple's two tech talks: "Prepare your app for iPhone Duo" and "Strike a pose with adaptive layouts on iPhone Duo".

## The checklist

1. Replace every UIDevice idiom check and interface orientation check with size classes. The outer display is compact width and regular height in portrait, like any iPhone. The inner display is regular width and regular height, like an iPad, which is why iPhone-only branches break.
2. Remove UIScreen.main.bounds and other fixed frame sizes. Window size changes live when the device opens, closes or is placed side by side with another app.
3. Adopt NavigationSplitView in SwiftUI or UISplitViewController in UIKit so the inner display gets a sidebar or two-column layout instead of a stretched single column.
4. Handle asymmetric safe areas and layout margins. On the inner display the system UI is not symmetric left to right.
5. Use the iOS 27.1 ReservedRegion API (SwiftUI) or UIViewReservedRegion (UIKit) for custom bars, toolbars and edge-to-edge canvases so they claim space without colliding with system UI.
6. Query reserved regions by kind. The division kind marks the fold itself; the occlusion kind marks the camera. Keep controls and important content out of both.
7. Design a half-folded pose. When the device is partly folded the inner display behaves like two halves. Media, camera, reading and video-call views should place content on one half and controls on the other rather than straddling the crease.
8. Preserve state across the outer-to-inner handoff. Opening the device while a screen is on the outer display must not reload data or lose scroll and edit state.
9. Support side-by-side multitasking. Users can run two apps at once on the inner display, so the app can be resized to a compact slice at any moment.
10. Adopt the Concentricity APIs for corner shapes so custom rounded containers match the display corners.
11. Test text scaling and Dynamic Type at both display sizes; the inner display is 7.6 inches at 430 ppi and exposes long lines that were previously wrapped.
12. Run every screen through all six poses (three fold states in two orientations) plus side-by-side multitasking in the simulator and capture screenshots for review. Do this again before each release.

## What to prioritize if you have one week

Fix size-class branching first because it affects every screen. Then remove hardcoded widths, which cause the visible clipping that reviewers screenshot. Then handle the half-folded pose for any media or camera screen. Everything else can follow in a point release.

> Need this done for you? FoldReady runs a fixed-price iPhone Duo readiness audit that covers every item on this list and returns a prioritized fix list in five business days.

## FAQ

**Do I need to rewrite my app for iPhone Duo?**

No. Apple states that legacy iOS apps do not require a full refactor. Most apps need targeted changes to size-class handling, safe areas, hardcoded dimensions and custom bars.

**Which Xcode version supports iPhone Duo?**

Xcode 27.1 includes the iPhone Duo simulator in Device Hub and the iOS 27.1 SDK with the ReservedRegion API.

## Sources

- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)
- [Apple Newsroom: Apple unveils iPhone Duo](https://www.apple.com/newsroom/2026/09/apple-unveils-iphone-duo/)

---

# iPhone Duo specs for developers: displays, size classes, poses and tools

Source: https://foldready.dev/guides/iphone-duo-specs-for-developers

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: iPhone Duo has a 5.4-inch outer display at 1398 by 2034 pixels and a 7.6-inch inner display at 1878 by 2670 pixels and 430 ppi; both share one aspect ratio, the outer display reports compact width and the inner display reports regular width and regular height.

A reference sheet of the numbers and system behaviors an iOS developer needs when targeting iPhone Duo. All figures are from Apple's announcement and developer materials published September 9, 2026.

## Displays

|  | Outer display | Inner display |
| --- | --- | --- |
| Diagonal | 5.4 inches | 7.6 inches |
| Resolution | 1398 x 2034 px | 1878 x 2670 px |
| Pixel density | 460 ppi | 430 ppi |
| Refresh rate | 120 Hz ProMotion | 120 Hz ProMotion |
| Peak brightness | 3000 nits | 3000 nits |
| Aspect ratio | About 1.46:1 (2034/1398) | About 1.42:1 (2670/1878); Apple describes both as roughly 1.4:1 so layouts carry across |
| Finish | Glass | Matte nano-texture, reduces crease visibility |

## Size classes by pose

| Pose | Horizontal size class | Vertical size class | Behaves like |
| --- | --- | --- | --- |
| Closed, portrait | Compact | Regular | A standard iPhone |
| Closed, landscape | Compact | Compact | A standard iPhone in landscape |
| Open, portrait | Regular | Regular | A small iPad |
| Open, landscape | Regular | Regular | A small iPad in landscape |
| Half folded, portrait | Regular | Regular | Two halves; content should avoid the fold |
| Half folded, landscape | Regular | Regular | Top and bottom halves; ideal for video and camera |

### Window states on top of the poses

| Window state | Horizontal size class | Vertical size class | Behaves like |
| --- | --- | --- | --- |
| Open, side by side with another app | Compact | Regular | iPad Split View |

Rotation is not a pose of its own; it is an orientation applied to each fold state. Apple's guidance is to make layout decisions from size classes, never from orientation, because the inner display does not honor supported interface orientations the way a single-screen iPhone does.

## Reserved regions

iOS 27.1 introduces ReservedRegion in SwiftUI and UIViewReservedRegion in UIKit. Apps query regions by kind. The division kind is the fold; the occlusion kind is the camera. Standard system controls avoid both automatically; custom UI must opt in.

## Tooling

- Xcode 27.1 with the iPhone Duo simulator in Device Hub. Controls open, close, rotate and fold the device.
- iOS 27 SDK: content extends left of the status bar on the inner display.
- iOS 27.1 SDK: content reaches the screen edge; navigation and toolbar buttons lay out vertically; ReservedRegion API available.
- Concentricity APIs for corner shapes that match the display.

## Commercial facts

| Fact | Value |
| --- | --- |
| Announced | September 9, 2026 |
| Ships | October 23, 2026 |
| Starting price | $1,999 (256 GB) |
| Top configuration | $3,199 (2 TB) |
| Launch partner apps | Netflix, Zoom, Slack among the first adapted third-party apps |

## Sources

- [Apple Newsroom: Apple unveils iPhone Duo](https://www.apple.com/newsroom/2026/09/apple-unveils-iphone-duo/)
- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)

---

# SwiftUI and UIKit layouts for iPhone Duo: size classes, split views and reserved regions

Source: https://foldready.dev/guides/swiftui-uikit-layouts-for-iphone-duo

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: On iPhone Duo, read horizontalSizeClass from the SwiftUI environment or the UIKit trait collection instead of checking device idiom, use NavigationSplitView for the regular-width inner display, and keep custom bars out of the fold and camera reserved regions exposed by the iOS 27.1 ReservedRegion API.

Most iPhone Duo layout bugs come from three habits: branching on device idiom, sizing from the screen instead of the container, and drawing custom chrome where the system reserves space. This guide shows the replacement for each.

## 1. Branch on size class, not idiom or orientation

```swift
struct LibraryView: View {
    @Environment(\.horizontalSizeClass) private var hSize

    var body: some View {
        if hSize == .regular {
            // Inner display, or closed device with plenty of width.
            NavigationSplitView {
                SidebarList()
            } detail: {
                DetailPane()
            }
        } else {
            // Outer display, or the app is a compact slice in multitasking.
            NavigationStack { SidebarList() }
        }
    }
}
```

In UIKit, read traitCollection.horizontalSizeClass and respond in traitCollectionDidChange or, on iOS 17 and later, with registerForTraitChanges. Never cache the value at launch; it changes when the device opens or closes.

## 2. Size from the container, never from the screen

```swift
// Before: breaks the moment the window is not the full screen.
let width = UIScreen.main.bounds.width

// After: UIKit
let width = view.window?.windowScene?.coordinateSpace.bounds.width ?? view.bounds.width

// After: SwiftUI, only when you truly need a number
GeometryReader { proxy in
    Grid(columns: proxy.size.width > 600 ? 2 : 1)
}
```

Prefer layout containers such as ViewThatFits, adaptive grids and flexible frames over measured widths. When the device opens, the window resizes live and every measured value becomes stale.

## 3. Respect the fold and camera reserved regions

iOS 27.1 adds ReservedRegion in SwiftUI and UIViewReservedRegion in UIKit. Standard bars and toolbars avoid these regions automatically. Custom bottom bars, floating action buttons and edge-to-edge canvases must query the regions and lay out around them. Two kinds exist: division for the fold and occlusion for the camera. Treat a non-empty division region as the signal that the device is half folded, and move controls to one half.

> Exact API signatures are in the iOS 27.1 SDK documentation. Query the regions in the same place you read safe area insets so both update together on pose changes.

## 4. Handle asymmetric safe areas

Do not assume safeAreaInsets.leading equals safeAreaInsets.trailing on the inner display. Use the individual insets and layout margins rather than a single horizontal padding value.

## 5. Preserve state through the handoff

When the user opens the device, the same scene continues on the inner display with a new size. Keep view models outside of view identity, avoid re-fetching in onAppear without a guard, and store scroll position and in-progress edits in state that survives a layout change.

## 6. Test the matrix

Every screen should be checked in the six poses, closed, open and half folded in both orientations, and side by side with another app. The Xcode 27.1 Device Hub simulator has buttons to open, close, fold and rotate, which reach all six poses. Automating this matrix with screenshots per pose is what FoldCheck does.

## FAQ

**Does NavigationSplitView work on iPhone Duo?**

Yes. On the regular-width inner display it shows a sidebar and detail column; on the compact outer display it collapses to a stack automatically.

**Can I detect the half-folded pose in SwiftUI?**

Query the ReservedRegion API for the division kind. A non-empty fold region indicates a folded pose; lay out content on either side of it.

## Sources

- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)
- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)

---

# iPhone Duo testing checklist: the pose matrix every screen must pass

Source: https://foldready.dev/guides/iphone-duo-testing-checklist

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: Testing an app for iPhone Duo means running every screen through six poses, closed, open and half folded in both portrait and landscape, plus side-by-side multitasking, and checking each for clipped content, hardcoded widths, system UI collisions, content across the fold, state loss on handoff and broken multi-window resizing.

A single screen on iPhone Duo can render in six poses, three fold states in two orientations, plus a side-by-side window state, seven configurations per screen. Manual testing that covers all of them for a 40-screen app is 280 checks per build, which is why teams skip it. This checklist makes the matrix explicit so it can be split, scripted or automated.

## The pose matrix

| Pose or window state | How to get there in the simulator | Most common defect |
| --- | --- | --- |
| Closed, portrait | Default | None; matches existing iPhone behavior |
| Closed, landscape | Rotate | Controls hidden behind the keyboard |
| Open, portrait | Open | Single column stretched across the 4.4-inch-wide inner display |
| Open, landscape | Open, then rotate | Sidebar and detail proportions wrong |
| Half folded, portrait | Fold | Content or controls straddling the crease |
| Half folded, landscape | Fold, then rotate | Video or camera view not split top and bottom |
| Window state: open, side by side | Open, then add a second app | Layout does not collapse back to compact |

## What to check on every screen

1. Clipped or truncated text and images.
2. Elements positioned with hardcoded widths or heights.
3. Custom bars overlapping the vertically laid out system navigation and toolbar buttons.
4. Important content or tap targets over the fold region or the camera occlusion.
5. Scroll position, form input and playback state preserved when opening or closing the device mid-task.
6. Correct collapse to a compact layout when the window is resized in multitasking.
7. Asymmetric safe areas respected on the inner display.
8. Dynamic Type at the largest accessibility sizes on both displays.

## Transitions, not just poses

Test the moves between poses as well as the poses themselves: closed to open while a sheet is presented, open to half folded during video playback, and resizing in multitasking while a text field has focus. These transitions expose state loss that static screenshots miss.

## Automating the matrix

The manual matrix scales linearly with screen count and must be repeated each release. FoldCheck automates it: it drives a simulator build through every pose, captures screenshots, flags clipped content, hardcoded dimensions, system UI collisions and content across the fold, and proposes SwiftUI or UIKit fixes. It is in early access and free for the first apps on the list.

> Want the matrix run on your app before launch? Request a FoldReady readiness audit or join FoldCheck early access from the home page.

## Sources

- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)
- [Apple Tech Talk: Design for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111466/)

---

# iPhone Duo app letterboxed or not full screen: why it happens and how to fix it

Source: https://foldready.dev/guides/iphone-duo-app-letterboxed-fix

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: An iOS app is letterboxed on iPhone Duo because it was built with an SDK older than iOS 27; rebuilding with Xcode 27.1 and the iOS 27.1 SDK removes the bars, and adopting size classes, flexible layouts and the ReservedRegion API makes the app fill the inner display correctly.

You opened your app on an iPhone Duo and it sits in the middle of the inner display with dark bars around it, or it fills the screen but every control is stretched. Both are expected behavior for apps that predate the Duo SDK, and both are fixable in days, not months.

## Why is my app letterboxed on iPhone Duo?

iOS decides how much of the inner display an app may use from the SDK the app was built against. Apps built with an SDK older than iOS 27 run in a compatibility window with limited screen usage, which appears as letterboxing. Apps built with the iOS 27 SDK extend past the status bar on the inner display. Apps built with the iOS 27.1 SDK reach the screen edge and get vertically laid out navigation and toolbar buttons. The letterbox is a promise from Apple that old apps still work; it is not a bug in your code.

## Why is my app stretched instead of letterboxed?

If the app was already built with a recent SDK, it fills the display, but layouts written for a compact-width iPhone are now given regular width. A single column stretches across the 4.4-inch-wide inner display, buttons sized from the screen width become enormous, and lists show one item per row with empty space on both sides. Stretching is a size-class problem, not an SDK problem.

## How do I fix it?

1. Rebuild with Xcode 27.1 and the iOS 27.1 SDK. This alone removes the letterbox and lets the app reach the screen edge.
2. Delete UIRequiresFullScreen from Info.plist if present. Apple deprecated the key in 2025 and the system ignores it once the app links against the iPadOS 26 SDK or later, so there is no longer a way to opt out of resizing or side-by-side multitasking. Leaving it in only misleads the next engineer.
3. Replace device idiom and orientation checks with size classes. The inner display is regular width and regular height; the outer display is compact width.
4. Give regular width a real layout: NavigationSplitView or UISplitViewController, adaptive grids, and a maximum content width for reading views.
5. Remove UIScreen.main.bounds and fixed frame sizes. Size from the container so the window can change live when the device opens or closes.
6. Adopt the ReservedRegion API for custom bars and edge-to-edge canvases so they do not collide with system UI, the fold or the camera.
7. Run every screen through all six poses in the Device Hub simulator and fix what you see.

## How long does the fix take?

| Situation | Typical effort | What you get |
| --- | --- | --- |
| Letterboxed, otherwise fine | Half a day | Rebuild with Xcode 27.1, retest, resubmit |
| Stretched single-column app, 10 to 20 screens | 3 to 6 engineering days | Size-class layouts, split view on the inner display |
| Custom navigation bars, media or camera screens | 1 to 3 weeks | ReservedRegion adoption, half-fold layouts, state preservation |
| Cross-platform app (React Native, Flutter) | 1 to 2 weeks | Window-dimension fixes plus native layout work at the edges |

Effort estimates assume a team that already ships iOS regularly. After previous form-factor launches, reviewers noticed compatibility-mode apps within days, so it is reasonable to prioritize the rebuild first and the layout work in a follow-up release.

> Not sure which case you are in? Send the App Store link and FoldReady will tell you within 24 hours whether a rebuild is enough or a readiness audit is worth it.

## FAQ

**Does letterboxing hurt my App Store rating?**

Indirectly. Early buyers of a new form factor tend to be enthusiasts who leave reviews, and after previous launches, apps that ran in compatibility mode drew one-star reviews in the first weeks. Expect the same pattern on a $1,999 device.

**Will Apple reject my app if it is letterboxed on iPhone Duo?**

No. Apple runs older apps in a compatibility mode on purpose. Letterboxing is a user experience problem, not a review guideline violation.

**Can I fix letterboxing without changing any code?**

Often yes for the letterbox itself: rebuilding with Xcode 27.1 removes it. Stretched layouts need code changes.

## Sources

- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)

---

# How much does it cost to update an app for iPhone Duo?

Source: https://foldready.dev/guides/iphone-duo-app-update-cost

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: Updating an app for iPhone Duo typically costs between half a day for a simple rebuild and three to six engineering weeks for apps with custom design systems, media or camera screens; at common contractor rates of $100 to $180 per hour that is roughly $400 to $43,000 assuming eight-hour engineering days, and a readiness audit fixes the number before any work starts.

Nobody publishes numbers for this, so budgets get set by guesswork. iPhone Duo has not shipped yet, so these ranges come from scoping the same class of work on earlier form-factor changes, iPad multitasking, Dynamic Island and Stage Manager adoption, mapped onto the Duo change surface Apple has documented. They assume a competent iOS team or contractor and are meant to give a product owner a defensible order of magnitude, not a quote.

## What drives the cost?

- Number of screens with custom layout code. Screens built from standard navigation and lists adapt nearly for free.
- Hardcoded dimensions. Every UIScreen.main.bounds and fixed width is a change, and they cluster in older code.
- Custom bars and edge-to-edge canvases. These need the ReservedRegion API and are the most expensive per screen.
- Media, camera and video-call screens. They need a designed half-fold layout, not just a resize.
- Cross-platform frameworks. React Native and Flutter add a layer where window size can be cached at startup.
- Test coverage. Without automated screenshots, every release repeats the manual pose matrix.

## Cost by app type

| App type | Engineering effort | At $100 to $180 per hour | Notes |
| --- | --- | --- | --- |
| Simple, standard UIKit or SwiftUI, under 15 screens | 0.5 to 3 days | $400 to $4,300 | Mostly a rebuild plus size-class branches |
| Mid-size product app, 15 to 40 screens | 1 to 2 weeks | $4,000 to $14,400 | Split views, adaptive grids, fixed-width cleanup |
| Media, camera, video, reading or maps app | 2 to 4 weeks | $8,000 to $28,800 | Half-fold layouts, ReservedRegion, state across handoff |
| Custom design system with own bars and gestures | 3 to 6 weeks | $12,000 to $43,200 | Design work plus engineering; often the design system itself changes |
| React Native or Flutter app | 1 to 2 weeks | $4,000 to $14,400 | Window-dimension and safe-area fixes plus native edges |

Dollar figures are engineering days times eight hours at the stated $100 to $180 hourly range, which is a common contractor bracket for senior iOS work in the US and Western Europe; the rates are an assumption, not a market survey, so substitute your own. Ongoing cost is smaller but real: each release needs the six-pose check. Manually that is 10 to 30 minutes per screen; automated screenshot testing brings it close to zero.

## How do I get a fixed number instead of a range?

A readiness audit runs every screen through every pose, lists the concrete issues with screenshots, and returns a prioritized fix list. Because the audit exposes exactly how many screens have custom layout code and hardcoded dimensions, the redesign quote that follows is fixed price. Most teams find the audit pays for itself by removing screens from the estimate that turned out to need nothing.

## Is it worth doing before the October 23 launch?

For consumer apps with reviews that matter, yes. Expect first-week buyers to write reviews, as they did for previous form factors, and a letterboxed or stretched app on a $1,999 device is an easy complaint. For internal or B2B apps with a known user base, a rebuild before launch and layout work in the next planned release is usually enough.

> Want the number for your app? Email the App Store link to FoldReady and you get a fixed-price audit quote within 24 hours.

## FAQ

**Can I just rebuild with Xcode 27.1 and ship?**

Yes, and for simple apps that is the whole job. It removes the letterbox. It does not fix layouts that assume compact width, which show as stretched controls on the inner display.

**Do I need a designer for the iPhone Duo update?**

For standard apps, no; size classes and split views are engineering work. For apps with a custom design system or media screens, a designer decides the half-fold and two-column layouts, and that is usually a few days of design time.

## Sources

- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)
- [Apple Newsroom: Apple unveils iPhone Duo](https://www.apple.com/newsroom/2026/09/apple-unveils-iphone-duo/)

---

# iPhone Duo support for React Native and Flutter apps

Source: https://foldready.dev/guides/react-native-flutter-iphone-duo

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: React Native and Flutter apps run on iPhone Duo, but they must read window size reactively (useWindowDimensions in React Native, MediaQuery or LayoutBuilder in Flutter) instead of caching it at startup, handle asymmetric safe areas, and use native code for the iOS 27.1 ReservedRegion API until framework support lands.

Cross-platform teams are the least prepared for iPhone Duo. Their layout code often reads the window size once at launch, and their foldable experience, if any, comes from Android where the fold is exposed through different APIs. This guide covers what actually changes and what still needs native Swift.

## What is the same as native?

- Rebuilding with Xcode 27.1 and the iOS 27.1 SDK is required to leave the compatibility window. This is a native toolchain step regardless of framework.
- The window resizes live when the device opens, closes, folds or enters side-by-side multitasking. Anything that cached the size at startup is wrong after the first fold.
- Safe areas on the inner display are asymmetric. Use per-edge insets, never a single horizontal padding value.
- Every screen must be checked in all six poses plus side-by-side multitasking. The framework does not change the test matrix.

## React Native

```tsx
import { Dimensions, useWindowDimensions } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";

// Wrong: read once at module load, never updates on fold or multitasking.
const { width: staleWidth } = Dimensions.get("window");

// Right: re-renders when the window changes.

function Library() {
  const { width } = useWindowDimensions();
  const insets = useSafeAreaInsets(); // per-edge, asymmetric on the inner display
  const regularWidth = width >= 600;   // conventional compact/regular cut in points; confirm in the Device Hub simulator
  return regularWidth ? <TwoColumn insets={insets} /> : <Stack insets={insets} />;
}
```

- Search the codebase for Dimensions.get and replace it with useWindowDimensions. Avoid relying on Dimensions change events; React Native has a long-standing issue where they do not fire on first entry into split view, and side-by-side multitasking is a first-class window state on Duo.
- Derive a size-class equivalent from width, not from Platform.isPad or device model. iPhone Duo's inner display is regular width on a phone.
- Use react-native-safe-area-context for insets and apply them per edge.
- Navigation libraries with drawer or split layouts (for example React Navigation's drawer) can provide the two-column layout on the inner display.
- The fold and camera reserved regions are exposed by the iOS 27.1 ReservedRegion API. Until a maintained package wraps it, expose the regions through a small native module and pass them to JavaScript as insets.

## Flutter

```dart
// Reacts to window changes, including fold, unfold and multitasking.
Widget build(BuildContext context) {
  final size = MediaQuery.sizeOf(context);
  final padding = MediaQuery.paddingOf(context); // asymmetric on the inner display
  final regularWidth = size.width >= 600; // conventional cut in logical pixels; confirm in the simulator
  return regularWidth
      ? TwoColumnLayout(padding: padding)
      : StackedLayout(padding: padding);
}

// Prefer LayoutBuilder for widgets that only need their own constraints.
LayoutBuilder(builder: (context, constraints) =>
  constraints.maxWidth >= 600 ? const WideList() : const NarrowList());
```

- MediaQuery.sizeOf and LayoutBuilder already respond to window resizing; the risk is code that stored size in a singleton or computed it in initState.
- Flutter's MediaQuery.displayFeatures API describes hinges and folds. As of September 2026 it is populated on Android; check the Flutter changelog for iPhone Duo support, and until then bridge the ReservedRegion API through a platform channel.
- Use SafeArea with per-edge control rather than symmetric padding.
- NavigationRail or a two-pane layout package gives the regular-width layout on the inner display.

## Where native code is still required

| Need | React Native | Flutter |
| --- | --- | --- |
| Rebuild with iOS 27.1 SDK | Xcode project setting | Xcode project setting |
| Window size updates | useWindowDimensions | MediaQuery, LayoutBuilder |
| Asymmetric safe areas | react-native-safe-area-context | MediaQuery.paddingOf, SafeArea |
| Fold and camera reserved regions | Native module until a package exists | Platform channel until displayFeatures covers iOS |
| Half-fold detection | Native module | Platform channel |
| Concentric corner shapes | Native views only | Native views only |

> FoldReady audits React Native and Flutter apps as well as native ones, and the FoldCheck tester drives the built app, so it works regardless of framework.

## FAQ

**Does React Native support iPhone Duo?**

Yes. Apps run and resize. The work is in your layout code: window dimensions must be read reactively and safe areas applied per edge. Fold-specific APIs need a small native module for now.

**Does Flutter support iPhone Duo?**

Yes. MediaQuery and LayoutBuilder respond to window changes. Fold regions need a platform channel to the iOS 27.1 ReservedRegion API until Flutter exposes them on iOS.

## Sources

- [Apple Tech Talk: Prepare your app for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111461/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)

---

# iPhone Duo design guidelines for product teams

Source: https://foldready.dev/guides/iphone-duo-design-guidelines

Published: 2026-09-12. Updated: 2026-09-12. Author: FoldReady (vity5.diduk@gmail.com).

Summary: Good iPhone Duo design keeps the app continuous between the outer and inner displays, uses the regular-width inner display for two-column layouts rather than stretched phone screens, designs a dedicated half-fold layout for media and camera screens, and keeps content and controls out of the fold and camera regions.

Most Duo guidance is written for engineers. This page is for the people who decide what the app should look like on the new device: designers, product managers and founders. It distills Apple's design guidance for iPhone Duo into rules you can put in a brief.

## Rule 1: Continuity, not two apps

The outer and inner displays share roughly the same aspect ratio on purpose. A user starts a task on the outer display, opens the device, and expects the same screen with more room, not a different app. Keep navigation structure, position in a flow, scroll position and in-progress edits identical across the transition. Do not present a different home screen when the device opens.

## Rule 2: Use the width, do not stretch into it

The inner display is regular width, like a small iPad. Phone layouts stretched across it look broken. Design a two-column version of list-and-detail screens, a sidebar for apps with sections, and a maximum reading width for text-heavy views. Standard iOS components do this automatically when engineering uses size classes; custom components need a designed regular-width variant.

## Rule 3: Two size classes first; a bespoke half-fold layout only where it earns it

Apple's guidance is explicit: do not design a custom layout for each pose. Design for two size classes, compact and regular, and let every pose fall out of them. The documented exception is a bespoke layout for a specific pose when it clearly helps: a half-folded Duo stands on its own, and video playback, camera, video calls and media browsing benefit from content on one half and controls on the other. If you add such a layout, Apple asks that functionality and general hierarchy stay the same as in the regular layout. Every other screen simply avoids placing critical content across the fold.

## Rule 4: Respect the fold and the camera

iOS 27.1 exposes two reserved regions: the fold (division) and the camera (occlusion). System components already nudge interactive elements away from the hinge, with scrollable content as the stated exception, so standard bars and lists need no design work. Custom bars, floating buttons and edge-to-edge canvases must be designed with these regions in mind. Provide engineering with a regular-width layout that shows where custom controls go, and a half-fold variant only for the screens covered by Rule 3.

## Rule 5: Put toolbars and tab bars along the vertical edge

On the inner display iOS 27.1 lays standard navigation and toolbar buttons out vertically along the edge. Custom control bars should follow the same convention so the app feels native next to system apps and keeps controls clear of the fold. On the outer display, most content needs an offset so it is not hidden behind controls.

## Rule 6: Match the hardware corners

Rounded containers near the display edge should be concentric with the device corner. Apple's Concentricity APIs handle the math, but the design should specify which containers sit at the edge and therefore need it.

## Rule 7: Assume the window can be any size

Users run two apps side by side on the inner display, so the app can be a compact slice one moment and full width the next. Design breakpoints by width, not by device. Two layouts, compact and regular, cover every pose on Duo and also iPad multitasking.

## What to hand engineering

| Deliverable | Why engineering needs it |
| --- | --- |
| Compact and regular layouts for each screen type | Maps directly to size classes |
| Bespoke half-fold layout, only for media, camera and call screens | Apple's documented exception to the two-size-class rule; must keep the regular layout's hierarchy |
| List of custom bars and edge-to-edge surfaces | These need ReservedRegion work |
| Maximum content widths for text views | Prevents full-width line lengths on the 4.4-inch-wide inner display |
| State that must survive open and close | Drives what is preserved in the handoff |

## What does not change

Typography scale, color, iconography and interaction patterns carry over. The outer display behaves like any iPhone, so existing designs remain valid there. Duo work is additive: it adds regular-width and half-fold variants rather than replacing the phone design.

> FoldReady's readiness audit produces per-screen screenshots in every pose, which is the fastest way for a design team to see which screens need a regular-width or half-fold variant.

## FAQ

**Do I need a separate design for the outer display?**

No. The outer display is a compact-width iPhone screen and the existing phone design applies, with one caveat from Apple: most content needs an offset on the outer display so it is not hidden behind controls.

**Which screens need a half-fold design?**

Video playback, camera, video calls, reading and media browsing benefit most. Standard list and form screens usually do not need one.

## Sources

- [Apple Tech Talk: Design for iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111466/)
- [Apple Tech Talk: Strike a pose with adaptive layouts on iPhone Duo](https://developer.apple.com/videos/play/tech-talks/111463/)
- [Apple Newsroom: Apple unveils iPhone Duo](https://www.apple.com/newsroom/2026/09/apple-unveils-iphone-duo/)