Apple’s folding iPhone, simulated.
Build apps for it.
Hold it. Fold it. Build for it.
Drag to turn. Use the slider to fold. Tap an icon to open an app.
01 · Not a mockup
It looks like a concept.
It behaves like a device.
Every pose, button and gesture below is the shell itself, driven by the same code the desktop app runs.
Fold it.
The inner display hands over to the cover as the hinge closes.
Close it mid-song.
Playback continues on the cover. Nothing remounts.
Take a screenshot.
Side button and volume up, like the phone in your pocket.
Drag an app into split screen.
Swipe up from the home bar and hold: the app becomes a card. Drop it on a half and open the next one beside it.
Or pause, and let go.
Every running app is a card. Tap one to bring it back, flick one up to quit it.
Stack two icons.
Hold an icon on the home screen, carry it onto another, let go: a folder. Hold one inside to take it out again.
Hold the wallpaper.
Apple’s dune, a few gradients, and any shot the Camera took. Both displays change at once.
02 · Real hardware
The simulated phone
can use your real camera.
On the desktop it is your Mac camera, or your iPhone over Continuity Camera. Here it is your webcam.
Your browser is asking for the camera. The picture goes to the phone on this page and nowhere else. Nothing is recorded or uploaded.
03 · The twist
And then we gave it
an App Store.
Apps install into their own isolated runtime, keep their own storage, and update on their own.
04 · The core idea
The fold is not a breakpoint.
It is input.
Most responsive software asks one question: how wide is the screen? Duo also asks what shape the device is in right now, and tells your app every time that changes.
1const { display, angle, width, height } = useDisplay()23if (display === 'cover') return <PocketCard />4if (angle < 150) return <Workspace angle={angle} />5return <Board width={width} height={height} />
Apps hear about the display in use, their placement on it, its size and the hinge angle, every time one changes. The buttons and sensors are events too, in the SDK.
05 · SDK
Four primitives.
That is the whole surface.
Enough to build a real app, small enough to read in a minute. The rest is React and the platform you already know. Read the SDK page for the full client.
- Display
- useDisplay()
- Which display, its size, the hinge angle and focus, live.
- Storage
- useKV()
- Durable, revisioned storage, private to each app.
- Views
- os.commands
- Two views of one app, one owner; the rest send it commands.
- Links
- os.open()
- Hand off to another app on the device, with an argument.
06 · The apps
Built for both displays
and the fold between them.
Official apps ship in the simulator and publish to the Duo catalog; community apps arrive as pull requests. Every one is MIT licensed and installs through the Store.
07 · Open
The platform is open.
So are the apps.
Someone in Berlin can build a calculator, open a pull request, and after review it can appear in the Duo Store for everyone.
- Apps live in the repository.
- Every app is MIT licensed.
- Contributions are pull requests.
- No developer account. No payments. No gatekeeping.
fork→pull request→review→Duo Store
Build something strange
for a phone that folds.
Duo is an open experiment in what foldable software could become.