# rquickshare: NearbyShare for Linux and macOS, installed from a .deb or .dmg

> rquickshare is a Rust implementation of Android's NearbyShare/QuickShare for Linux and macOS. It ships as prebuilt packages rather than a build-from-source project, and its own README calls it a work in progress with one hard limitation: both devices must sit on the same Wi-Fi LAN.

**Martichou/rquickshare** — Rust implementation of NearbyShare/QuickShare from Android for Linux and macOS.

- Repository: https://github.com/Martichou/rquickshare
- Stars: 3,627 · Forks: 133
- Language: Rust
- License: GPL-3.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/martichou-rquickshare

## The gap rquickshare fills: Android file transfer without a cable or a cloud account

Android's NearbyShare, now branded Quick Share, is the default way to move a file between a phone and another device. On Windows there is a Google client. On Linux and macOS there is nothing official, so the phone-to-laptop path normally runs through a USB cable, a cloud folder, or a chat app that recompresses the file. rquickshare is a Rust program that speaks the same protocol from the desktop side, so the phone sees the machine as a normal NearbyShare target. The audience is narrow and specific: Linux desktop users, plus macOS users, who already have an Android phone and want the transfer to happen over the local network. The README frames the project as work in progress and notes that it currently only supports Linux even though macOS should be compatible. That sentence matters more than the feature list, because it tells you the macOS .dmg is shipped but is not the path the maintainer is exercising day to day.

## How the discovery and transfer actually work

The repository is split into `app/` and `core_lib/`, which matches the two halves of the problem: a desktop shell and the protocol implementation. Discovery runs over mDNS, the same multicast DNS mechanism Android uses to advertise its NearbyShare service on the local network. That single design decision explains most of the project's behaviour. If mDNS multicast does not cross your network, nothing appears in either direction, which is why the README points at public networks such as coffee shops and airports as the usual failure case.

The asymmetry between the two devices is the part most users hit. An Android phone does not advertise its mDNS service continuously, even when set to Everyone mode, so the laptop often sees nothing. On Linux, rquickshare works around this by broadcasting a Bluetooth advertisement, which prompts Android to publish its mDNS record. That workaround requires a Bluetooth radio on the desktop. Without one, the README offers two manual alternatives on the phone side: opening the Files app and going to the Nearby Share tab, or building a shortcut to a specific Android activity or intent. The README also warns that Samsung's Quick Share implementation may not respond to either workaround. When you share a file, the phone appearing and disappearing in the list is a symptom of the same mechanism, not a bug in the desktop app.

## Installing rquickshare on Ubuntu, Debian, Fedora or Arch

There is no build step for normal users. The README says to download the latest release, and the package filename carries the minimum GLIBC version it was built against. Check yours first:

```bash
ldd --version
```

On Debian and Ubuntu, install the .deb directly. The README also lists `libayatana-appindicator` or `libappindicator3` as required for the tray icon, and notes the packages should pull those in themselves:

```bash
sudo dpkg -i r-quick-share_${VERSION}.deb
```

On Fedora, the README prefers DNF over a raw RPM install:

```bash
sudo dnf install r-quick-share-${VERSION}.rpm
```

If you would rather not install anything, the AppImage needs no root. Make it executable and run it:

```bash
chmod +x r-quick-share_${VERSION}.AppImage
./r-quick-share_${VERSION}.AppImage
```

Arch users can install from the AUR, which the README lists under unofficial methods:

```bash
yay -S r-quick-share
```

On macOS, the README says to install the .dmg, and warns you may have to allow it under Settings > Privacy & Security > Security first. Once the app is running, it lives in the system tray. Closing the window does not quit it. If you want the close button to actually stop the process, the README points to the three dots menu and the Stop app on close option.

## The Wi-Fi LAN requirement, and the port you will probably want to fix

The Limitations section is one line long and it is the constraint that decides whether this tool works for you at all: Wi-Fi LAN only, both devices on the same network. There is no relay, no pairing over the internet, no fallback. A laptop on a VPN whose traffic is routed away from the local subnet will not see the phone, and neither will a machine on a guest VLAN.

The second constraint is the listening port. By default the OS picks a random one, which is fine until a firewall is in the way. The README's answer is to edit the settings file and pin the port. On Linux the path is `./.local/share/dev.mandre.rquickshare/.settings.json`, on macOS `Library/Application Support/dev.mandre.rquickshare/.settings.json`, and the README suggests `find $HOME -name ".settings.json"` if you are unsure. The key is `port`, and the README carries a warning worth repeating: the JSON must stay valid, so if `port` is the last item it must not be followed by a comma, otherwise the config is reset.

```json
{
	"port": 12345
}
```

There is a third failure mode documented for Linux users on NVIDIA cards: the app opens to a blank window. The README's workaround is an environment variable, and it also suggests trying the legacy variant instead.

```bash
env WEBKIT_DISABLE_COMPOSITING_MODE=1 rquickshare
```

