Open source file sharing tools have real advantages: no account, no tracking, no vendor deciding to paywall a feature you rely on. The code is inspectable, and if the maintainer walks away, someone can fork it.
That last part isn't hypothetical, though — walking away happens, and this year it happened to one of the biggest names on this list. So this review covers not just what each tool does, but how healthy it actually is in 2026.
We set up all seven on real devices — a Windows laptop, a Mac, an Android phone, an iPhone — and judged them on four things: setup effort, platform coverage, whether they survive a network boundary, and maintenance health.
1. LocalSend — the default choice
The closest thing this category has to a safe recommendation. LocalSend is MIT-licensed with genuinely native apps on Windows, Mac, Linux, iOS, and Android — install it on two devices on the same WiFi, and they see each other in seconds. Transfers are encrypted (HTTPS) and never leave your network. No account, no configuration.
The catch: same WiFi, always. LocalSend has no mode for reaching a device on another network or on mobile data — the other device simply doesn't appear, with no error explaining why. We covered exactly when that bites in our guide to transferring files over a local network.
Use it if: you want the AirDrop experience without the Apple lock-in, and your devices share a network.
2. PairDrop — nothing to install
PairDrop is the actively maintained fork of Snapdrop (the original is abandoned — a recurring theme). Open pairdrop.net in a browser on both devices, and they discover each other over the local network via WebRTC. It's the tool to use on a device you don't own: nothing to install, nothing to sign into.
The catch: it lives in a browser tab, so it's ephemeral by design — close the tab and the session is gone. Its pairing feature (a 6-digit code or QR scan) lets paired devices find each other even across networks, which genuinely lifts it above old Snapdrop, but pairing every device pair by hand is exactly the kind of setup friction the tool otherwise avoids.
Use it if: you need a one-off transfer, especially to someone else's device.
3. KDE Connect — deepest integration, narrowest audience
KDE Connect does far more than move files: shared clipboard, notification mirroring, remote input, media controls. On Linux plus Android, nothing else on this list comes close.
The catch: that pairing of platforms is really the product. The iOS app exists but is genuinely limited by Apple's background restrictions, and Windows/Mac support trails Linux. Like LocalSend, it's local-network only.
Use it if: you live in the Linux/Android world and want your phone and desktop to feel like one machine.
4. Syncthing — brilliant engine, wrong job (and an Android problem)
Syncthing continuously mirrors folders between machines — a decentralized, encrypted, self-hosted Dropbox with no server. For keeping a working directory identical across three computers, it's superb, and the core project is healthy.
The catch: two, and they're big. First, the mental model: Syncthing syncs folders; it doesn't send things. Using it for "get this one file to my phone" means adopting a whole folder-mirroring lifestyle. Second, the Android story: the official Android app was discontinued — its final release shipped with the December 2024 version — and the most popular community fork disappeared from GitHub in late 2025. Android users are now choosing between smaller forks with uncertain futures. That's the honest cost of open source: maintenance depends on people, and people move on.
Use it if: you want continuous folder sync between desktops and can live with the Android uncertainty.
Photo by Ilya Pavlov on Unsplash
5. croc — the terminal user's answer
croc is a command-line tool: type croc send file.pdf on one machine, it prints a short code phrase, you type that phrase into croc on the other machine, and the file moves — end-to-end encrypted, through a public relay, across any two networks. It's the only tool on this list that combines cross-network transfer with genuinely zero configuration.
The catch: it's terminal-only, which rules it out for most people's phones (Android needs Termux; iOS is out). And both machines need croc running at the same moment — there's no inbox, so you can't send something now for pickup later.
Use it if: you're comfortable in a shell and need machine-to-machine transfers that don't care about networks.
6. OnionShare — for when anonymity is the point
OnionShare shares files by spinning up a temporary onion service over Tor. The recipient just needs Tor Browser and the address you give them. Nobody — not a relay operator, not a cloud provider — learns who sent what to whom.
The catch: Tor's routing makes it slow, and the share only exists while your window stays open. That's the correct trade-off for a journalist's source; it's the wrong one for sending yourself a design file. Judging it as a daily-driver transfer tool misses its point entirely.
Use it if: the metadata — who, to whom — matters as much as the file.
Photo by Taylor Vick on Unsplash
7. Nextcloud — own the whole cloud
Nextcloud is the maximal option: a full self-hosted cloud with file sync, share links, mobile apps on everything, and hundreds of add-on apps. It works across any network, because you're running the server.
The catch: you're running the server. Updates, backups, TLS certificates, storage, uptime — it's all yours now. As a file-sharing tool judged on effort-to-value, it's the heaviest thing here by an order of magnitude. Teams and homelab enthusiasts get real value; someone who just wants files on two devices gets a hobby.
Use it if: you want full ownership of your data and genuinely enjoy running infrastructure.
The honest verdicts, side by side
| Tool | Works across networks? | Platforms | The one-line verdict |
|---|---|---|---|
| LocalSend | No | All five | Best all-rounder, same WiFi only |
| PairDrop | Paired devices only | Any browser | Best zero-install option |
| KDE Connect | No | Linux + Android (others limited) | Best integration, narrowest fit |
| Syncthing | Yes (sync, not send) | Desktop strong, Android uncertain | Folder sync, not handoffs |
| croc | Yes | Anywhere with a terminal | Best cross-network, CLI only |
| OnionShare | Yes (via Tor) | Desktop | Anonymity first, speed last |
| Nextcloud | Yes | All five + web | Full ownership, full sysadmin job |
Where open source stops short
Notice the pattern in that table: the tools that are effortless (LocalSend, PairDrop) are network-bound, and the tools that cross networks (croc, Nextcloud) demand a terminal or a server. None of the seven gives you the everyday case — send a link or file from the browser you're in, to your phone on whatever network it's on, in one click.
That specific gap is what Knit is built for. Full honesty, since this is a review: Knit is free but not open source. If open source is a hard requirement, croc and a paired PairDrop are your closest options. If what you actually need is the frictionless self-handoff — browser extension on the laptop, any browser on the phone, any network, signed in once — that's the trade Knit makes, and it's the tool we'd reach for between our own devices. For the broader landscape beyond open source, see our comparison of every cross-platform file sharing method.
Frequently asked questions
What is the best open source alternative to AirDrop?
LocalSend is the closest open source equivalent: free, MIT-licensed, with real apps on Windows, Mac, Linux, iOS, and Android, and no account required. If you can't install anything, PairDrop does the same job from a browser tab. Both require every device on the same WiFi network.
Is Syncthing still maintained?
The core Syncthing project is actively maintained on Windows, Mac, and Linux. The official Android app is not — its last release shipped in December 2024, and the most popular community fork became unavailable in late 2025. On Android, you're choosing between smaller forks with uncertain futures.
Which open source file sharing tools work between different networks?
croc (through an encrypted relay), OnionShare (through Tor), and a self-hosted Nextcloud all work across different networks. PairDrop can too, but only between devices you've explicitly paired. LocalSend and KDE Connect are same-WiFi only by design.
The bottom line
Every tool here is genuinely good at the thing it was designed for — and honest reviewing means saying what that thing is. Same-WiFi handoffs: LocalSend. Borrowed devices: PairDrop. Linux+Android: KDE Connect. Folder mirroring: Syncthing (on desktop). Terminal transfers across networks: croc. Anonymity: OnionShare. Data sovereignty: Nextcloud.
And for the case none of them cover — the one-click, any-network, browser-to-phone handoff — that's the gap Knit closes.
