iPhone Duo adaptive layout: ArrangementView and reserved regions

Summary. Apple announced iPhone Duo on 9 September 2026, with pre-orders from 16 October 2026, availability from 23 October 2026 in more than 70 countries, and a second wave of 28 more from 30 October 2026. It starts at $1,999 in the US across 256GB to 2TB capacities. The device ships with iOS 27.1, and that version number matters more to engineering teams than any hardware spec: iOS 27.1 is the release in which Apple's system arrangements and the ReservedRegion API become available to third-party apps. An app built against an older SDK still runs, but it gets progressively less of the screen. This guide covers the three layout decisions that actually take engineering time: querying reserved regions around the hinge, choosing between the split and overlay arrangements, and knowing which containers already adapt for free.

Most foldable coverage this week is about the hinge as an object. The engineering question is narrower and more useful: what does the fold do to your layout, and which of that does the system handle without you.

The SDK tier is the first decision, and it is not binary

Apple is explicit that support is graduated rather than on-or-off. In the Tech Talk Prepare your app for iPhone Duo, the UI Frameworks team states that an app "runs on iPhone Duo even without recompiling, but screen usage improves with each SDK. The iOS 27 SDK extends your app left of the status bar on the inner display; the iOS 27.1 SDK reaches the screen edge and lays standard navigation and toolbar buttons out vertically."

So there are three states, not two, and the gap between them is visible screen area.

SDK you build against | What the app gets on the inner display | Work required ---|---|--- Older SDK, no recompile | Runs, compatibility presentation | None iOS 27 SDK | Extends left of the status bar | Rebuild iOS 27.1 SDK | Reaches the screen edge, vertical bar layout | Rebuild plus layout audit

The practical reading for a product owner: a rebuild against iOS 27.1 is the cheapest meaningful step, and it is a prerequisite for everything below. Nothing in Apple's published material sets a deadline for this. Unlike the Google Play API 36 floor, there is no submission cut-off attached to iPhone Duo support, so this is a competitive decision rather than a compliance one.

Reserved regions: the hinge is a layout object you can query

Apple's model treats the hardware as regions your layout avoids, in the same way an iPad layout avoids window controls. The Strike a pose with adaptive layouts session describes two kinds. A division region divides a larger area into smaller ones, and backs the fold. An occlusion region occludes rather than divides, and represents the FaceTime camera.

Querying them in SwiftUI uses a new method on GeometryProxy:

            // SwiftUI
GeometryReader { proxy in
  let regions = proxy.reservedRegions(
    kind: .division)
}
          

UIKit gets the equivalent on UIView, and the frame is what you feed into your own layout:

            // UIKit
let regions = view.reservedRegions(
  kind: .division)

// Query the frame to incorporate it into your own layout
let frames = regions.map(\.frame)
          

The behaviour that catches people out is activity. Regions are active or inactive, and only active ones come back by default. Apple's summary is precise on this: the fold's division region "is active only when the device is folded, and has zero width when flat." A layout that only ever reads active regions therefore sees nothing at all on a flat device, which is correct but easy to misread as a broken query.

Inactive regions are still useful for coarse decisions. Apple's example is preferring an even number of grid columns, so that a future fold does not bisect a column. You opt in explicitly:

            // SwiftUI
GeometryReader { proxy in
  let regions = proxy.reservedRegions(
    kind: .division, options: .includeInactive)

  let frames = regions.map(\.frame)
}
          

Apple's guidance is to reserve this API for the cases that need it. The closing advice in that session is to "adopt the ReservedRegions API for your highest-priority manually laid out controls", not to thread it through every view.

What adapts without any work

Before writing custom layout code, it is worth knowing how much is already handled, because the answer is most of it.

Apple states that navigation containers including NavigationStack, NavigationSplitView and TabView, and content containers including List and ScrollView, "adapt to the fold for free." Columns collapse when the device is closed and tile or overlay when it is open. Presentations are covered too: the system "automatically repositions action sheets, alerts, menus, and popovers around reserved regions to keep them fully visible."

This is the single most useful fact for scoping. An app already built on standard navigation containers needs a rebuild and an audit, not a rewrite. The teams facing real work are those with hand-rolled navigation, custom bars, or centred single-column layouts that assume one continuous rectangle.

Arrangements: the new container between navigation and content

For custom two-view layouts, iOS 27.1 introduces arrangements. Apple describes an arrangement as a layout container that "sits between navigation and content containers, arranging two views according to a set of rules", where the rules are a function of size classes, the view's aspect ratio, and any active division regions.

The SwiftUI container takes a primary and a secondary view and goes inside a NavigationStack:

            // SwiftUI
var body: some View {
  NavigationStack {
    ArrangementView {
      PlayerView()
    } secondary: {
      UpNextView()
    }
  }
}
          

UIKit uses UIArrangementViewController as the root of a UINavigationController:

            // UIKit
let arrangementVC = UIArrangementViewController()
let navController = UINavigationController(rootViewController: arrangementVC)

let playerVC = PlayerViewController()
arrangementVC.setViewController(playerVC, for: .primary)

let upNextVC = UpNextViewController()
arrangementVC.setViewController(upNextVC, for: .secondary)
          

Split, and why the axis matters

The default split style divides its bounds between primary and secondary. Apple's rule is mechanical: it "splits horizontally when the view is wider than it is tall and vertically when taller."

            // SwiftUI
.arrangementViewStyle(.split)
          

You can restrict it to one axis, which is where the sharp edge lives:

            // SwiftUI
.arrangementViewStyle(
  .split.axes(.horizontal))
          

