# WindSend moves clipboard and files between your phone and your PC over TLS

> WindSend is a set of applications for passing clipboard content, files and folders between devices, currently focused on a personal phone and computer. It encrypts everything with TLS, discovers peers automatically on the local network, and can fall back to a relay or a tunnel when the two devices are on different networks.

**doraemonkeys/WindSend** — Quickly and securely sync clipboard, transfer files and directories between devices. 快速安全的同步剪切板，传输文件或文件夹

- Repository: https://github.com/doraemonkeys/WindSend
- Stars: 616 · Forks: 31
- Language: Dart
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/doraemonkeys-windsend

## A personal phone-to-PC transfer tool, not a team file sync

WindSend is a set of applications for quickly and securely passing clipboard content between devices, transferring files or folders, and supporting image and file clipboards. The documentation is explicit about the current focus: it is currently oriented toward transferring between a personal phone and a computer.

That framing sets expectations properly. This is not a Dropbox replacement, not a sync folder, and not a shared workspace. The clipboard case is the sharp one: copy a snippet of text on the phone, open the app, tap paste, and the notification appears on the computer. The file case is a long press on a phone folder to upload it.

The design decisions listed for choosing it are worth reading as a specification of what the tool optimises for. Security comes first, because all data is transferred encrypted with TLS, and the documentation notes that even on a local network some people want more security. Simplicity means a clean interface, open source, free and no advertising. Coverage means it automatically matches computers on the local network that share the same key, so switching Wi-Fi is not a problem. Peace of mind means you no longer worry about the connection state to the computer, since as long as it is online the phone can send. Speed comes from multithreaded asynchronous file transfer that makes use of the available bandwidth. Lightness means no additional runtime environment, with idle memory usage under 10M and essentially no CPU consumption.

The repository has two implementations, a Rust one and a Flutter one, and the topics list both Dart and Rust.

## Automatic pairing over the local network, with a manual fallback

The pairing mechanism is the part that decides whether the tool feels smooth or fiddly, and the documentation describes both paths.

The automatic path is quick pairing. On the PC you enable quick pairing so the phone can discover it, and quick pairing switches itself off after the first successful pairing. On the phone you tap the plus button in the bottom right to open the configuration, then tap search several times, and if you are lucky the secret key is filled in automatically.

The manual path exists for when that fails. You open the default configuration file config.yaml, copy the secretKeyHex value, open tls/ca_cert.pem and copy its contents, then fill both into the app configuration by hand.

The documentation offers a diagnostic for the failure case, and it is the most useful line in the setup section: in most cases, a failed quick pairing means the network between your devices is not connected, and you should try again using a phone hotspot.

Two permission notes are worth knowing before you start. Notifications on Windows depend on PowerShell, so if no notification appears you should check that PowerShell is on your PATH. The app's location permission is used to obtain Wi-Fi information, and the documentation strongly recommends granting precise location access.

## Two implementations, and the warning not to pick the wrong download

The download instructions contain a warning that is easy to skim past. For the PC, the documentation says you should generally choose the x64 Rust version, with an explicit instruction not to download the Flutter version. For mobile, the suggested file is WindSend-flutter-arm64-v8a-release.apk.

The reason for the split is visible in the platform support tables. The Flutter implementation compiles on Windows, macOS, Linux, Android and iOS, and runs normally on Windows, Linux and Android, with macOS and iOS marked as uncertain. The Rust implementation compiles on Windows, macOS and Linux and runs on Windows and Linux, with the same uncertainty marks on macOS, and Android and iOS marked as unable to compile. A third implementation, in Go, is marked as no longer maintained, and its table shows it compiling only on Windows with macOS and Linux unable to compile.

The cross-platform caveat explains the uncertainty marks. The documentation states that because the author only has Android and Windows devices, the software cannot be guaranteed to work correctly on other platforms, and invites pull requests or issues. That is a candid statement and a useful one: it tells you the macOS and iOS entries are aspirational rather than tested, and that anyone on those platforms is effectively testing it themselves.

On Linux, the unzip target is WindSend-linux-x64-S-Rust-v*.zip, and the documentation notes that a compatible version exists for GLIBC mismatches, or you can compile it yourself.

## Leaving the local network through a tunnel or a relay you host

Two mechanisms handle the case where the phone and the computer are not on the same network, and the documentation is direct that the configuration stage requires the two devices to be on the same network or that you manually configure a relay server.

The first option is an intranet penetration tool such as Tailscale. The instruction is short: replace the computer IP with the one Tailscale assigns, and test the other tools yourself. This keeps the traffic on a virtual network you control and does not require running anything of your own beyond the tunnel client.

The second option is your own relay server. WindSend supports self-hosted relay servers for different network environments, with a separate WindSend-Relay repository holding the build guide. The usage sequence is three steps: run the relay service and set a connection key if you want one, put the relay server address in the device settings, then push the relay configuration to the target device, or edit the configuration file by hand.

The manual configuration path adds a few keys to the default config.yaml and restarts the software:

```yaml
  relayServerAddress: your_relay_server_address:16779
  relaySecretKey: null
  enableRelay: true
```

The relaySecretKey defaults to null, meaning the relay runs without a connection key, and you set it to a key string if you want one. The relay port shown here is 16779. Because the relay is software you host, the trust decision moves to you: anyone who can reach that address and knows the key can relay traffic between paired devices, so treat the key like a password and treat the host like a server you are responsible for.

## Building from source with Cargo or Flutter

The build guide points at the Release.yml workflow file, which contains the detailed automated build process, and notes that you can also download the raw artefacts produced by the Actions workflow.

For the Rust implementation, the source lives in the windSend-rs directory and the build is a standard cargo release build:

```shell
cd windSend-rs
cargo build --release
```

The Rust toolchains are pinned per target: stable-x86_64-pc-windows-msvc for Windows x86_64, aarch64-pc-windows-msvc for Windows aarch64, x86_64-unknown-linux-gnu for Linux x86_64, x86_64-apple-darwin for macOS x86_64 and aarch64-apple-darwin for macOS aarch64. The requirements section points at the AWS Libcrypto for Rust user guide, and the Linux package list shows what a headless build needs:

```shell
sudo apt install -y libgtk-3-dev libxdo-dev libappindicator3-dev 
sudo apt install -y pkg-config libssl-dev build-essential linux-libc-dev
sudo apt install -y musl-dev musl-tools
```

The Flutter implementation builds from the flutter/wind_send directory, and the Flutter version channel is stable:

```shell
cd flutter/wind_send

flutter build windows --release
flutter build linux --release
flutter build macos --release
```

Android needs a signing setup before an APK build, which means creating a key.properties file in the flutter/wind_send/android/app directory containing the app signing information and the path to the store.jks file:

```shell
flutter build apk --split-per-abi --release
```

The split-per-abi flag produces one APK per architecture, which matches the arm64-v8a release file the mobile download instructions point at.

## MIT licensed, small footprint, and versioned regularly

The licence is MIT, which is the permissive case and leaves no real questions for a company shipping this internally. The LICENSE file sits at the repository root next to the README and the build scripts.

Upkeep looks steady. The last push was on 2026-10-22, and the release history shows v1.7.4 on 2026-09-19, v1.7.3 on 2026-07-29 and v1.7.2 on 2026-06-26. Three releases in one quarter is a healthy pace for a tool of this size.

The repository layout shows the two implementations coexisting rather than one replacing the other. There is a flutter directory, a windSend-rs directory, and a set of shell and batch build scripts at the root covering Android, Linux, macOS and Windows, plus build-win.bat and build.bat for the Windows path. A version.sh and an env.sh handle release versioning and environment setup. The docs directory holds the longer documentation, and there is a.devcontainer directory, which means there is a containerised development environment for contributors.

The cost of running the tool is also part of its practical profile. There is no server to operate in the default case, no account to create, and the client sits at under 10M of memory while idle. What you do operate is whatever you choose for the relay case, and if you use Tailscale you are running that tunnel on both devices.

## Conclusion

WindSend suits someone who wants to move text, photos and whole folders from a phone to a computer on the same network without a cloud account, a browser extension or a cable. It is the wrong choice if you need iOS or macOS support you can rely on, since the project states the author only has Android and Windows hardware and cannot guarantee behaviour on other platforms, and the wrong choice when the devices will routinely be on different networks without a tunnel or relay you control. Before adopting it, download the x64 Rust build for the PC rather than the Flutter one as the documentation warns, start it once so it writes config.yaml, and confirm the TLS certificate in tls/ca_cert.pem matches what the app is showing you.

## FAQ

### How do I install WindSend on a PC and connect it to my phone?

On the PC, unzip WindSend-linux-x64-S-Rust-v*.zip on Linux or the Windows x64 zip on Windows and run the executable, which writes a default config.yaml and starts a tray icon. On the phone, install the app, tap the plus button to configure, enable quick pairing on the PC, and tap search several times until the secret key is filled in automatically.

### What should I do if automatic pairing fails between WindSend and my phone?

The documentation states that in most cases a failed quick pairing means the network between the devices is not connected, and you should try again using a phone hotspot. The manual alternative is to copy secretKeyHex from config.yaml and the contents of tls/ca_cert.pem into the app configuration by hand.

### Can WindSend work when my phone and computer are on different networks?

Yes, through one of two documented routes. You can use an intranet penetration tool such as Tailscale and replace the computer IP with the assigned one, or you can self-host a relay server using the separate WindSend-Relay repository, then set relayServerAddress, relaySecretKey and enableRelay in config.yaml and restart the app.

## Sources

- [doraemonkeys/WindSend on GitHub](https://github.com/doraemonkeys/WindSend)
- [Issues](https://github.com/doraemonkeys/WindSend/issues)
- [License: MIT](https://github.com/doraemonkeys/WindSend/blob/main/LICENSE)
- [README](https://github.com/doraemonkeys/WindSend/blob/main/README.md)
- [Releases](https://github.com/doraemonkeys/WindSend/releases)

---

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