## Where rquickshare is the wrong tool

If you need to send a file to a phone that is not on your network, this project cannot help you and no amount of configuration will change that. The same applies to a locked-down corporate network where mDNS multicast is filtered; the README names public networks as the typical case, but managed switches and client isolation produce the same result.

Samsung owners are a separate category. The README states plainly that Samsung did something to Quick Share and that the documented workarounds may not work, with no alternative offered. If you are on a recent Samsung device, treat compatibility as unverified rather than likely.

The macOS story is thinner than the download page suggests. The README says the project is still in development and currently only supports Linux, while also saying it should be compatible with macOS. Those two statements are not reconciled anywhere in the README. A macOS user should read the .dmg as an untested path, not a supported one. Finally, the design is explicitly allowed to change between versions, so anything scripted against the config file or the tray behaviour is exposed to that.

## How it compares with NearDrop and QNearbyShare

The README credits two projects as the reason rquickshare exists: grishka/NearDrop and vicr123/QNearbyShare. Both implement the same NearbyShare protocol on the desktop side, so the difference is in packaging and language rather than in what the protocol can do. NearDrop is the macOS-side project that established the approach of speaking Android's sharing protocol from a desktop; rquickshare reimplements that work in Rust and extends it to Linux distributions as well as macOS. QNearbyShare is the Qt-based counterpart, which matters if you already run a Qt desktop and would rather not pull in a second toolkit stack.

The practical distinction for rquickshare is distribution. It ships as .deb, .rpm, AppImage, AUR and Nix packages, with a .dmg for macOS, and it carries a Bluetooth advertisement workaround for the Android discovery problem that the README describes. If your distribution is covered by one of those package formats, installation is a single command. If it is not, you are compiling Rust from `app/` and `core_lib/` yourself, and the README does not walk through that.

## Licence and what it costs you to stay current

rquickshare is GPL-3.0. If you redistribute it or ship a modified build inside a product, the GPL-3.0 obligations attach to that distribution. Running it on your own machines carries no such obligation. This is a description of the licence identifier in the repository, not legal advice; read the LICENSE file and talk to counsel if you plan to redistribute.

The upgrade cost is low but not zero. Releases are tagged, with v0.11.5, v0.11.4 and v0.11.3 listed most recently, and the last push to the repository was on 2026-05-01. Since there is no auto-update described in the README and installation is a package file, staying current means downloading a new .deb, .rpm or .dmg and reinstalling it. Watch the GLIBC version in the filename when you do: the README explains that main and legacy builds existed side by side up to v0.11.5, with legacy for older Ubuntu versions and main for newer ones. If you picked legacy once, you need to make that choice again at each upgrade rather than assuming the newest file is the right one for your distribution.

## Conclusion

Adopt rquickshare if you move files between a Linux or macOS machine and an Android phone on the same Wi-Fi network and you want a tray app rather than a browser-based transfer. Skip it if your devices are on different subnets, if your network blocks mDNS, or if you are on a Samsung phone whose Quick Share build the README says may not respond to the documented workarounds. Before relying on it, check `ldd --version` against the GLIBC version named in the package filename you download, and decide whether you want the main or legacy build, since both existed only up to v0.11.5.

## FAQ

### Is rquickshare safe?

The repository is public and licensed GPL-3.0, and the README documents the discovery and transfer behaviour, including the Bluetooth advertisement used to prompt Android into publishing its mDNS record. Nothing in the README describes telemetry or a cloud relay; transfers are described as happening over the local Wi-Fi network only.

### Can I use Samsung Quick Share on Linux devices with rquickshare?

The README states that Samsung did something to Quick Share and that the documented Android workarounds may not work on those devices, with no alternative offered. Treat Samsung compatibility as unverified rather than confirmed.

### How do I install rquickshare on Ubuntu or Debian?

Download the latest release and install the .deb with `sudo dpkg -i r-quick-share_${VERSION}.deb`. The README notes that `libayatana-appindicator` or `libappindicator3` must be present for the tray icon, and that the package should install those itself.

### How do I stop rquickshare from staying in the tray after I close the window?

Closing the window does not quit the process by default. The README says to click the three dots in the app and enable Stop app on close, and suggests checking with `ps aux | grep r-quick-share` to confirm whether the process is still running.

### Why does rquickshare show a blank window on Linux?

The README attributes this to some Linux users running NVIDIA cards. The documented workaround is to start the app with `env WEBKIT_DISABLE_COMPOSITING_MODE=1 rquickshare`, or to try the legacy variant.

## Sources

- [Issues](https://github.com/Martichou/rquickshare/issues)
- [License: GPL-3.0](https://github.com/Martichou/rquickshare/blob/master/LICENSE)
- [Martichou/rquickshare on GitHub](https://github.com/Martichou/rquickshare)
- [README](https://github.com/Martichou/rquickshare/blob/master/README.md)
- [Releases](https://github.com/Martichou/rquickshare/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/martichou-rquickshare