The funny thing about file sharing in 2026 is that the hard part is often not the file. It is everything around it: which account is signed in, which cable is on the desk, whether the office Wi-Fi blocks peer discovery, whether the recipient is on iOS, Android, Windows, Linux or macOS, and whether sending a screenshot through a messaging app is acceptable for a file that should never leave the room.

That is why LocalSend keeps coming back. It is not a new project, but it resurfaced on Hacker News and GitHub discovery because it solves a boring problem with unusual discipline: send files between nearby devices without a cloud account, without a vendor ecosystem, and without pretending that everyone owns the same laptop and phone.

LocalSend describes itself as an open-source, cross-platform alternative to AirDrop. The useful version of that claim needs a footnote. It is excellent when your devices can see each other on a local network. It is much less magical than AirDrop when you want to send a photo to a stranger in a park, on a train, or at an event without joining the same Wi-Fi. That distinction is not nitpicking. It is the whole reason the project is interesting.

Open-source local file sharing between laptop, phone and tablet without cloud services

What LocalSend actually is

LocalSend is a free, open-source app for local file sharing across Windows, macOS, Linux, Android and iOS. The project site frames the pitch plainly: share files without the cloud, no account, no login, no external server, no ads, no trackers. The GitHub repository is licensed under Apache-2.0 and had roughly 85,000 stars, 4,600 forks and more than 1,000 open issues when checked on July 15. The repository was active that same day, even though the latest stable release listed by GitHub was v1.17.0 from February 2025.

The app’s basic flow is simple. Install it on the devices you care about, put those devices on the same local network, open LocalSend, choose a recipient, and send. The official site says transfers stay on the local network and are encrypted using HTTPS. The separate LocalSend protocol documentation describes a REST-based design that does not rely on external servers, with discovery methods such as multicast and HTTP modes, plus transfer endpoints for upload and reverse transfer.

That sounds almost too ordinary to be a front-page developer story. But ordinary is the point. Most people do not want a distributed-systems seminar when they need to move a PDF from a Linux desktop to an iPhone. They want the nearby device to appear and the transfer to finish without uploading the file to a cloud drive first.

LocalSend is also not trying to become a complete device-control suite. KDE Connect can do more: clipboard sharing, remote control, notifications, device integration. Syncthing can keep folders continuously synchronized. Magic Wormhole and Croc are strong command-line tools for secure one-off transfers over the internet. PairDrop and Snapdrop-style tools offer browser-first flows. LocalSend sits in a narrower lane: local, app-based, cross-platform, easy enough for non-developers.

Why it is getting attention again

The current wave is partly about numbers. The main Hacker News thread titled “Localsend: An open-source cross-platform alternative to AirDrop” showed 923 points and 275 comments on the page when checked. Older LocalSend threads also did well: a 2023 thread had 563 points and 229 comments, and a 2024 discussion drew hundreds more. This is not a one-day novelty. The same need keeps returning.

The GitHub numbers tell the same story. A project does not get to 85,000 stars merely because people enjoy file-transfer theory. It gets there because enough users have run into the same absurd little wall: they can video-call across continents, but moving a file between two devices on the same table still turns into a choice between Apple-only magic, Google-specific flows, cloud upload, Bluetooth misery, USB cables, or a chat app used as a file shuttle.

Hacker News is useful here because the comments are practical rather than celebratory. People praise LocalSend for doing the job between mixed devices. Users mention Android-to-Mac, Linux-to-phone, Windows-to-iOS and family or office setups where the device mix makes AirDrop irrelevant. Others push back hard on the “AirDrop alternative” label because AirDrop can create a peer-to-peer path and work without a shared Wi-Fi network. LocalSend generally assumes the devices can meet on the same local network. Both sides are right.

That makes LocalSend a good Open Source Radar item. The story is not “this new app replaces everything.” The story is that an open-source project is filling a real usability gap that the big platforms still have not standardized across ecosystems.

The AirDrop comparison is useful, but only if it is honest

