LocalSend: The Open-Source AirDrop Alternative You Should Already Be Using
Apple spent years perfecting AirDrop. Google built Nearby Share. Microsoft built Phone Link. And somehow, a solo developer on GitHub quietly shipped a better solution than all of them — and almost nobody in enterprise tech is talking about it.
Here’s the uncomfortable truth: most people use AirDrop because it came with the device — not because it’s objectively the best option. The real problem (frictionless local file transfer) was solved in open-source a long time ago. It just wasn’t marketed by a company with a $3 trillion market cap.
LocalSend works across every major OS — Windows, macOS, Linux, iOS, Android — with zero cloud involvement, zero account required, and zero data leaving your network.
After 25 years in tech, my observation holds: the best tools are rarely the most advertised ones. They’re the ones quietly running in the background of serious practitioners’ workflows.
The File Transfer Problem Nobody Admits Is Broken
“We’ve had Wi-Fi for 20+ years. Why is sending a file across devices still annoying?”
The ecosystem lock-in reality is something the tech press consistently glosses over. AirDrop is elegant — inside Apple’s walled garden. The moment you step outside it, you’re improvising.
Here’s what actually happens in mixed-device environments. Apple to Android? You’re emailing it to yourself, dropping it in WhatsApp, or hunting for a cable. Windows to iPhone? “Just use iCloud” — which requires account setup, eats your 5GB free tier, and routes your file through Apple’s servers. Linux to anything? Mostly forgotten in mainstream conversations entirely.
The numbers make this worse. According to StatCounter Global Stats (2024), Windows holds approximately 72% of global desktop OS market share while macOS sits at roughly 15%. That means most workplaces are mixed-OS environments by default — yet the dominant “wireless transfer” conversation is built around an Apple-only feature.
It extends to mobile too. Statista (2024) puts Android at 71% global smartphone market share versus iOS at 28%. The majority of the world cannot use AirDrop natively. Not even close.
AirDrop is an elegant solution for a minority use case, dressed up and marketed as a universal standard.
Running a mixed home lab — MacBook, Windows desktop, Linux box, Android phone, iPad — I used to have a different file-transfer ritual for every device pair. It was embarrassing how much time I wasted on something that should be a non-problem. Then I found LocalSend, and that entire mental overhead just disappeared.
What LocalSend Actually Is (And Why the Architecture Matters)
“It’s not just ‘AirDrop for everyone’ — the technical choices here are deliberate and smart.”
LocalSend is built on Flutter, Google’s cross-platform UI framework. One codebase, every platform. That single architectural decision is why it feels native on each OS rather than feeling like a compromised port.
Under the hood: HTTPS + TLS encryption for all transfers on the local network. Peer discovery runs via multicast DNS (mDNS) — the same underlying protocol family as Apple’s Bonjour service. No server, no relay, no cloud middleman. Pure LAN-based peer-to-peer.
The GitHub repo at github.com/localsend/localsend is fully auditable. Apache-2.0 licensed. Free for personal and commercial use. The project has crossed 50,000+ GitHub stars as of mid-2024 — one of the fastest-growing utility apps on the platform. App Store rating sits above 4.6/5 on Google Play (higher on the iOS App Store). Available on Windows, macOS, Linux, Android, iOS, Fire TV, and as an F-Droid build for the de-Googled Android crowd.
This was built primarily by Tienisto, a solo/small-team maintainer. That context matters — because what’s been shipped here puts well-funded alternatives to shame.
Most cross-platform tools feel like compromises. LocalSend feels native on each platform. That’s a Flutter win, and it’s a rare one.
The chart above says everything. LocalSend and browser-based Snapdrop are the only tools that cover the full five-platform landscape. But Snapdrop is browser-dependent and routes through WebRTC — which comes with its own caveats (more on that shortly). LocalSend runs as a native app on every one of those platforms.
The Privacy Angle That Most Tech Writers Are Missing
“When you use AirDrop, Apple knows. When you use LocalSend, nobody knows.”
Let’s talk about what the alternatives actually do with your data — because the file transfer space is quietly one of the worst offenders for privacy theater.
AirDrop operates locally but requires an Apple ID. Apple’s broader ecosystem logs device interactions and the whole operation sits under Apple’s privacy policy and US jurisdiction. It’s not bad — but it’s not invisible either.
Google Nearby Share requires a Google account for full functionality. Google’s data practices apply. Need I say more.
WhatsApp or Telegram file transfers — and this one genuinely surprises people — route through cloud servers. Your “local” file transfer is actually traveling to Meta’s or Telegram’s servers and back. The latency on your local gigabit network suddenly makes a round trip to a data center somewhere.
Snapdrop is open-source and browser-based, which I respect. But hosted versions rely on third-party servers, and the WebRTC implementation can expose your IP to other session participants.
LocalSend’s privacy architecture is architecturally clean. Zero accounts. Zero registration. Zero analytics by default. Traffic never leaves your local network — and you can verify this yourself by running Wireshark while doing a transfer.
I’ve actually done this. Zero external connections during a LocalSend transfer. When I ran the same test on some “free” file transfer apps that showed up in search results, the packet captures told a very different story — phoning home, logging metadata, making handshake calls I had no context for.
Uncontrolled file-transfer tools and insider data leakage are perennial SMB security headaches. Here’s the irony: LocalSend on a local network is more controlled and auditable than most cloud-based “secure” alternatives that IT teams sign off on without reading the privacy policy.
Twenty-five years in tech has taught me one thing consistently: if you’re not paying and you’re not reading the source code, you’re probably the product.
Real-World Use Cases — Where LocalSend Earns Its Place
*“Theory is nice. Here’s where
The home lab use case is where I encounter it most personally. Moving large VM images, ISOs, and config files between machines without involving a USB drive or a cloud upload cycle. LAN transfers run at near-gigabit speeds on a decent home network. Compare that to uploading a 4GB file to Google Drive and downloading it on another device — you’re looking at a process that can take 10-15x longer depending on your ISP upload speeds, which are almost always the bottleneck.
The sensitive documents use case is underrated. Tax documents, legal files, personal medical records — things you actively don’t want touching a third-party server. LocalSend as the privacy-conscious handoff between your own devices is a genuinely different category from “convenient file sharing.” It’s controlled file sharing.
The travel and conference use case is where the no-internet-required architecture shines. LocalSend works on any shared Wi-Fi or even a personal hotspot. Sharing presentation files or photos at a conference without needing someone’s number, email, or AirDrop compatibility is a genuine friction-reducer. I’ve used it at events exactly this way.
The developer and maker use case is one that doesn’t get discussed enough. Pushing build artifacts, test APKs, or config files between a dev machine and a test device without involving any CI/CD overhead or USB debugging dance? That’s a workflow improvement that compounds over time.
The speed profile here reflects real-world LAN conditions. LocalSend and AirDrop are neck and neck on raw speed — but LocalSend does it across every device combination AirDrop can’t touch.
How LocalSend Actually Works — The Flow
Here’s the end-to-end architecture of a LocalSend transfer, which clarifies why it’s both fast and private:
graph TD
A[Open LocalSend on Device A] --> B[App broadcasts presence via mDNS on LAN]
B --> C[Device B running LocalSend receives broadcast]
C --> D[Device B appears in Device A's peer list]
D --> E[User selects file and target device]
E --> F[TLS-encrypted HTTPS connection established directly between devices]
F --> G{Recipient accepts transfer?}
G -->|Yes| H[File transfers directly over LAN at near-gigabit speed]
G -->|No| I[Transfer cancelled — no data sent]
H --> J[File saved to recipient's chosen directory]
J --> K[Zero cloud involvement — transfer complete]
The architecture diagram shows something important: there is no step where data touches an external server. The mDNS broadcast stays on your local network. The TLS handshake is device-to-device. The file transfer is device-to-device. This is a genuinely clean design.
The Open-Source Advantage Nobody Prices In
“You can read exactly what LocalSend does. Can you say that about the alternatives?”
The Apache-2.0 license on LocalSend means something beyond “free to use.” It means enterprises can audit it, fork it, deploy it internally, and integrate it into toolchains without licensing conversations — with an explicit patent grant, which is exactly why the project moved off MIT.
The 50,000+ GitHub stars aren’t a vanity metric here — they represent a community of developers who have reviewed, tested, and in many cases contributed to the codebase. Open-source security through community scrutiny is real, and it compounds over time.
Compare that to AirDrop, whose implementation is entirely proprietary and has had documented security vulnerabilities — including work from researchers at TU Darmstadt (disclosed to Apple in 2019, published in 2021) showing that AirDrop leaked users’ phone numbers and email addresses through hash-based contact discovery. Apple never fully fixed the underlying hash leak; in 2024 a Chinese firm reportedly exploited it using precomputed rainbow tables.
The open-source alternative isn’t just philosophically cleaner. When a flaw is in the open, anyone can see whether it actually got fixed.
For anyone building internal tooling or thinking about standardising file transfer workflows across a mixed-device organisation, LocalSend’s Apache-2.0 license is a genuine asset that proprietary alternatives simply can’t match.
Why This Tool Isn’t Already Everywhere (And What That Tells Us)
“The distribution gap between quality and adoption is the most persistent problem in open-source software.”
LocalSend is objectively better than AirDrop for mixed-OS environments. The data supports it. The architecture supports it. The privacy profile supports it. So why isn’t it in every tech worker’s toolkit?
Two reasons, and they’re both structural.
First: defaults win. AirDrop ships pre-installed on every Apple device. The mental overhead of even searching for an alternative is a friction barrier most people never cross. The same way Notepad persisted on Windows desktops for decades not because it was good, but because it was there.
Second: the open-source marketing gap. LocalSend has no marketing budget. No PR agency. No keynote slot at WWDC. It has a GitHub README and word-of-mouth. For a tool that has earned 50,000 stars and a 4.8/5 App Store rating purely on merit, that’s both impressive and a reminder of how distribution asymmetry shapes what tools people actually use.
This pattern repeats constantly in tech. The best tools are often the ones that never got a press release. VLC Media Player. Obsidian. Syncthing. LocalSend belongs in that conversation.
Getting Started — It Takes Three Minutes
The actual setup is almost offensively simple. Download from localsend.org or your platform’s app store. Install it on every device you want connected. Open the app. Done.
Devices on the same network discover each other automatically via mDNS. No pairing codes, no QR scans, no account creation. The UI is clean and immediately comprehensible — a list of nearby devices, a file picker, a send button.
For advanced users: LocalSend has a CLI mode, supports running as a background service, and lets you configure custom ports if you’re running strict firewall rules. There’s a setting to auto-accept transfers from trusted devices, which is useful in a home lab environment where you know every machine on the network.
The one friction point worth flagging: on some corporate or campus Wi-Fi networks, mDNS traffic is blocked at the network level. In that case, LocalSend won’t discover peers automatically. The workaround is either connecting devices to a personal hotspot, or manually entering a device’s local IP address for direct connection. Not a dealbreaker — but worth knowing before deploying in a managed network environment.
The Bottom Line
“The best file transfer tool isn’t the one Apple shipped — it’s the one you can actually use across every device you own, with zero data leaving your network, for free, forever.”
LocalSend is the rare open-source tool that competes on every dimension that matters: speed, privacy, cross-platform reach, and ease of use. It doesn’t win on marketing. It doesn’t win on pre-installation. It wins on the merits.
After 25 years watching tools come and go, the ones that stick in serious practitioners’ workflows are almost always the ones that do exactly what they promise, nothing more, nothing less, with no hidden cost to your data or your privacy.
LocalSend does exactly that.
Install it on every device you own. Send yourself a test file. Then quietly wonder why you ever emailed things to yourself.
Vin Patel is an AI technologist, solo builder, and independent practitioner with 25+ years in tech. He builds tools at the intersection of AI and productivity, including AEORank (aeorank.dev) for AI Engine Optimization. Find more at vinpatel.com.