A throw looks like one motion, but Beam is really two things travelling at once: the gesture and the bytes. Each takes the route that suits it, and both are sealed before they leave your iPhone.
This is the plain version of what happens between your thumb and your Mac, written from Droppy's own code. If you only want to use Beam, the introduction is shorter. If you want to know where your photos go, read on.
The gesture travels as small, sealed live frames, so the Mac can show your items peeking in while your finger is still down. The bytes go straight to the Mac over your local network when it can be reached, and otherwise through Droppy Sync's encrypted path. The relay and the storage only ever see ciphertext.
Two halves of one throw
When you lift a stack on the Beam tab, Droppy for iPhone starts a throw session. From then on it sends the Mac a short series of messages about that throw: it began (with small previews of the first few items), where the stack is now, that you let go, how far the upload is, that everything is delivered. The Mac answers once with "landed", and says where the items went.
Those messages are the gesture half. They are tiny on purpose. A preview is a JPEG thumbnail with its longest side at 320 pixels, capped at 28 KB, and a throw carries previews for at most four items; the rest of the stack is a count. That is enough for the Mac to draw the real photos at its edge, and small enough to travel quickly on any connection.
The bytes half is the files themselves, and they travel separately, by the best route available.

The direct path: straight over your network
When your iPhone and Mac are on the same network, Droppy Sync keeps a direct, sealed connection between them. Beam uses it to skip the cloud entirely:
- The phone sends an offer: every file with its name, kind and size, plus any notes and links inline.
- Each file follows in order, in pieces of 512 KB, read off the phone's main thread one piece ahead of the send.
- The Mac writes each piece to disk as it comes and answers with an acknowledgement. The phone keeps at most eight pieces in flight, so a slow Mac never gets flooded.
- After the last piece, the phone sends the file's SHA-256, computed while it read the file. The Mac checks it. Only a verified file counts as arrived.
No blob storage, no sync record, no pull. To save time, the phone may even start the transfer before you let go; if you drop the stack back on the phone instead, the Mac throws away whatever arrived.
iOS needs your permission for this. The first time Droppy reaches for your Mac on the network, iPhone asks to allow Local Network access. If you said no, the Beam tab tells you so: "Turn on Local Network for Droppy, so Beam goes straight to your Mac over Wi-Fi." You can change it in the iPhone's Settings, Privacy and Security, Local Network.
The durable path: when you are not at home
Away from your Mac's network, Beam sends files the way Droppy Sync already moves every synced file. The phone seals each file with your library's record key, uploads the ciphertext to storage, and pushes a record: a file tray record for photos and files, a clipboard record for text and links. Then it tells the Mac which records belong to this throw. The Mac pulls exactly those, opens them, applies your Save files to choice and answers "landed".
This path is slower than a local hop, but it does not care where the two devices are. It is also the safety net for the direct path, so a throw never depends on a perfect Wi-Fi link.

The gesture over the relay
On the same network, the phone streams your finger's position to the Mac continuously, so the peek follows your thumb closely. Away from home, the gesture frames go through Droppy Sync's relay, which allows a limited number of messages per minute per connection, shared with everything else the phone sends. Beam is careful with that budget:
- Position is rounded to a coarse grid and sent at most once every 140 milliseconds, and only when it changed.
- Beam frames of any kind stay within 70 a minute from one device. Motion is the only kind that may be thinned; the frames that matter, began, released, delivered, always go.
- While you hold a stack still, the last position is repeated about once a second, so the Mac's peek does not go stale under a resting finger.
The result is a peek that moves in steps instead of gliding when you are away, and an arrival that plays exactly the same.
Sealed everywhere
Both halves are end to end encrypted with the keys of your pairing. Your Mac creates the library key and keeps it in its Keychain; it reaches your iPhone only inside the pairing code you scan and never reaches a server. Every frame and every file is sealed on the device before it is sent, so the relay and the storage only hold what they cannot read. The pairing handbook and privacy and data explain the key handling in more detail.
Diagnostics are careful too: Beam's logs on the iPhone record ids and timings only, never a file name or any text you threw.
Built to survive the real world
Phones lose their connection at the worst moment, so Beam assumes it will happen:
- A lost start. If the Mac receives a frame for a throw it never saw begin, it asks the phone once to send the start again, holds the frames it has for a moment, and replays them in order.
- A late frame. A frame for a throw that already finished is dropped, so a reordered message can never cause a second arrival.
- Several throws at once. Lift a second stack while the first is still uploading. Each is followed home on its own, and the Mac's stage shows the newest.
- Only Macs that can take it. A Mac advertises Beam on its sync record, with the edge it takes items on. A phone only throws to a Mac that does, and a Mac with Beam switched off stops being offered at once.
- Interruptions. If a call, Control Center or the app switcher takes your touch away mid-drag, nothing is sent: nobody let go.
The honest ceilings
Beam needs Droppy Sync, which needs an active Droppy license on the Mac. It goes from iPhone to Mac, not the other way, and not to other people: it moves things between your own devices in your own Sync Library. For sending files to someone else, Droppy Cloud share links are the tool. And without Local Network access, every throw takes the durable path, which works but cannot match a direct hop across the room.
Learn more about Beam on its own page, with every arrival style and the setup in one place.
Frequently asked questions
Does Droppy Beam send my photos through a server?
Not when your iPhone and Mac are on the same network and the phone has Local Network access: the bytes then go directly to the Mac over the local network. When they are apart, the bytes travel Droppy Sync's durable path through Droppy's servers, sealed on the phone first, so the servers only hold ciphertext.
Is Beam end to end encrypted?
Yes. Both the gesture frames and the files are sealed with the keys of your Droppy Sync pairing. Your Mac creates that key and keeps it in its Keychain, and it reaches your iPhone only inside the pairing code you scan.
What happens if the Wi-Fi drops halfway?
The direct transfer stops and reports which files the Mac already has and verified. The rest is sent the durable way through Droppy Sync, so the throw still completes.
How does the Mac know the file arrived intact?
On the direct path the phone computes a SHA-256 of each file while it reads it, and the Mac checks it after the last piece. A file only counts as delivered once the Mac verified it.
Why does the peek on the Mac look less smooth when I am away from home?
Over the relay, the phone sends its finger position on a coarser grid and at a lower rate, so a throw stays well inside the relay's message budget. On the same network the position streams continuously.