AirDrop is the obvious reference point because it defined the user expectation: open a share sheet, pick the nearby person or device, send the file. When it works, it feels unfairly good. The cost is the Apple boundary. AirDrop is for Apple devices. If your world includes Android phones, Windows laptops, Linux machines, work computers, tablets and borrowed devices, the magic ends fast.

LocalSend covers many of the same everyday use cases. You can move photos from a phone to a laptop, send a build artifact to another machine, pass a PDF to a tablet, or move a screen recording without creating a cloud copy. For a mixed household or a developer with several operating systems, that is already enough to justify installing it.

But LocalSend is not AirDrop with the serial numbers filed off. AirDrop’s strongest trick is proximity sharing without the user first caring about a shared network. LocalSend’s strongest trick is being cross-platform and local once the network is suitable. That difference matters in hotels, conferences, trains, universities and corporate Wi-Fi setups where client isolation blocks devices from seeing one another.

A useful way to phrase it is this: LocalSend is an AirDrop-like app for people who control the local network or can create one. It is not yet a universal “send to anyone nearby” standard.

That limitation is not a failure. It is the boundary of the design. It also explains why discussions around the project quickly branch into Wi-Fi Direct, WebRTC, browser-based transfer, Quick Share, KDE Connect and Magic Wormhole. Everyone is circling the same missing standard from a different angle.

Privacy is the selling point, but also the trade-off

LocalSend’s best argument is privacy through locality. You do not need to upload a file to a third-party server just to move it across the room. You do not need to sign into an account. You do not need to send a private document through a messenger because it happens to be convenient.

That matters for work files, screenshots, medical documents, tax forms, family photos, APKs, logs and archives. It also matters for ordinary trust. A local transfer app is easier to reason about than a cloud sync product when all you want is a one-time handoff.

The trade-off is that local networking is messy. Multicast discovery can fail. VPNs can confuse routing. A laptop may have Ethernet, Wi-Fi, a virtual adapter, a container network and a VPN interface at the same time. Public Wi-Fi often isolates clients on purpose. Mobile operating systems can restrict background behavior or ask for permissions in ways that make a “simple” transfer feel less simple.

The v1.17.0 release notes are a useful window into that reality. The release added an advanced setting to filter network interfaces, improved mobile media selection, handled Windows pasted images as PNG, and fixed a path traversal vulnerability when saving files. Those are not flashy features. They are the kind of maintenance work a real utility accumulates once people use it on messy machines.

LocalSend’s privacy story is therefore strong but specific. It reduces cloud exposure. It does not make local networks safe by magic. If you are sending sensitive files on a hostile network, you still need to understand who can see what, verify recipients, and use the app’s security features such as PIN verification where appropriate.

The release signal needs nuance

There is a small tension in the project’s public signals. The repository looked active in mid-July 2026, but GitHub listed v1.17.0 from February 2025 as the latest stable release. That does not mean the project is abandoned. It does mean users should separate “active development” from “recent stable release.”

For a developer tool or utility, that distinction matters. An active repository with many open issues can mean healthy usage and ongoing maintenance. It can also mean backlog, platform churn and a project carrying a lot of edge cases. LocalSend has to deal with desktop operating systems, mobile operating systems, app stores, local networking, permissions, browser expectations and security reports. That is a large surface area for a utility whose job sounds simple.

The release notes also mention that v1.17.0 was a small interim release before WebRTC is stable. That is worth watching because WebRTC could improve some browser and peer-to-peer scenarios, but it does not automatically solve every local transfer problem. WebRTC still needs discovery, signaling decisions, browser behavior, NAT behavior and UX that normal users understand.

The practical advice is simple: try LocalSend as it exists today, not as the roadmap you hope it becomes. If it solves your local transfers now, keep it. If your main use case is stranger-to-stranger transfer without shared Wi-Fi, treat it as one candidate, not the final answer.

How it compares with the usual alternatives

AirDrop is still the smoothest option inside Apple’s ecosystem. It is not a general answer for mixed-platform homes or teams.

Quick Share and the old Nearby Share line are better than the chaos that came before, especially for Android and Windows users, but they are not the same as a neutral open standard across every desktop and mobile platform. They also come with vendor assumptions that some privacy-conscious users do not want.

