NewDuo 0.2.0 is out

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.

app.tsx
1const { display, angle, width, height } = useDisplay()
2
3if (display === 'cover') return <PocketCard />
4if (angle < 150) return <Workspace angle={angle} />
5return <Board width={width} height={height} />
display
"inner"
angle
180
placement
"full"
width × height
790 × 850

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.

A product by Doan Labs