Written from the Mac, which connects to the PC. The PC's link to the Mac reports the mirror of them, naming the Mac.

Both ends notice a dead link within a few seconds. The PC enforces a 2.5-second read timeout and the Mac pings at least once a second while idle, so the PC is back to waiting for the Mac within about three seconds; the Mac notices in about two and takes its input back.

The Mac always fails open. A dropped connection, a missing acknowledgement, a crashed capture worker or a full event queue returns input to the Mac at once. A watchdog runs for as long as a socket exists, so a half-open connection is caught and the Mac reconnects even if you never switched. Trying to switch while the link is down beeps and posts a notification.

Push the pointer at the outer edge and it does not move: the push builds as pressure, the edge lights up, the trackpad ticks at each quarter, and once you have pushed far enough the boundary gives. The resistance is the point. An edge that switches the instant you touch it does so every time you overshoot a close button. The default is 120 points; zero switches on contact.

Any combination can be on, except Edge and Part of the edge, which exclude each other. On the Mac, shortcut and the right-hand edge are on to start with.

• The notch has no pixels to light, so a push there draws on the notch itself. Outline, the default, runs a comet of light round a small tab under the notch that brightens and speeds up with the push. Island springs a black island out of the notch with a four-segment meter; with Reduce Motion on it stays one size and fades with the push.
• An edge counts wherever no display of the same machine lies beyond it, so an edge between two displays behaves as the system intends, and the edge of a MacBook under a wider external display still crosses.
• The pointer arrives where it left: 42% of the way down the Mac's right edge is 42% of the way down the PC's left edge, on whichever monitor owns it.
• Crossing never fires while a mouse button is held, because a drag that reaches the edge is a drag.
• It suspends itself while a full-screen app has focus. Pause crossing in the Mac's menu bar puts it away until you resume it or restart Beamer.
• Only one machine's input is on the other at a time. While the Mac drives the PC, pushing the PC's own mouse through the edge sends the Mac's input home and takes the PC's mouse across behind it.
• Either machine's own switch, the menu item or the trigger key, sends the other's input home, so a way back never depends on the edge alone. The PC's edge facing the Mac leads home even when the Mac has only its shortcut on.
• Switching to a PC that is asleep sends wake-on-LAN. The PC's hardware address is read from the Mac's ARP table after a successful connection, never typed.

Each machine's menu has one tick per direction: This Mac drives Windows and Windows drives this Mac on the Mac, Mac drives this PC and This PC drives the Mac in the Windows tray. Turning one off stops that direction only.

Mac modifiers map to Windows by meaning, so the shortcuts your fingers know keep working. The Mac's Keyboard page can switch this to positional, where Cmd sends the Windows key.

So Cmd+C, Cmd+V, Cmd+Z and Cmd+T are copy, paste, undo and new tab, Ctrl+E opens Explorer and Ctrl on its own opens Start. The PC's keys arrive on the Mac the reverse way. Chords with Ctrl, Alt or Windows held are sent as real virtual-key presses, so they land on the right key for the active Windows keyboard layout. The Mac reads its own layout too, so on a German or French Mac Cmd+Z is still undo and Cmd+A still selects all, and a letter typed from the PC lands on the key that types it. When the two machines are on layouts of different alphabets, say the PC on Russian and the Mac on English, a letter types what the receiving machine's own layout has on that key, as its own keyboard would, and shortcuts keep working. The key_map object in each app's config JSON can still override single keys.

The trigger key is never forwarded. On both machines it is recorded by pressing it: Right Option on the Mac and Right Ctrl on the PC to start with. Either can double-tap or hold.

The stays-here list is per machine, because a Mac keycode and a Windows virtual key are different numbers for the same key. It takes keys, the right, middle, back and forward mouse buttons, and on the Mac its media keys. A listed press stays on the machine it was pressed on while input is away; its release goes wherever its press went, so nothing is ever left held down on the far side. The trigger key cannot be added.

The Mac's F7–F12 media row and volume keys forward to the PC as play/pause, next, previous, mute and volume. On the Mac they arrive as system events rather than key events and are captured separately (mac_app/media_keys.py). Brightness and keyboard-backlight keys stay with macOS, since Windows has no equivalent.

Ctrl+Alt+Del is the Secure Attention Sequence, trapped by the kernel before any app sees it. SendInput cannot produce it, and SendSAS() needs a Windows service or a signed uiAccess app installed under Program Files, which Beamer is not.

Trackpad scrolling is smooth and horizontal scrolling works on Windows. While input is on the PC, the Mac's system gestures do the equivalent thing there and nothing on the Mac:

The Mac classifies a system gesture when it ends and sends one message. The PC replays it as a real swipe through a synthetic Precision Touchpad, so Windows' own touchpad settings apply and Task View animates as it would under fingers. Where Windows refuses that device, it presses the shortcut with the same default meaning instead (Win+Tab, Win+D, Win+Ctrl+Left/Right, Win). Direction comes from private macOS event fields, keyed by macOS major version in mac_app/gestures.py, because the horizontal sign has flipped between releases.