Apple's note on that restriction deserves emphasis, because it is a silent behaviour change rather than an error: "when the arrangement can't split along its primary axis it shows only a single view." Constrain the axis and you are accepting that one of your two views disappears in some poses. That is a product decision, and it should be made deliberately rather than discovered in review.

UIKit updates the arrangement imperatively:

            // UIKit
arrangementVC.updateArrangement(.split.axes(.horizontal))
          

Overlay, and reading the Z index

Overlay prefers positioning content above or below, and moves to side by side when the device folds. The useful part is that you can observe where your view landed in the stack and change its presentation accordingly:

            // SwiftUI
enum UpNextMinimization {
  case collapsed; case expanded
}

struct UpNextView: View {
  @Environment(\.overlayArrangementZIndex)
  private var zIndex: Int

  var body: some View {
    UpNextList(minimization: minimization)
  }

  var minimization: UpNextMinimization {
    zIndex > 0 ? .collapsed : .expanded
  }
}
          

UIKit reads the same value from the arrangement state:

            // UIKit
let primaryState = arrangementVC.state(for: .primary)
myModel.minimization = (primaryState?.zIndex ?? 0) > 0
  ? .collapsed : .expanded
          

Choosing between them

Apple's decision rule is inheritance first, semantics second. Follow your app's existing patterns: HStack or VStack layouts translate to split, ZStack layouts to overlay. Where no pattern exists, choose overlay when there is a clear foreground and background relationship and partially obscuring the background is acceptable, and split when the relationship is main and detail and neither view should be obscured.

Arrangement | Default placement | When it fits | Apple's example ---|---|---|--- Split | Divides bounds, horizontal if wider than tall | Main and detail, neither obscured | Podcasts transcript Overlay | Above or below, side by side when folded | Foreground over background | Accessibility Reader

Two places not to use an arrangement

Apple names both constraints explicitly, and they are the kind that surface as layout bugs rather than compile errors. ArrangementView provides no navigation infrastructure, so avoid putting navigation containers such as NavigationSplitView inside one. And because of how List and ScrollView behave, avoid putting an ArrangementView inside a scrollable container.

The hinge angle is a separate API, and not for layout

It is worth separating two things that sound similar. Apple's Tech Talk session 111464 on multiple displays and scenes introduces onHingeChange in SwiftUI and UIHingeInteraction in UIKit, which report hinge status as closed, partially open or fully open, plus continuous angle updates.

Apple is direct that this is not a layout tool: hinge data "is observed live and is ideal for driving interactions or effects. For layout, use the arrangement and region APIs" instead. Teams reaching for the angle to decide a layout are using the wrong input and will fight the system. Use it for interaction, as in Apple's worked example of driving a guitar pitch bend from the angle while the device is partially open.

An audit that takes an afternoon

Apple's own closing checklist is short, and it is a reasonable scope for a first pass on an existing app.

1. Audit centred layouts and ask whether a two-column layout or a displacement pattern fits better.

1. Confirm you are using standard system containers and presentations, which carry most of the behaviour.

1. For custom horizontal split or overlay layouts, evaluate ArrangementView.

1. Adopt reserved regions for the highest-priority manually laid out controls only.

Add one item Apple raises separately in the readiness session: stop referencing the main screen. On a two-display device it is ambiguous, and Apple states it "will be deprecated." Read the scale from the trait collection instead of UIScreen.main.scale.

What this costs, honestly

The spread is wide and it is driven by one variable. An app on standard navigation containers is a rebuild against the iOS 27.1 SDK plus a layout audit, measured in days. An app with custom navigation, hand-drawn bars, or layouts that assume a single uninterrupted rectangle is a genuine refactor, because the fold turns one canvas into regions and no amount of constraint tweaking papers over that.

We size this work by reading the view hierarchy, not the brief. If you want a defensible estimate rather than a range, the useful input is your navigation layer and the count of manually laid out controls. Tell us what those look like at our contact page and we will tell you which of the four steps above your app actually needs.

Related reading on adjacent version floors: our guide to hiring Kotlin developers against the API 36 deadline covers the Android equivalent, and SwiftUI versus Kotlin Multiplatform sets out where a shared codebase changes this calculation. For delivery rather than staffing, see iOS app development.

FAQ

How eCorpIT can help

eCorpIT is a Gurugram-based engineering organisation, founded in 2021, holding CMMI Level 5, MSME and ISO 27001:2022 certifications, with senior-led iOS teams. We take on bounded adaptive-layout migrations, retained capacity for teams tracking the iOS release calendar, and embedded engineers inside existing squads. We scope foldable work by auditing the navigation layer and the manually laid out controls, because that is what determines whether this is a rebuild or a refactor. Tell us where your view hierarchy sits today at our contact page.

References

1. Apple unveils iPhone Duo — Apple Newsroom, 9 September 2026

1. Strike a pose with adaptive layouts on iPhone Duo — Apple Developer Tech Talks

1. Prepare your app for iPhone Duo — Apple Developer Tech Talks

1. Apple Developer Tech Talks, session 111464, on multiple displays and scenes on iPhone Duo

1. Raise the bar with iPhone Duo — Apple Developer Tech Talks

1. UserInterfaceSizeClass — Apple Developer Documentation

1. horizontalSizeClass — Apple Developer Documentation

1. Layout — Human Interface Guidelines, Apple Developer

1. Maintaining the adaptable sizes of built-in views — Apple Developer

1. Build a great camera experience for iPhone Duo — Apple Developer Tech Talks

1. Modernize your UIKit app — WWDC26, Apple Developer

_Last updated: 12 September 2026._