TwinDesk is free and has no paid Apple Developer ID or Windows code-signing certificate, so macOS and Windows don't know who made it and ask once before opening it. The source is all here.

🍎 macOS

The easiest way is Homebrew, which installs it ready to open: brew install --cask inukaasith/twindesk/twindesk

From the .dmg instead:

1. Drag TwinDesk into Applications and open it. macOS says it can't verify TwinDesk: click Done (not Move to Bin).
2. Open System Settings › Privacy & Security, scroll down to Security and click Open Anyway next to "TwinDesk was blocked". Enter your password, then click Open Anyway again.

You do this once; updates open normally. If macOS says TwinDesk is damaged and can't be opened, it isn't: run this in Terminal, then open it again:

xattr -dr com.apple.quarantine /Applications/TwinDesk.app

🪟 Windows

1. If the browser warns that the file isn't commonly downloaded, choose Keep (in Edge: ⋯ › Keep › Show more › Keep anyway).
2. When the installer shows Windows protected your PC (SmartScreen), click More info, then Run anyway.

On Windows 11 with Smart App Control on, unsigned apps are blocked with no Run anyway button. The only way past it is turning it off (Windows Security › App & browser control › Smart App Control settings), and on many Windows 11 versions it can't be turned back on without reinstalling Windows.

🤖 Android

1. Open the downloaded .apk. Android asks to allow your browser or Files app to install unknown apps: tap Settings, turn on Allow from this source, go back and tap Install.
2. If Play Protect warns about an unrecognised developer, tap More details › Install anyway.

The full app (notifications, texts and Accessibility) is easiest installed by the computer over wireless debugging (Phone page › Notifications from the phone): Android then lets you turn those on. Installed by hand, Play Protect may block it, and Android 13 and later grey out notification access and Accessibility as a restricted setting: open Settings › Apps › TwinDesk, tap ⋮ › Allow restricted settings, then turn them on.

• Off until you turn it on, one switch for the pair. Until then nothing is read and nothing is asked.
• A document's path never leaves the device. Only its name and size do, and the file goes only to the side that asked for it.
• Edit shares only that one file (and the lock and temporary files the app makes beside it), over WebDAV inside TLS with the session's own certificate and a secret path. It's unmounted when the session ends.
• Preview copies live in a cache folder that's emptied when TwinDesk quits.
• Only http and https addresses are ever opened.
• Allowlists: every app ReZume has met is listed with a switch, how often it was sent and when. New apps can start allowed or blocked.

The full design is in docs/rezume.md.

Why. Until 2.5 every mouse move rode the same TLS-over-TCP stream as everything else. On Wi-Fi, one lost packet holds back every byte behind it until it's resent (head-of-line blocking), so the pointer stuttered for 20–300 ms whenever the air got busy or a file was on its way. On top of that, each move was turned into JSON in the helper, parsed by Node, and garbage-collected.

The lane. When both sides have 2.5, the session negotiates a UDP lane next to it (il: {v: 1} in hello and welcome). Each move is one small authenticated packet:

'T''L' | ver | type | seq u64 | AES-256-GCM(body) | 16-byte tag
MOVE: route, move number, last event number, running total x, y

• Exact under loss. Each MOVE carries the running total, not a delta, so a lost packet costs nothing: the next one puts the pointer exactly where it belongs. The last move is sent again at +8 ms and +24 ms so the pointer always lands where you stopped.
• Clicks never overtake moves. Clicks and keys are numbered, fenced to the moves before them and sent on both the lane and the reliable session; the receiver applies them in order, exactly once.
• Secure. Per-session keys from HKDF-SHA256, AES-256-GCM, a 64-packet replay window as in WireGuard. Anything that doesn't authenticate is dropped.
• Follows you. The peer's address is the last authenticated packet's, so the lane follows a switch between Wi-Fi and cable.
• Prioritised. Voice-class DSCP marking (a qWAVE flow on Windows), and Windows' Wi-Fi low-latency mode while you drive.

