Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/UniClipboard/UniClipboard

Real-time clipboard sync across all your devices — local-first, peer-to-peer, and end-to-end encrypted. No account. No cloud dependency. No central server.
https://github.com/UniClipboard/UniClipboard

clipboard-manager clipboard-sync clipboardsync cross-platform e2ee efficientnet linux local-first macos p2p tauri-app tauri2 tools windows

Last synced: 3 days ago
JSON representation

Real-time clipboard sync across all your devices — local-first, peer-to-peer, and end-to-end encrypted. No account. No cloud dependency. No central server.

Awesome Lists containing this project

README 

          




  
UniClipboard


  

    Windows

  

  

    MacOS

  

  

    Linux

  

  

    iOS

  

  

    Android

  



  


    

      

    

    

      

    

    

      

    

  






English | 简体中文


Who maintains this project? (About & Trust)



## Project Overview



> **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.





  UniClipboard desktop screenshot






  

  


  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!



## Table of Contents



- [Features](#features)

- [Installation](#installation)

  - [Download from Releases](#download-from-releases)

  - [One-line install script (Linux / macOS)](#one-line-install-script-linux--macos)

  - [Linux](#linux)

  - [Homebrew (macOS)](#homebrew-macos)

  - [Build from Source](#build-from-source)

- [Usage](#usage)

  - [First Device (Create a Space)](#first-device-create-a-space)

  - [Adding More Devices (Join via Invitation)](#adding-more-devices-join-via-invitation)

  - [Pair a Mobile Device (current compatibility mode)](#mobile-companion-lan)

  - [Main Pages](#main-pages)

- [Advanced Features](#advanced-features)

  - [How it Works](#how-it-works)

  - [Command-line Tool](#command-line-tool)

  - [Privacy & Security](#privacy--security)

- [FAQ](#faq)

- [Contributing](#contributing)

- [License](#license)

- [Acknowledgments](#acknowledgments)

- [Community](#community)



## Features



- **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](https://github.com/UniClipboard/UniClip)** for **iOS** ([TestFlight public beta](https://testflight.apple.com/join/nyNQ8dQe)) and **Android** ([download APK](https://github.com/UniClipboard/UniClip/releases/latest)). 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](https://github.com/UniClipboard/UniClipboard/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:



```bash

curl -fsSL https://uniclipboard.app/install.sh | bash

```



The script detects OS and CPU automatically:



- **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:



```bash

# 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:



```bash

# 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)**



```bash

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:**



```bash

# Debian / Ubuntu

sudo dpkg -i uniclipboard__amd64.deb

sudo apt-get install -f                                 # resolve missing deps if any



# Fedora / RHEL / openSUSE (one-shot, no COPR)

sudo dnf install ./UniClipboard--1.x86_64.rpm



# AppImage (any distro)

chmod +x UniClipboard__amd64.AppImage

./UniClipboard__amd64.AppImage

```



> 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.



### Homebrew (macOS)



On macOS, install via the official tap [`UniClipboard/homebrew-tap`](https://github.com/UniClipboard/homebrew-tap):



```bash

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):



```bash

brew trust UniClipboard/tap                          # Homebrew 6.0+, one-time

brew install --cask UniClipboard/tap/uniclipboard    # GUI

brew install UniClipboard/tap/uniclipboard           # CLI

```



The cask and the formula can coexist — install both if you want the GUI plus the `uniclip` command.



### Build from Source



```bash

# 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)



1. Launch the app and choose **Create a Space**

2. Set an encryption passphrase — this protects all data inside the space

3. Done. Copied content is stored encrypted in this space.



### Adding More Devices (Join via Invitation)



1. On an existing device, open the **Devices** page and **generate an invitation code** (short-lived, valid for several minutes)

2. On the new device, choose **Join an existing space**, enter the invitation code together with the space passphrase

3. 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](https://github.com/UniClipboard/UniClip)** is a single client for both **iOS** (now in [TestFlight public beta](https://testflight.apple.com/join/nyNQ8dQe)) and **Android** (APKs in [releases](https://github.com/UniClipboard/UniClip/releases/latest)). 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.



1. 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).

2. Click **Add device** to generate a QR code with the listener URL, username, and one-time password.

3. **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.

4. **Android** — install the [**UniClipboard mobile app**](https://github.com/UniClipboard/UniClip) (APK in [releases](https://github.com/UniClipboard/UniClip/releases/latest)) and enter the same URL and credentials.

5. 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](https://www.uniclipboard.app/docs/faq#why-cant-the-ios-app-sync-clipboard-silently-in-the-background-like-the-desktop).



See the [Mobile sync guide](https://www.uniclipboard.app/docs/guides/mobile-sync) for the full setup flow, or the [headless server node guide](https://www.uniclipboard.app/docs/guides/self-host-server-node) to reach your phone over HTTPS from any network.



### Main Pages



- **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



```mermaid

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 only
encrypted 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):



```bash

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.

  - Memory cost: 128 MB · Iterations: 3 · Parallelism: 4 threads

  - Resistant to GPU / ASIC cracking attacks

- **Layered key architecture**:

  - MasterKey encrypts clipboard content

  - 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](https://github.com/UniClipboard/UniClip)** 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](#mobile-companion-lan) for the current setup flow.



## Contributing



Contributions of all kinds are welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for the full development setup, branching strategy, commit conventions, and PR process.



Quick start:



1. Fork this repository

2. Create your feature branch (`git checkout -b feature/amazing-feature`)

3. Commit your changes following the project's [commit conventions](./CONTRIBUTING.md#commit-conventions)

4. Push to the branch (`git push origin feature/amazing-feature`)

5. Open a Pull Request against the `main` branch



## License



This project is licensed under the AGPL-3.0 License - see the [LICENSE](./LICENSE) file for details.



## Acknowledgments



- [Tauri](https://tauri.app) - Cross-platform application framework

- [React](https://react.dev) - Frontend UI development framework

- [Rust](https://www.rust-lang.org) - Safe and efficient backend implementation language

- [iroh](https://www.iroh.computer) - QUIC-based P2P networking that powers cross-network direct connections and blob transfer

- [Tokio](https://tokio.rs) - Asynchronous runtime that drives every networking and I/O path

- [shadcn/ui](https://ui.shadcn.com) - Composable component recipes built on Radix UI

- [Radix UI](https://www.radix-ui.com) - Unstyled, accessible primitives behind the desktop interface

- [Tailwind CSS](https://tailwindcss.com) - Utility-first styling for the entire UI

- [SQLite](https://www.sqlite.org) - Embedded database that stores clipboard history locally



## Community



Join us to chat with other users and the dev team:



  

    QQ Group

    WeChat Group

    Telegram Group

  

  

    QQ Group QR Code

    WeChat Group QR Code

    Telegram Group QR Code

  



---



**Have questions or suggestions?** [Create an Issue](https://github.com/UniClipboard/UniClipboard/issues/new) or contact us to discuss!