Apple's first foldable, iPhone Duo, went on sale on October 23, 2026, and every iPhone game on the App Store now runs on it, whether the developer planned for it or not. For Unity studios the work is less about the hinge and more about something older: your game's window can now change size and aspect ratio in the middle of a match. This guide covers what Unity has observed on the iPhone Duo simulator, what Apple asks for, and a practical checklist for getting a Unity mobile game ready before the April 2027 deadlines.
▶ Watch the video version (about 4 minutes):
What actually changed for games
iPhone Duo has a compact outer display and a large inner display. Unity's engineers describe the inner screen as close to 4:3, close to an iPad, while most phone games are designed around roughly 20:9 (Unity Discussions). When a player opens or closes the phone, the game moves between the two displays. On the inner display a game can also run side by side with another app, and Unity notes there is no way to opt out of that.
Apple's Prepare for iPhone Duo page sums up the risk: apps built with the iOS 27 SDK and later resize dynamically, and "hardcoded screen sizes, fixed orientations, and device assumptions can break layouts, leading to stretched, clipped, or misplaced content." For a Unity game that usually means three things:
Screen.widthandScreen.heightare no longer fixed for a session.- The safe area is different on each display, and not symmetric.
- On the inner display, iOS treats your game much like an iPad app.
The dates matter too. Apple opened iPhone Duo submissions on October 5 and says that from April 2027 every app or game submitted must include iPhone Duo screenshots. Unity also expects Apple to require the iOS 27 SDK for all submissions by late April 2027, in line with previous years.
How the SDK you build with changes the result
You do not need to do anything for your game to launch on iPhone Duo. What you get depends on the Xcode SDK used to build it. Apple describes three tiers, and Unity's team tested each on the simulator:
| Built with | What players see (per Apple and Unity) |
|---|---|
| iOS 26 SDK or earlier | "Full legacy mode": the window keeps a normal iPhone size, black space around it |
| iOS 27.0 SDK | "Partial legacy mode": window 240 px shorter on one side, black bar; runtime orientation changes don't work |
| iOS 27.1 SDK or later | Fills the whole display on both screens; the game must handle resizing |
The middle row is the one to avoid. With SDK 27.0, Unity observed that orientation is locked to what is set in the Xcode project and that forcing an orientation at runtime does nothing. If your game switches between portrait menus and landscape gameplay, that is a real bug, not a cosmetic one. Apple's advice is to recompile with Xcode 27.1, which adds iPhone Duo development support.
The "Requires Full Screen" setting is no longer an escape hatch
Many Unity mobile games tick Requires Full Screen in iOS Player Settings to avoid iPad multitasking. That checkbox maps to Apple's UIRequiresFullScreen key, which Apple deprecated in iPadOS 26. Unity's post explains what it still does on iPhone Duo with SDK 27.1:
- Disabled: on the inner display the game rotates freely and fills the screen; runtime orientation changes do not work there. Side by side, it fills half the screen.
- Enabled: the game keeps its allowed orientations and runtime changes work, but if the player rotates the phone to an orientation you don't allow, iOS draws black letterboxing around the game.
On the outer display both settings behave like a normal iPhone. Unity's warning is the key point: because the key is deprecated, Apple can change its behaviour without notice. Treat it as a temporary bridge, not a design decision. The same post notes that on iPadOS 27 every Unity game built with SDK 27 is opted into Split View and Stage Manager resizing, with no exemption announced for games, so the work you do for the Duo also fixes iPad.
Handle resolution changes mid-session
The good news from Unity: the rendered view adapts to the new window size automatically, and both uGUI and UI Toolkit support layouts that react to size changes. The bad news is everything your own code caches. Typical offenders in our projects are:
- Camera viewport rects or orthographic sizes computed once in
Start(). - Render textures sized from the screen (minimaps, outlines, UI blur).
- Virtual joystick zones and swipe thresholds stored in pixels.
- Canvas Scaler set to "Match Width" only, which looks fine on 20:9 and squeezes the HUD on 4:3.
Unity's guidance is simple: screen width and height update in real time with the window, so poll them and rebuild whatever depends on them. A small component that watches both size and safe area covers most cases:
using UnityEngine;
public class SafeAreaFitter : MonoBehaviour
{
RectTransform rt; Rect lastSafe; Vector2Int lastSize;
void Awake() { rt = GetComponent<RectTransform>(); Apply(); }
void Update()
{
if (Screen.safeArea != lastSafe ||
Screen.width != lastSize.x || Screen.height != lastSize.y)
Apply();
}
void Apply()
{
lastSafe = Screen.safeArea;
lastSize = new Vector2Int(Screen.width, Screen.height);
Vector2 min = lastSafe.position, max = lastSafe.position + lastSafe.size;
min.x /= Screen.width; min.y /= Screen.height;
max.x /= Screen.width; max.y /= Screen.height;
rt.anchorMin = min; rt.anchorMax = max;
}
}
Put it on a full-screen panel under your Canvas and parent the HUD to it. Fire the same "size changed" event to cameras, render textures and input zones rather than giving each its own check. For the Canvas Scaler, a "Match" value around 0.5, or switching the match value by aspect ratio, keeps buttons readable on both a tall outer screen and a nearly square inner one.
If a scene really cannot adapt (a fixed-board puzzle, a pixel-art game), Unity suggests adding your own letterbox or pillarbox inside the app so the aspect ratio stays fixed. Put artwork in the bars instead of plain black; it looks deliberate.
Safe areas, the camera side and the fold
On the outer display the safe area excludes the home bar at the bottom and the side with the selfie camera, where native apps place their vertical toolbars. On the inner display only the bottom is excluded. Unity reports the new safe area out of the box through