Native. native/tdfast (Rust, C ABI) is linked into the Swift helper on the Mac, the C helper on Linux and loaded by the C# helper on Windows. Moves go from the input hook to the socket and from the socket into the OS's input without touching JavaScript. The helpers, Node's fallback lane, Multi-device and the Android app allocate nothing per move, and the Windows helper runs with the sustained-low-latency GC mode.

Fallback. No lane (an older app, Bluetooth, UDP blocked) means input stays on the session exactly as before. General › Advanced › Input protocol lets you pick UDP (tdv2), the default, or TCP (tdv1). The old and new protocols side by side: docs/protocol.md.

• Its own process. A "TwinDesk Files" utility process runs its own HTTPS server, so reading, hashing and writing never block the window, the clipboard or input.
• Parallel ranges. A large file is fetched as several byte ranges at once.
• Verified while streaming. Every range is hashed on the way and the hashes travel with file.end, so a received file is checked without being read again.
• Small files fast. Up to 16 files in flight, asynchronous writes with backpressure on every receiver, and no O(n²) queue scans.
• Hardened. A file stops at the size it was offered with, a full disk fails cleanly, and a sender can't choose the name of a temporary file.
• Negotiated as fx2 in hello and welcome. An early failure falls back to the previous HTTPS path, then to chunks on the session. Bluetooth, Wi-Fi Direct and older apps keep working.

Turn it on in the Multi-device page, and off again any time with everything as you left it. Connecting just two devices? You won't need it. Still coming to Mesh: the Camera, ReZume, pictures on the clipboard, and files dragged to more than one device at a time. The phone connects to one computer at a time, and Linux joins over the same Wi-Fi only. Mesh uses the tdv2 lane in Node. See docs/mesh.md.

Who can turn up over Bluetooth is up to you: Bluetooth with phones (on) and Bluetooth with computers (off until you want it), on the Connection page.

On Linux, TwinDesk runs on both X11 and Wayland. On Wayland, the mouse and keyboard go through evdev and uinput (the Setup screen grants access once), screens are captured through the desktop portal, and the clipboard goes through wl-clipboard. A few things work a little differently:

• Input access on Wayland. Reading /dev/input means reading every key typed, so it goes to TwinDesk's helper alone: Setup's Fix installs a setgid input copy of the helper (the NixOS module a wrapper) and never adds your account to the input group. General › Input access › Remove undoes it. Details and the manual undo are in docs/nixos.md.

• Shared folder. Sharing uses Samba. The first time, one password prompt installs it if it's missing and adds a network-only account. The other computer's folder is connected with GVFS and shows in the file manager's sidebar.

• Copy and paste files. Ctrl+Alt+C copies what's selected in the file manager in front (or files you already copied), and Ctrl+Alt+V pastes into the file manager window in front (else Downloads). Right-click › Send to works in Nautilus, Nemo, Caja, Dolphin and Thunar.

• Dragging files across the edge. Files dragged in from the other computer are dropped into the folder under the pointer, or the desktop. On Wayland, they go to the file manager window in front. Dragging files out of Linux needs an Xorg session.

• Extend. On GNOME (Wayland) it uses Mutter's own virtual monitor; pick "Virtual remote monitor" when the desktop asks which screen to share. On X11 it switches on a spare output of the graphics driver (not available on NVIDIA's driver). That needs a small helper, which the .deb installs; with the AppImage, Share screen › TwinDesk virtual display › Install puts it in once, with your password.

• Apps and ReZume windows. Opening this computer's apps on the other side needs an Xorg session.

• Virtual camera and gamepad. TwinDesk Camera is a v4l2loopback device, and Real gamepad a uinput controller ("TwinDesk Gamepad"); each asks for your password once, the first time it's turned on.