The clipboard moves at the moment of a switch, ahead of the switch itself: switching from the Mac carries the Mac's clipboard to the PC, and switching back carries the PC's to the Mac. Where it holds both an image and text, both cross and the pasting app picks. The caps keep the switch prompt: 256KB of text and an 8MB image as PNG. Over a cap, that half is left alone rather than truncated. The PC converts to and from the Windows clipboard's DIB format itself, using the Qt it already ships. A switch sends the clipboard only when it has changed since it last crossed, so a large image is not re-sent every time.

If both machines are on Wi-Fi, every event crosses the air twice, Mac to access point to PC. Ethernet on either machine removes a hop. Where Wi-Fi is unavoidable, 5GHz or 6GHz and turning off power saving on the PC's adapter both help.

Beamer sends every event at once (TCP_NODELAY). Acknowledgements are coalesced over 15ms so a 100Hz stream of moves cannot double the packet count, with an idle heartbeat every 400ms. The Mac's settings show the measured round trip while input is on the PC.

Both apps derive a key from the shared token with HKDF-SHA256 and seal every frame with ChaCha20-Poly1305. The token is never sent. Pairing agrees a token with CPace, a password-authenticated key exchange over X25519, from the six-digit code, so nothing sent while pairing can be tested against a list of codes. What that does and does not protect against is in SECURITY.md.

Once a day, and at start, Beamer asks GitHub's public releases API for the latest release of this repository and compares its version with its own. A new minor or major version is always offered; a patch release (1.4.0 to 1.4.1) only when its release notes ask for it, so a run of small fixes does not nag. Drafts and pre-releases never count and nothing is downloaded. When a newer one is out, the menu says Beamer X is available and Overview offers a Download button that opens the release page. The request is an ordinary HTTPS request, so GitHub sees the address it came from, as it would for a browser. Switch it off with Check for updates on Overview.

The installer puts Beamer in %LOCALAPPDATA%\Beamer for the current user with a Start menu shortcut. Quit Beamer from the tray before installing a newer version over it; only one instance runs at a time.

Beamer runs elevated (its exe carries a requireAdministrator manifest), because Windows silently drops input from a non-elevated app aimed at an elevated window such as an admin PowerShell. Start Beamer when you sign in, on Overview, writes and removes an elevated Beamer logon task; nothing else touches autostart.

Beamer needs two inbound rules on Private networks: TCP 24820 for input and UDP 24821 for pairing, both below the range Windows and macOS hand out for themselves. The app adds them on its first elevated start. Connection says in one sentence whether the Mac can get in and offers one button for whichever of three things usually stops it: the rule is missing (it adds it), Cancel was pressed on Windows' own "allow this app" prompt, which writes a block rule that beats any allow rule (it removes the block and adds the rule), or the network is classed as public (it marks the network private rather than opening the port on every public network).

The lock screen. No elevation lets an app type there: it is the Winlogon secure desktop, which admits only SYSTEM. On a PC with the author's separate unlock credential provider installed (not part of this repository), switching to a locked PC signals that provider, which unlocks it in about four seconds; input sent meanwhile is dropped. Beamer only signals the provider and never holds a password. Without it, the Mac reports Windows is locked — unlock it at the PC.

On the Mac, double-click mac_app/Install-Beamer-Mac.command. It builds a self-contained app, installs it at /Applications/Beamer.app, and leaves it closed so the permission prompts do not appear unexpectedly.

On Windows, run win_app\Install-Beamer.ps1 from an admin PowerShell. It builds and installs %LOCALAPPDATA%\Beamer\Beamer.exe, adds a Start menu shortcut and the two firewall rules. From a non-admin PowerShell it still installs but skips the rules, which the app adds on its first elevated start.

Pairing is the easy path, not the only one: each Connection page still takes an address, port and shared token typed by hand, and they must match on both machines.

From mac_app:

.venv/bin/python3 -m unittest discover -s tests -v
./build_dmg.sh

From win_app:

python -m unittest discover -s tests -v
.\build_win_app.ps1

A local Mac build is signed with the release's Developer ID identity when the login keychain can reach it, so privacy grants carry between local builds and releases, and ad-hoc otherwise (over SSH), under the hardened runtime either way. It is not notarised.

Files shared by both apps (receiver.py, return_edge.py, pairing.py, ignored.py, tokens.py and others) are byte-identical copies, because each app bundles only what sits under it; a test fails if a pair drifts. Beamer.svg is the master of the mark, and Beamer.ico, Beamer.png and Beamer.icns are rendered from it.

The version lives once, in VERSION at the repository root; the Mac build number is the commit count. Change VERSION, commit, then build each platform from that commit. Both commands refuse uncommitted changes outside docs/, upload nothing except the Mac's notary submissions, and write to docs/beamer-releases/<version>/ in the folder that contains the repository.

On the Mac, from mac_app, in a desktop session (the keychain will not release a Developer ID identity over SSH):

./build_dmg.sh --release

It signs every nested binary with Developer ID under the hardened runtime with a secure timestamp, checks the bundle still runs, notarises and staples the app, then the DMG, and checks both with stapler validate and spctl. Notarisation uses the App Store Connect API key named in ~/.appstoreconnect/key_id.

On Windows, from win_app:

.\build_win_app.ps1 -Release

It runs the tests, builds Beamer.exe and compiles Beamer-Setup.iss with Inno Setup 6 into Beamer-Setup-<version>.exe. The installer adds no firewall rules and leaves autostart off.