Everyday work has become increasingly mobile and digital. We jump between laptops, phones and tablets all the time, yet moving data between them still feels like a chore. Apple’s ecosystem demonstrates how seamless it could be: AirDrop makes file transfer trivial and a universal clipboard syncs text and images across devices. When my friends Jan Schäfer and Arshia Reisi and I were brainstorming ideas for our final year project, we realised that the rest of the world deserved the same experience. That idea became LinkWave, a cross‑platform platform that brings AirDrop‑style functionality to Windows, Android, macOS and iOS.
Modern creative workflows involve frequent file transfers, editing text on one device and pasting it on another, and constantly switching between devices. Existing solutions such as KDE Connect work only within local networks and often require manual pairing. Cloud services like Google Drive or Dropbox add multiple steps and rely on internet connections. We wanted a solution that:
LinkWave installs as a native application on each platform and automatically detects other LinkWave devices nearby. Once devices are discovered, all features work without further configuration. The main features are:
Devices advertise themselves and discover others using Bonjour/mDNS on the local network. This mechanism broadcasts a service record (_linkwave._tcp) with metadata (device name, type and port) and listens for matching records. When a new LinkWave device appears, it automatically shows up in the device list. Unlike KDE Connect, there is no manual pairing step.
Files of any size can be transferred directly between devices over an encrypted TCP connection. The workflow mirrors AirDrop: select Share on the source device, choose LinkWave, pick a target device and accept the transfer on the recipient. Behind the scenes, LinkWave performs a secure TLS handshake, sends a request describing the file (name, size and checksum), waits for the recipient to accept, then streams the file in chunks. Transfers work even without an internet connection because devices talk directly over the local network. The protocol is symmetric—every platform can both send and receive.
The clipboard feature synchronises copied text or images. When you copy content on one device, LinkWave detects the change and sends a notification to your other devices logged into the same account. Accepting the share automatically inserts the text or image into the clipboard on the other device. On macOS and Windows the clipboard is monitored continuously; on iOS and Android the clipboard share is triggered via a Share or Process Text action because the operating systems restrict background clipboard access. All clipboard data is encrypted and never stored on external servers.
To prevent anyone on the same network from pushing data to your devices, LinkWave requires a user account. The account is authenticated using JSON Web Tokens and optional two‑factor authentication. Clipboard sharing only works between devices signed into the same account. All communication is secured with TLS, and files or clipboard content are encrypted end‑to‑end.
To truly showcase what LinkWave can do, we recorded a short demo highlighting the seamless connection between macOS, Windows, Android and iOS. Watch how devices instantly discover each other, transfer files securely, and even synchronize clipboards — all without any internet connection.
One of the most rewarding parts of LinkWave was creating fully native applications for each operating system. We wanted the apps to feel like part of the platform rather than clunky cross‑platform ports.
The iOS app is built with Swift and SwiftUI, Apple’s declarative UI framework. It supports iOS 17 and later and offers multiple entry points:
Option 1: Share file directly from the app.
Option 2: Share content from any app using the system share extension.
Select a nearby device from the share extension.
The macOS client is also written in Swift and SwiftUI and runs on macOS 14+. It offers the same features as the iOS app plus some Mac‑specific conveniences:
The Mac Share extension can be used to share files via LinkWave.
On Android we used Kotlin and Google’s declarative Jetpack Compose framework. The app runs on Android 12+ and consists of three components:
1. Select LinkWave from the share menu.
2. Send to nearby devices.
Use Clipboard Share via the context menu.
The Windows application is written in C# with WinUI 3. It follows the MVVM pattern and consists of three projects: a UI project, a core project and a backend library. Windows users enjoy the same features as Mac users, including file transfer, clipboard sync, a share target and a system‑tray icon for quick access. The app is packaged as an .msix installer for easy distribution.
The Windows Share Integration can be used to share files via LinkWave.
LinkWave is open source — you can explore how everything works, from the peer-to-peer encryption layer to the native UIs on each platform.
If you want to try it yourself:
If you’d like to dive deeper into the technical details, implementation, and architecture of LinkWave, you can also read our full diploma thesis.
The paper covers every layer of LinkWave — from Bonjour-based device discovery and encrypted peer-to-peer protocols to the SwiftUI, Jetpack Compose, WinUI, and SvelteKit frontends — along with detailed UML diagrams and architectural breakdowns.
At the heart of LinkWave is a client–server architecture. Each client is responsible for device discovery and peer‑to‑peer communication, while a central backend provides authentication and manages user accounts and device metadata. The key components are:
Bonjour/mDNS for discovery: All clients advertise a _linkwave._tcp service and listen for the same service to detect nearby devices. Service metadata includes the device name, operating system and a dynamically chosen port. Once a device is discovered, clients establish a direct TLS‑encrypted TCP connection for transferring data.
Encrypted peer‑to‑peer protocol: File and clipboard transfers follow a request–response pattern. The sender announces its intent (e.g., FILE_SHARE or CLIPBOARD_SHARE), the recipient accepts (ACK) or rejects (RST), metadata about the data is exchanged, and then the data is streamed in chunks. The protocol is symmetrical and implemented natively on each platform.
Backend services: Our backend exposes a GraphQL API (built with Hot Chocolate on .NET) for user registration, login, device management and authentication. It stores user and device information in a PostgreSQL database and handles password hashing with bcrypt. The backend is containerised and hosted on Azure behind an Nginx reverse proxy, which also terminates TLS and enforces security headers.
Implementing Bonjour on four different platforms was one of the biggest challenges. Each operating system exposes mDNS differently:
Device Discovery Network Diagram
File transfers use asynchronous TCP streams and are chunked to avoid blocking the UI. On Swift, we use NWConnection.send/receive callbacks; in Kotlin we rely on coroutines and Socket.getOutputStream/InputStream; and in C# we use asynchronous SslStream operations. All platforms calculate a checksum to verify integrity and report progress back to the UI. Recipients receive a push notification or system notification and can accept or decline the transfer.
File Transfer Network Diagram
Clipboard integration required platform‑specific tricks. On macOS we poll NSPasteboard.general.changeCount every couple of seconds; on Windows we hook into System.Windows.Clipboard events. On Android and iOS we rely on the operating systems’ share and process‑text APIs because direct background access is blocked. Once we detect a change, we send a CLIPBOARD_SHARE request to all devices logged into the same account. The target decodes the content and writes it to the local clipboard using the respective API.
Clipboard Synchronization Diagram
Security was a central consideration. We enforce TLS across all peer connections. The server uses industry‑best ciphers and stores passwords hashed with bcrypt. Devices are identified by their certificate fingerprint, which is stored in the database. Only devices authenticated with the same account can communicate; untrusted devices simply do not appear in your device list. Our Nginx reverse proxy uses strict SSL configurations and security headers to mitigate common web attacks.
TLS Handshake Diagram
Building LinkWave taught me more than any school assignment. I honed skills in network programming, encryption, cross‑platform UI design and cloud deployment. Collaborating with Jan and Arshia forced us to divide work by platform yet maintain a consistent user experience. We built a GraphQL API from scratch, designed an authentication system, created polished interfaces with SwiftUI, Jetpack Compose and WinUI, and wrote code that continues to run in the background reliably across platforms.
What began as a simple desire to make my MacBook play nicely with my Android phone became a fully fledged connectivity platform. LinkWave bridges the gap between ecosystems and makes device heterogeneity invisible. It is fast, secure and easy to use thanks to automatic device discovery, encrypted direct connections and thoughtful user interfaces. I am proud of what we built and how much we learned along the way. If you want to try LinkWave yourself, visit linkwave.org or browse the open‑source code on GitHub. Feel free to contact me for more details or collaboration opportunities!