• Bluetooth and Wi-Fi Direct. Bluetooth LE goes through BlueZ, and direct Wi-Fi links through NetworkManager, hosted beside the computer's own Wi-Fi where the adapter allows (2.4 GHz groups for a phone).

• The input lane. If firewalld blocks inbound UDP, the tdv2 lane never comes up and input stays on the session, as in 2.4.

• Android phone. Everything in Android works on Linux too. The package carries adb; the Setup screen's firewall fix opens mDNS (5353/udp) so the phone's wireless debugging is found.

Install TwinDesk on the phone, open it next to TwinDesk on the computer and pair from Connect › Nearby, or scan the computer's QR code. The phone needs Android 10, and Android 11 for everything that goes through wireless debugging.

The phone app

Tabs at the bottom on a phone (Overview, Connect, Screen, Files, More), a sidebar on a tablet. Every page names the computer it's connected to:

And outside the app:

• Share sheet: Send to computer, Copy to computer and Open on computer in every app's Share menu.
• Quick Settings tiles: Send clipboard and Wireless debugging.
• The ongoing notification shows what's connected, with Exit.
• The computer can install the full app over wireless debugging (Phone page › Notifications from the phone): Play Protect blocks downloaded apps that read notifications or texts, or use Accessibility, so the download leaves those out and the computer adds them. Settings and pairing stay.

Wireless debugging

Files, the clipboard and notifications work right away. The phone's screen, its apps in windows, touch, your mouse and keyboard on the phone and its sound go through wireless debugging, which TwinDesk pairs with once:

• Until it's paired, a card on Connect (on the computer and on the phone) walks you through it. Open Developer options › Wireless debugging › Pair device with pairing code on the phone and type the 6-digit code on the computer, or on the phone in TwinDesk's notification.
• After that TwinDesk switches wireless debugging on by itself when it needs it, follows it to its new port every time it restarts, and keeps the pairing from expiring. Phones that switch it off on every Wi-Fi change or screen lock (MIUI, HyperOS) get it switched back on as soon as they're unlocked. Wireless debugging only runs while USB debugging is on too, so TwinDesk turns both on.
• Xiaomi, Redmi and POCO also need Developer options › USB debugging (Security settings) for touch, mouse and keyboard. Without it the screen shows but input is refused.
• Limited control works without wireless debugging, through TwinDesk's Accessibility in the full app.
• On a Mac, the phone in Finder. Turn it on in the Mount page and click Mount: the phone shows under Locations like any server.

Each computer runs an Electron app, which handles the window, pairing, the link and the state machines. Next to it runs a small native helper for everything the OS keeps to itself: capturing and injecting input, virtual displays, gestures, window capture and native drag and drop. Inside each helper, tdfast (Rust) runs the tdv2 input lane.

The link between two devices is one TLS session wherever it runs: on the local network, through a phone's USB cable (adb), or through Bluetooth LE (a GATT pipe of TwinDesk's own, shared/blepipe.js). When a session on Bluetooth needs bandwidth, shared/netlink.js brings up a Wi-Fi Direct group or joins a phone's hotspot, moves the session onto it, and takes it down again once nothing needs it.

Beside the session run the tdv2 UDP lane for input (shared/inputlane.js, native/tdfast), fx2 for files (shared/fx2-engine.js in its own utility process) and WebRTC for screens, cameras and sound. Each is negotiated in hello and welcome and falls back by itself.

Ports: TCP 47800 (the session and files), UDP 47801 (discovery), and the input lane and fx2 on ports the two sides agree on per session.