KDE Connect is excellent if you want broader device integration. It can send files, but file transfer is only one part of the project. That can be a benefit or a distraction depending on what you need.

Magic Wormhole and Croc are strong for developers and terminal users. They are especially useful when devices are not on the same local network. The downside is obvious: they are less friendly for family members, phone users, or anyone who expects a graphical nearby-device picker.

PairDrop and Snapdrop-style tools are attractive because the browser becomes the app. They can be great when you do not want to install anything on the recipient’s device. The trade-offs are browser limits, signaling infrastructure, network behavior and sometimes less predictable performance.

Syncthing is a different category. It is wonderful for continuous folder sync between your own devices. It is overkill when you just want to hand one file to one person once.

LocalSend wins when the question is narrower: “I have two or more devices on a local network, often across different operating systems, and I want a private one-off transfer without accounts.” That is not every file-sharing scenario. It is a lot of them.

Who should try LocalSend

Install it if you live in a mixed-device world. Android phone plus Mac. iPhone plus Linux laptop. Windows work machine plus personal tablet. Family members with different ecosystems. A small team that wants to move logs, screenshots or test builds without turning every transfer into a cloud upload.

It is also worth trying if you are the unofficial tech-support person in a household. A simple local file-transfer app can save a surprising amount of time compared with explaining cloud folders, account permissions, expiring links and why a messenger compressed the file.

Developers and sysadmins may like it for a different reason: it is a GUI tool that non-technical people can use, but it still respects the basic instinct to keep local files local. Not every transfer needs an S3 bucket, a Slack attachment or a USB stick.

The best test is mundane. Put LocalSend on your phone and your laptop. Send a large video, a PDF, a folder, a screenshot and a build artifact. Try it on your home Wi-Fi, office Wi-Fi and phone hotspot. If discovery works and speed is acceptable, the app has earned its place.

Who may be disappointed

Do not expect LocalSend to behave exactly like AirDrop in every social setting. If you regularly need to send files to people you just met, without a shared network and without asking them to install an app, LocalSend may feel less magical than the name comparison suggests.

Be cautious on corporate or school Wi-Fi. Client isolation can prevent devices from discovering one another. VPNs and multi-network setups can also create confusing failures. The network interface filter added in v1.17.0 exists because real machines often have more than one plausible network path.

If you need continuous synchronization, use a sync tool. If you need internet-routed transfers with a simple code phrase, look at Magic Wormhole or Croc. If you need a no-install recipient flow, try PairDrop or another browser-based option. If you are all-in on Apple hardware, AirDrop may remain the better everyday default.

The worst outcome would be calling LocalSend “the universal AirDrop” and then blaming the project when it does not solve a different problem. It is better than that: it is a focused tool with clear strengths.

The open-source lesson

LocalSend’s popularity is a reminder that open source does not need to be glamorous to matter. Sometimes the winning project is the one that attacks a tiny daily annoyance and refuses to make the user pay with an account, a cloud upload, a tracking SDK or a platform lock-in.

It also exposes a larger failure. File transfer between nearby devices should have been solved years ago by interoperable standards that every major platform implemented well. Instead, users keep choosing between vendor islands, partial bridges and clever community tools. LocalSend is useful because that gap still exists.

That is why the Hacker News debate is healthy. The critics are not wrong when they say LocalSend lacks AirDrop’s ad-hoc network magic. The fans are not wrong when they say it works better than the messy alternatives they actually have. Both reactions point to the same truth: the universal local file-sharing problem is still unfinished.

Verdict

LocalSend is worth trying and probably worth keeping installed if you use more than one operating system. It is open source, practical, private by default in the way most users mean that phrase, and broad enough to cover a lot of ordinary file-transfer pain.

Just do not oversell it. It is not a perfect AirDrop clone. It is not a replacement for sync tools, terminal transfer tools, or browser-first sharing in every situation. It is a local-network file-transfer app that does its job well enough to make people wonder why the platforms themselves still make this so hard.

For Open Source Radar, that is exactly the kind of project worth attention: not because it is new, but because it is useful, maintained, understandable, and aimed at a problem people keep having.