The short version
- If the call panel says via server, the call takes a detour through the server: try another network.
- On a Mac on Wi-Fi, turn off AWDL for the session, or use an Ethernet cable.
- Share at 2560 px and 60 fps, the defaults.
- On a slow connection, ask for a smaller picture under View › Picture Size.
- Far apart, the round trip sets the floor: no setting gets under it.
Where the time goes
Between something changing on the shared Mac and the other person seeing it, the screen is captured, encoded, sent, decoded and shown. When they drive, their keys and clicks cross the network the other way first, so what they feel is a whole round trip, plus what the apps add.
Doubles measures what it adds by sharing a test pattern with its capture time stamped into the pixels and decoding it again, both in one process on one Mac, so there's no network in it and no clocks to disagree. On an M2 Pro, in an optimized build, on 19 Nov 2026, from capture to a decoded frame (median times, two runs of each):
- 2560×1600 at 60 fps: 14 ms.
- 2560×1600 at 30 fps: 14 ms.
- 2560×1664 at 60 fps, as a 14-inch MacBook Pro shares: 14 ms.
- 2560×1600 with WebRTC's own encoder in place of Doubles': 23 ms at 30 fps and 39 ms at 60 fps.
An earlier run, in a debug build on 19 Oct 2026, measured other sizes: 1920×1200 at 60 fps took 12 ms, against 13 ms for 2560×1600 in that run, and 3456×2234 took 28 ms, at about 30 fps, the encoder's limit. And in Doubles' link test, which sends every packet through a proxy on the same Mac, with someone typing at 2560×1664 and 60 fps, capture to decoded frame took 15 ms (the median, over three runs).
On top of the self-test's figures come half the network's round trip, and showing the frame: one refresh of the display. To keep its own part small, Doubles encodes with the Mac's hardware H.264 encoder in its low-latency mode, which hands over each frame as soon as it's compressed, and every Mac and browser in the call shows each frame as soon as it's decoded, without holding it to smooth out jitter. Pointers travel apart from the picture, so a lost packet never holds them up.
Direct, or via server
At the foot of the call panel, a line such as “13 ms · 2560×1600 · 60 fps · 21 Mb/s · direct” says how the screen you're watching, or your own share, is getting across: the round trip to the other end, the picture's size and frame rate, the bit rate, and the route.
direct means the call goes straight between you, which it does whenever the network allows. via server means it goes through the Doubles server's relay, which adds the trip to the server and back. The relay forwards what it can't decrypt (see how calls are encrypted), for networks where a direct connection isn't possible. If you see via server, the networks between you didn't allow a direct connection; from another network, they may.
Wi-Fi, and the radio that interrupts it
On Wi-Fi, the radio that AirDrop, Handoff and Universal Control use (AWDL) takes a Mac off its Wi-Fi channel about once a second, adding 40 to 150 ms each time. To stop it on a Mac until the Mac restarts:
$ sudo ifconfig awdl0 down
And to turn it back on:
$ sudo ifconfig awdl0 up
AirDrop, Handoff and Universal Control use that radio, so they may not work while it's off. An Ethernet cable avoids Wi-Fi altogether.
On the same network
Between two Macs on one network, the network can carry far more than a shared screen usually needs. But WebRTC sends a shared screen at its estimate of the bandwidth, and that stays near what the screen has needed so far: about 5 Mbit/s on Wi-Fi, where mostly a few lines change. A big change, such as a window switch or a scroll, then waits to go out, and the picture freezes for a third of a second or more.
So when the path goes straight from one Mac's own address to the other's, both on one network and not through a VPN, and its round trip is 15 ms or less, Doubles keeps that estimate at 15 Mbit/s or more, split between the people watching. In Doubles' link test, with Wi-Fi stalls, window switches froze the picture for 2 seconds in 45 before this, and not at all after. On a network that can't carry it, the round trip rises or packets are lost while a lot goes out, and the link falls back to the usual 1 Mbit/s floor for a minute or more.
Far apart
Across the world, the round trip is most of the delay. Canada to India is about 290 ms, so what you type on someone's Mac shows on your screen about a third of a second later, and no app can make that shorter. What Doubles adds on such a path, it keeps small:
- Lost packets. Between Macs, Doubles adds error correction (FlexFEC) while packets are being lost, so the Mac watching rebuilds most lost video packets instead of asking for them again, which would freeze the picture for a round trip each time. Bursts of loss still freeze it now and then, and the repair packets take some of the bandwidth, so text is a little softer while packets are being lost. Browsers, and Macs on older versions of Doubles, don't use it.
- Wi-Fi stalls. While you share, the bandwidth estimate stays at 1 Mbit/s or more, split between the people watching, so a stall can't sink it to what typing needs and leave the next window switch blurry for seconds. A connection that can't carry 1 Mbit/s, such as hotel Wi-Fi or a phone's hotspot, loses that floor while it shows it can't, or everything would wait in its queue.
- Pointers. Pointer positions go on a channel of their own, which never resends a lost one, so they never queue up behind each other.
To see how a far call went, look at what a slow call leaves behind.
The size of your share
Keep shares at 2560 px, the default, or smaller: a bigger share takes longer to encode. In the earlier run above, 3456×2234 took 28 ms, at about 30 fps, and 1920×1200 took 12 ms. In Settings › Sharing, the pane says so too: native resolution keeps thin text sharp, at a little more latency; 60 fps has the lowest latency, and 30 fps is light on bandwidth.
Where a pixel or two is all it takes, Doubles also fits each frame to the encoder's blocks of 16 pixels: the encoder copies every frame of any other size first, about 2 ms a frame. So a 14-inch MacBook Pro's 3024×1964 goes out at 2560×1664, not 2560×1662, with at most a pixel of black to either side.
Someone watching on a slow connection can ask for a smaller picture instead: under View › Picture Size, or by Control-clicking the toolbar under the shared screen, choose 2560, 1920 or 1440 px. A smaller picture arrives sooner, and nobody else's picture changes.
Your voice
Doubles sends your voice in 10 ms packets rather than 20 ms ones, which halves the time each packet waits to fill, for a little more overhead.
Reduce background noise, in Settings › Calls, takes typing and other noise out of your microphone with Apple's voice isolation, and holds your voice back about 56 ms to do it. It's on unless you turn it off. Turned off, that delay goes, but so does what keeps the sound of your keys out of the call.
Wear headphones either way: on speakers, your microphone hears the others too, and your typing can get through while they talk. The rest of a session's setup is in how to pair program remotely on a Mac.
What a slow call leaves behind
A call keeps a record of how its shared screens travelled, to look into afterwards. While a screen is shared, Doubles writes a line every 10 seconds for each link and direction: the round trip, the bandwidth estimate, the frame rate, freezes, how long packets waited to go out, the biggest frame and the frames the encoder dropped. It names people by their ID in the call, not by name. The lines are in ~/Library/Logs/Doubles/call-quality.log, and in call-quality.1.log before it: the last 10 MB of them, 5 MB in each. They're in the log macOS keeps too:
$ /usr/bin/log show --last 1d --predicate 'subsystem == "dev.doubles"'
Start pairing in one click.
Sharp screen sharing, remote control only when you allow it, drawing and voice. Guests join from a browser.