Use this command to install UniClipboard with WinGet:
winget install --id=UniClipboard.UniClipboard -e
UniClipboard is a cross-device clipboard synchronization tool designed to enable real-time text, image, and file sharing across all your devices — locally or over the internet. Built with privacy in mind, it operates on a peer-to-peer network without relying on central servers or cloud storage.
Key Features:
Real-Time Sync: Copy on one device, paste anywhere else instantly.
End-to-End Encrypted: Data is encrypted both in transit and at rest.
Cross-Platform Compatibility: Works seamlessly across Windows, macOS, Linux, iOS, and Android.
File Transfer Support: Sync text, images, and files of any size effortlessly.
Encrypted Search: Locally index and search your clipboard history securely.
Winget Installation: Easily deploy using the winget command line for quick setup.
Target Audience and Benefits:
Ideal for privacy-conscious users and teams looking to collaborate seamlessly across devices. UniClipboard provides a secure, efficient way to share content without compromising on privacy or performance.
> Copy on one device. Paste on another — even across the internet.
>
> No cloud account. No third-party servers. Your clipboard never leaves your devices in a form anyone else can read.
UniClipboard is a privacy-first, cross-device clipboard synchronization tool.
It enables seamless and secure syncing of text, images, and files across multiple devices, whether on the same Wi-Fi or across different networks. Data is encrypted both in transit and at rest, and decrypted only on the user’s devices—neither servers nor the network layer can ever access plaintext data.
Desktop ↔ desktop — real-time, bidirectional clipboard sync between two computers.
Current mobile compatibility demo — share a screenshot from your phone to your desktop. (click to expand)
> [!WARNING]
> UniClipboard is currently under active development and may have unstable or missing features. Feel free to try it out and provide feedback!
Cross-platform: First-class support on Windows, macOS, and Linux. The current iOS and Android releases connect through the compatibility mode described below; the target architecture makes desktop, iOS, Android, and HarmonyOS equal P2P peers.
Cross-network sync: Desktop peers sync on the same Wi-Fi or across the internet with automatic NAT traversal and encrypted relay fallback. Mobile products may also expose LAN HTTP as a separate, user-selected compatibility channel; it never replaces or automatically takes over from the shared P2P core.
Mobile app: Install the UniClipboard mobile app for iOS (TestFlight public beta) and Android (download APK). The bundled iOS Shortcut remains available as part of the separately versioned LAN compatibility channel. Full P2P capability is delivered and validated independently.
Encrypted spaces: Devices join a shared "space" with one invitation code + passphrase — no cloud account, no email, just two devices agreeing to trust each other.
Local full-text search: Search your full history in milliseconds, even with tens of thousands of entries — and the index itself stays encrypted on disk.
Text, images, and files: Copy on one device, paste on another. Large files use streaming transfer so they don't have to fit in memory.
Quick Panel: Keyboard-shortcut overlay with inline preview for text, links, images, code, and files — designed to feel like part of the OS clipboard, not a separate app you context-switch into.
Command-line tool: A uniclip CLI mirrors the GUI flow and works headlessly — built for terminals, SSH sessions, scripts, and tmux workflows.
Secure encryption: XChaCha20-Poly1305 AEAD keeps data encrypted in transit and at rest — even the relay only sees ciphertext.
Multi-device management: Manage paired devices, presence, and per-device sync preferences. Revoke a lost device from any other paired one — sync stops including it immediately.
Installation
Download from Releases
Visit the GitHub Releases page to download the installation package for your operating system.
One-line install script (Linux / macOS)
Don't want to pick a package by hand? One command does it:
macOS — downloads .app.tar.gz, extracts it, and moves UniClipboard.app into /Applications (escalates with sudo if the directory isn't writable; pass --prefix "$HOME/Applications" for a user-level install).
Linux — with sudo, installs .deb via apt or .rpm via dnf/yum; otherwise falls back to AppImage in ~/.local/bin with a .desktop entry (no root needed).
Common flags:
# Pin a specific version
curl -fsSL https://uniclipboard.app/install.sh | bash -s -- --version v0.9.0
# Force AppImage (rootless even when sudo is available)
curl -fsSL https://uniclipboard.app/install.sh | bash -s -- --format appimage
Uninstall with the matching script:
# Remove the app only, keep data and config
curl -fsSL https://raw.githubusercontent.com/UniClipboard/UniClipboard/main/scripts/uninstall.sh | bash
# Full wipe — also removes data directories, config, and cache
curl -fsSL https://raw.githubusercontent.com/UniClipboard/UniClipboard/main/scripts/uninstall.sh | bash -s -- --purge
# Preview what would be removed without deleting anything
curl -fsSL https://raw.githubusercontent.com/UniClipboard/UniClipboard/main/scripts/uninstall.sh | bash -s -- --dry-run
> Update behavior matches the manual download paths below: .deb / .rpm installs are not picked up by the in-app updater — re-run the script or use your system package manager. AppImage on Linux and .app on macOS continue to update from inside the app.
Linux
Each release ships .deb, .rpm, and .AppImage artifacts for both x86_64 and aarch64 (where supported).
Fedora / RHEL / openSUSE — via COPR (recommended, auto-updating)
sudo dnf copr enable mkdir700/uniclipboard-alpha # alpha channel; or mkdir700/uniclipboard for stable
sudo dnf install uniclipboard
After enabling, sudo dnf upgrade will pick up new releases automatically.
Or download a single .rpm / .deb / AppImage from the Releases page:
> Packaged installs (COPR / one-shot rpm / deb) do not auto-update from inside the app — use dnf upgrade / apt upgrade against your package source. The AppImage is what the in-app updater uses on Linux.
brew tap UniClipboard/tap
# Homebrew 6.0+ requires you to trust third-party taps before it will load
# their formulae/casks. Skip this and you'll hit
# "Refusing to load ... from untrusted tap". It only needs to run once.
brew trust UniClipboard/tap
# Desktop app (.app bundle)
brew install --cask uniclipboard
# CLI only — installs the `uniclip` command
brew install uniclipboard
Or install in a single command without tapping first (still trust the tap once):
The cask and the formula can coexist — install both if you want the GUI plus the uniclip command.
Build from Source
# Clone the repository (`--recurse-submodules` pulls the iroh-blobs fork
# under src-tauri/vendor/iroh-blobs/; without it `cargo build` fails).
git clone --recurse-submodules https://github.com/UniClipboard/UniClipboard.git
cd UniClipboard
# Install dependencies
bun install
# Start development mode
bun tauri dev
# Build application
bun tauri build
Usage
First Device (Create a Space)
Launch the app and choose Create a Space
Set an encryption passphrase — this protects all data inside the space
Done. Copied content is stored encrypted in this space.
Adding More Devices (Join via Invitation)
On an existing device, open the Devices page and generate an invitation code (short-lived, valid for several minutes)
On the new device, choose Join an existing space, enter the invitation code together with the space passphrase
Once verified, the device joins and syncing starts automatically.
> Already set up and want to move to another space? Use Switch space from the Devices page (or run uniclip join --switch from the CLI) — your local clipboard history is re-encrypted and migrated. Without --switch, uniclip join takes the non-destructive redeem / re-pair path and does not switch spaces.
Pair a Mobile Device (current compatibility mode)
The UniClipboard mobile app is a single client for both iOS (now in TestFlight public beta) and Android (APKs in releases). Current releases use a time-limited HTTP compatibility mode: the desktop daemon exposes a small HTTP service, and the phone reads/writes the clipboard against it. This path receives only security, compatibility, and migration fixes; the target architecture makes mobile devices full P2P space peers.
On the desktop, open Devices → Mobile sync, enable it, and pick the LAN IPv4 the phone will reach (don't print 0.0.0.0 / Auto onto a phone screen).
Click Add device to generate a QR code with the listener URL, username, and one-time password.
iPhone — install TestFlight from the App Store, then open https://testflight.apple.com/join/nyNQ8dQe to accept the invite and install the UniClipboard iOS App; enter the desktop's URL + credentials in the app. The bundled iOS Shortcut (installed by scanning the QR) still works as a fallback.
> ⚠️ If TestFlight shows a certificate error, or the Install button spins because TestFlight can't reach App Store Connect, temporarily disable your proxy / VPN client (Loon, Surge, Clash, etc. — including global rules, TUN, HTTPS decryption / MitM) so TestFlight goes direct. Re-enable it after the app is installed.
Copy on either side; the other side picks it up over Wi-Fi.
Compatibility-mode limitations:
Current releases are not P2P — the compatibility client does not NAT-hole-punch or use the relay. It works on the LAN out of the box, and reaches across networks via a self-hosted server node (public HTTPS) or a Tailscale / VPN overlay.
Plain HTTP + Basic Auth at the listener — put it behind a TLS reverse proxy (e.g. a server node) for HTTPS; native listener TLS is planned for v2. Only expose the bare listener on networks you trust.
Compatibility clients are not space peers — they do not get a node ID or read the encrypted history database. This limitation belongs to the migration path, not the shared P2P core.
iOS has no silent background sync — iOS doesn't grant apps a general-purpose background clipboard hook, so the iOS app receives/sends only while it's in the foreground (or via notification tap). This is a platform restriction, not a missing feature; even WeChat's keyboard can only sync clipboard at the moment it's invoked. See FAQ — iOS background sync.
Dashboard — Clipboard history with full-text search and detailed preview
Quick Panel — Keyboard-shortcut overlay for fast clipboard access
Devices — Manage paired desktops and mobile clients, presence, invitation codes, QR pairing, switch spaces
Settings — General, sync, security, network, storage, and search-index options
Advanced Features
How it Works
flowchart LR
subgraph A["Device A (your laptop)"]
direction TB
CC["Ctrl+C"] --> EA["encrypt(your key)"]
end
subgraph B["Device B (your desktop)"]
direction TB
DB["decrypt(your key)"] --> CV["Ctrl+V"]
end
EA -->|"P2P hole-punch"| DB
EA -.->|"falls back"| R["Relay(sees onlyencrypted bytes)"]
R -.-> DB
Pairing: Devices exchange a public key once, locally — no cloud account, no email.
Transport: Direct connection when devices can reach each other (same Wi-Fi or via NAT hole-punching across home/office networks); falls back to an encrypted relay otherwise.
Encryption: Payload encryption is independent of the transport — even a malicious relay only sees ciphertext.
Storage: Local history is encrypted at rest, and the search index is encrypted too.
Resilience: Connections recover automatically after Wi-Fi switches, sleep/wake, or brief disconnects — no re-pairing required.
Command-line Tool
The uniclip CLI mirrors the GUI flow and works headlessly (e.g. on servers):
uniclip init # Create a new encrypted space on this device
uniclip invite # Generate a short-lived invitation code
uniclip join # Join a space (re-pair, non-destructive)
uniclip join --switch # Switch to another space (re-encrypts local history)
uniclip members # List paired devices and presence
uniclip send "hello" # Send clipboard content to other devices
uniclip watch # Stream incoming clipboard events
uniclip status / start / stop # Daemon lifecycle
Privacy & Security
What we collect — Anonymous telemetry to help improve the app — never your clipboard content or any of your personal data. You can turn it off anytime in Settings, and we fully respect that choice.
What a relay can see — Encrypted bytes and connection metadata (source / destination peer IDs). It can't decrypt your content, ever.
What's stored on disk — An encrypted SQLite database, plus a search index designed so full-text search works without exposing plaintext.
If you lose a device — Revoke it from any other paired device. Future syncs will exclude it immediately.
You can audit it — Every line, including the cryptography, lives on GitHub. Trust the code, not the marketing.
Cryptography details
End-to-end encryption: Data is encrypted in transit between devices and remains encrypted at rest in local storage.
XChaCha20-Poly1305 AEAD — modern authenticated encryption.
24-byte random nonce effectively eliminates nonce-reuse risk
32-byte (256-bit) encryption key
Provides ciphertext integrity and authenticity verification
Argon2id key derivation — securely derives encryption keys from your passphrase.
Key Encryption Key (KEK) is derived from your passphrase via Argon2id
KEK is stored in the system keyring (macOS Keychain, Windows Credential Manager, Linux Secret Service)
MasterKey is encrypted and stored in a KeySlot file
Per-space isolation: Each space has its own MasterKey; switching to another space re-encrypts local history under the new space's MasterKey.
Device authorization: Precise control over each paired device's access permissions.
FAQ
Why not just use iCloud Universal Clipboard?
If you only use Apple devices, don't need history, and fully trust Apple's closed-source end-to-end encryption — iCloud is fine. The moment you add a Windows or Linux machine, want a searchable history, or want to verify the encryption yourself, you need something else.
Why not a self-hosted clipboard sync (e.g. ClipCascade)?
Self-hosted means you have to run a server. UniClipboard works out of the box — direct P2P first, encrypted relay only as a fallback. You never have to operate any infrastructure.
Does it work fully offline / LAN-only?
Yes. Devices on the same Wi-Fi connect directly without going through the relay. Even if the relay is unreachable, devices on the same network keep syncing.
Where does my clipboard history actually live?
Only on your devices. Local storage is encrypted at rest with a key that never leaves the device's system keyring. No UniClipboard server ever receives or stores your clipboard content.
Is there a mobile app?
Yes — the UniClipboard mobile app covers both iOS and Android. Current releases use the time-limited HTTP compatibility mode described above; they work on the LAN or through a server node/Tailscale, but do not perform P2P NAT traversal themselves. The target mobile architecture uses the same full P2P core as desktop and HarmonyOS. See Pair a Mobile Device for the current setup flow.
Contributing
Contributions of all kinds are welcome! Please read CONTRIBUTING.md for the full development setup, branching strategy, commit conventions, and PR process.
Quick start:
Fork this repository
Create your feature branch (git checkout -b feature/amazing-feature)
-lightgrey?style=flat-square&logo=apple&logoColor=white){kind=icon}
-3DDC84?style=flat-square&logo=android&logoColor=white){kind=icon}