You need Node.js 18+ on every platform, and Rust for the native input lane (without cargo the helpers build without it and Node's lane is used).

macOS (13 Ventura or later)

xcode-select --install          # Swift compiler for the helper
rustup target add aarch64-apple-darwin x86_64-apple-darwin
cd mac
npm install
npm run build:helper
npm start                       # run from source
npm run dist && npm run dmg     # build TwinDesk.app and TwinDesk-<version>-<arch>.dmg in mac/dist/

The disk image is named after the app inside it: TwinDesk-2.5.0-arm64.dmg for Apple Silicon, TwinDesk-2.5.0-x64.dmg for Intel. Keep arm64 and x64 in the names on a release: the in-app updater picks the one for each Mac by them. npm run dist:x64 && npm run dmg (or npm run dmg:intel) builds the Intel app from an Apple Silicon Mac, cross-compiling the helpers and tdfast.

On first launch, TwinDesk asks for Screen Recording, Accessibility and Input Monitoring (once; after that the General page shows each permission's status).

npm run dist signs the app with a certificate of its own, made the first time in ~/.twindesk-signing (keep a backup). macOS keeps permissions per signature, so with the same certificate they carry over when an update is dragged into Applications.

Windows 10 / 11

cd windows
npm install
npm run build:helper            :: .NET Framework's csc.exe, and tdfast.dll with cargo
npm start
npm run dist                    :: NSIS installer in windows\dist\
npm run dist -- arm64           :: the Windows on ARM installer (or `x64 arm64` for both)

For the arm64 lane, rustup target add aarch64-pc-windows-msvc. The installer adds the firewall rules (for every network profile, and one for the helper's input lane). The Setup screen, shown once, offers to fix the firewall if something changed and to install the optional Virtual Display Driver for Extend.

Linux (X11 or Wayland)

sudo apt install build-essential libx11-dev libxi-dev libxtst-dev libxext-dev libxrandr-dev libxfixes-dev
cd linux
npm install
npm run build:helper
npm start
npm run dist                    # AppImage and .deb in linux/dist/

The Setup screen walks you through the rest. On Wayland that means input access (one admin prompt, then log out and back in once). Extend on GNOME Wayland uses Python 3 with GObject and GStreamer's PipeWire plugin (python3-gi, gstreamer1.0-pipewire), which GNOME desktops already have.

NixOS & Nix Flakes

TwinDesk includes a flake.nix with package, dev shell, and NixOS module support:

nix run github:InukaAsith/TwinDesk   # run directly
nix develop                           # development environment

{
  programs.twindesk = {
    enable = true;
    user = "yourusername"; # adds to input/uinput groups for Wayland KVM
  };
}

See docs/nixos.md for full options (firewall, Wi-Fi Direct capability wrappers, virtual displays, and more).

Testing the Linux app from a Mac

linux/scripts/vm-test.sh runs it in a Parallels Desktop Linux VM: it copies this checkout into the VM, builds the helper, starts TwinDesk in the VM's desktop session and drives it from the Mac.

linux/scripts/vm-test.sh start            # sync, build and (re)start it in the VM
linux/scripts/vm-test.sh shot linux.png   # screenshot of its window
linux/scripts/vm-test.sh log

Android

cd android
./gradlew assembleRelease        # JDK 17+; app/build/outputs/apk/{standard,full}/release/

standard is the build people download. full adds notification access, the SMS permissions (Messages) and the Accessibility service, which Play Protect blocks in downloaded apps; the computers install it over wireless debugging, so npm run dist on each platform bundles the newest android/dist/*-full.apk.

GitHub Actions

Build Android, Build Linux, Build Windows and Build AUR (Actions tab › Run workflow) make the standard and full APKs, the AppImage and .deb, the x64 and arm64 installers with the native lane, and the Arch package. Set the ANDROID_KEYSTORE secret to the key the Android app is signed with (base64 -i ~/.android/debug.keystore): the APKs then install over existing ones, and the Linux and Windows builds carry the full Android app.

To Authenticode-sign the Windows installers, set WIN_CSC_LINK to a base64-encoded code-signing .pfx and WIN_CSC_KEY_PASSWORD to its password. When WIN_CSC_LINK is set, the build fails if signing can't complete instead of publishing an unsigned installer.