Mousehop

Mousehop is a fork of lan-mouse by Ferdinand Schober (feschber) and its contributors. Forked in April 2026 and rebranded as Mousehop in May 2026, it is a modified version distributed under the same GNU GPL-3.0-or-later license. Huge thanks to the original author and contributors — see NOTICE for attribution details.

Mousehop is a cross-platform mouse and keyboard sharing software similar to universal-control on Apple devices. It allows for using multiple PCs via a single set of mouse and keyboard. This is also known as a Software KVM switch.

Goal of this project is to be an open-source alternative to proprietary tools like Synergy 2/3, Share Mouse and other open source tools like Deskflow or Input Leap (Synergy fork).

Focus lies on performance, ease of use and a maintainable implementation that can be expanded to support additional backends for e.g. Android, iOS, ... in the future.

blazingly fast™ because it's written in rust.

• Now with a gtk frontend

Encryption

Mousehop encrypts all network traffic using the DTLS implementation provided by WebRTC.rs. There are currently no mitigations in place for timing side-channel attacks.

OS Support

Most current desktop environments and operating systems are fully supported, this includes

• GNOME >= 45
• KDE Plasma >= 6.1
• Most wlroots based compositors, including Sway (>= 1.8), Hyprland and Wayfire
• Windows
• MacOS

Caveats / Known Issues

Important

• X11 currently only has support for input emulation, i.e. can only be used on the receiving end.

• Sway / wlroots: Wlroots based compositors without libei support on the receiving end currently do not handle modifier events on the client side. This results in CTRL / SHIFT / ALT / SUPER keys not working with a sending device that is NOT using the layer-shell backend

• Wayfire: If you are using Wayfire, make sure to use a recent version (must be newer than October 23rd) and add shortcuts-inhibit to the list of plugins in your wayfire config! Otherwise input capture will not work.

• Windows: The mouse cursor will be invisible when sending input to a Windows system if there is no real mouse connected to the machine.

For more detailed information about os support see Detailed OS Support

Android & IOS

A proof of concept for an Android / IOS Application by rohitsangwan01 can be found here. It can be used as a remote control for any device supported by Mousehop.

Installation

Mousehop is a young fork and is not yet packaged in distribution repositories (Arch, Fedora, nixpkgs). Until then, install from a release binary, the Nix flake, or build from source.

Nix (flake)

• flake: README.md

MacOS

• Download the .dmg for your Mac (Intel or Apple Silicon) from the releases page
• Open the .dmg and drag Mousehop.app into Applications
• Launch the app — release builds are signed with a Developer ID and notarized by Apple, so it opens with no Gatekeeper prompt
• Use the menu bar item to open the settings window or quit Mousehop. Bundled macOS builds run as a menu bar app and do not keep a Dock icon visible.
• Grant accessibility permissions in System Settings

Manual Installation

First make sure to install the necessary dependencies.

Precompiled release binaries for Windows, MacOS and Linux are available in the releases section. For Windows, the depenedencies are included in the .zip file, for other operating systems see Installing Dependencies.

Alternatively, the mousehop binary can be compiled from source (see below).

Installing desktop file, app icon and firewall rules (optional)

# install mousehop (replace path/to/ with the correct path)
sudo cp path/to/mousehop /usr/local/bin/

# install app icon
sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
sudo cp mousehop-gtk/resources/com.mousehop.Mousehop.svg /usr/local/share/icons/hicolor/scalable/apps

# update icon cache
gtk-update-icon-cache /usr/local/share/icons/hicolor/

# install desktop entry
sudo mkdir -p /usr/local/share/applications
sudo cp com.mousehop.Mousehop.desktop /usr/local/share/applications

# when using firewalld: install firewall rule
sudo cp firewall/mousehop.xml /etc/firewalld/services
# -> enable the service in firewalld settings

Instead of downloading from the releases, the mousehop binary can be easily compiled via cargo or nix:

Compiling and installing manually:

# compile in release mode
cargo build --release

# install mousehop
sudo cp target/release/mousehop /usr/local/bin/

Compiling and installing via cargo:

# will end up in ~/.cargo/bin
cargo install --git https://github.com/jondkinney/mousehop

Compiling and installing via nix:

# you can find the executable in result/bin/mousehop
nix-build

Conditional compilation

Support for other platforms is omitted automatically based on the active rust toolchain.

Additionally, available backends and frontends can be configured manually via cargo features.

E.g. if only support for sway is needed, the following command produces an executable with support for only the layer-shell capture backend and wlroots emulation backend:

cargo build --no-default-features --features layer_shell_capture,wlroots_emulation

For a detailed list of available features, checkout the Cargo.toml

Development

Git pre-commit hook

This repository includes a local git hooks directory .githooks/ with a pre-commit script that enforces formatting, lints, and tests before allowing a commit. It is optional to enable it, but it will prevent you from committing code with failing unit tests or that needs clippy/fmt fixes. To enable the hook locally:

1. Make the hook executable:

chmod +x .githooks/pre-commit

2. Point git to the hooks directory (one-time per clone):

git config core.hooksPath .githooks

The pre-commit script runs cargo fmt --all (and fails if files were modified), cargo clippy --workspace --all-targets --all-features -- -D warnings, and cargo test --workspace --all-features.

Dependencies & Compiling from Source

MacOS

# Install dependencies
brew install libadwaita pkg-config imagemagick
cargo install cargo-bundle
# Create the macOS icon file
scripts/makeicns.sh
# Create the .app bundle
cargo bundle
# Copy all dynamic libraries into the bundle, and update the bundle to find them there
scripts/copy-macos-dylib.sh

Ubuntu and derivatives

sudo apt install libadwaita-1-dev libgtk-4-dev libx11-dev libxtst-dev

Arch and derivatives

sudo pacman -S libadwaita gtk libx11 libxtst

Fedora and derivatives

sudo dnf install libadwaita-devel libXtst-devel libX11-devel

Nix

nix-shell .

Nix (flake)

nix develop

Windows

• First install Rust.

• Then follow the instructions at gtk-rs.org

TLDR:

Build gtk from source

• The following commands should be run in an admin power shell instance:

# install chocolatey
Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# install gvsbuild dependencies
choco install python git msys2 visualstudio2022-workload-vctools

• The following commands should be run in a regular power shell instance:

# install gvsbuild with python
python -m pip install --user pipx
python -m pipx ensurepath

• Relaunch your powershell instance so the changes in the environment are reflected.

pipx install gvsbuild

# build gtk + libadwaita
gvsbuild build gtk4 libadwaita librsvg adwaita-icon-theme

• Make sure to add the directory C:\gtk-build\gtk\x64\release\bin to the PATH environment variable. Otherwise the project will fail to build.

To avoid building GTK from source, it is possible to disable the gtk frontend (see conditional compilation).

Usage

Gtk Frontend

By default the gtk frontend will open when running mousehop.

To connect a device you want to control, simply click the Add button and enter the hostname of the device.

On the remote device, authorize your local device for incoming traffic using the Authorize button under the "Incoming Connections" section. The fingerprint for authorization can be found under the general section of your local device. It is of the form "aa:bb:cc:..."

Authorized devices can be persisted using the configuration file (see Configuration).

If the device still can not be entered, make sure you have UDP port 4252 (or the one selected) opened up in your firewall.

Command Line Interface

The cli interface can be accessed by passing cli as a commandline argument. Use

mousehop cli help

to list the available commands and

mousehop cli <cmd> help

for information on how to use a specific command.

Daemon Mode

Mousehop can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).

To do so, use the daemon subcommand:

mousehop daemon

Systemd Service

In order to start mousehop with a graphical session automatically, the systemd-service can be used:

Copy the file to ~/.config/systemd/user/ and enable the service:

cp service/mousehop.service ~/.config/systemd/user
systemctl --user daemon-reload
systemctl --user enable --now mousehop.service

Important

Make sure to point ExecStart=/usr/bin/mousehop daemon to the actual mousehop binary (in case it is not under /usr/bin, e.g. when installed manually.

Configuration

To automatically load clients on startup, the file $XDG_CONFIG_HOME/mousehop/config.toml is parsed. $XDG_CONFIG_HOME defaults to ~/.config/.

To create this file you can copy the following example config:

Example config

Tip

key symbols in the release bind are named according to their names in input-event/src/scancode.rs#L172. This is bound to change

# example configuration

# configure release bind
release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]

# optional port (defaults to 4252)
port = 4252

# list of authorized tls certificate fingerprints that
# are accepted for incoming traffic
[authorized_fingerprints]
"bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"

# define a client on the right side with host name "iridium"
[[clients]]
# position (left | right | top | bottom)
position = "right"
# hostname
hostname = "iridium"
# activate this client immediately when mousehop is started
activate_on_startup = true
# optional list of (known) ip addresses
ips = ["192.168.178.156"]

# define a client on the left side with IP address 192.168.178.189
[[clients]]
position = "left"
# The hostname is optional: When no hostname is specified,
# at least one ip address needs to be specified.
hostname = "thorium"
# ips are optional: peers running mousehop advertise every interface
# over mDNS, so a hostname alone discovers them all
# optional port
port = 4252
# optional base policy: "auto" (default) or "fastest"
mode = "fastest"

Where left can be either left, right, top or bottom.

Multi-homed peers (interfaces, latency, locking)

A peer with more than one address — e.g. a laptop wired and on Wi-Fi at the same time — advertises every interface's address over mDNS, so mousehop discovers them all without you pinning anything. By default it races them and uses whichever connects first, which can flap onto a slow Wi-Fi path. The GUI's Connection Address dropdown lists every candidate as <ip> — Wired/Wi-Fi · <latency> (the interface kind is advertised by the peer; latency is a lightweight background probe), and offers:

• Auto (default): race all candidates, biased toward the mDNS-advertised primary interface.
• Fastest: prefer the lowest-latency reachable candidate and stay on it (sticky). It only switches when the active path dies or another is sustainedly and substantially faster, so it never flaps. Fully portable — works on any network with no configuration.
• A specific address: pin the connection to that IP on the current network only. The pin is sticky (no silent failover) and is scoped by a network fingerprint (the default-gateway MAC), so a pin set at home doesn't break connectivity on a different LAN — there, mousehop falls back to the base mode.

mode persists on the [[clients]] entry; per-network pins persist under a network_locks table (keyed by network fingerprint, numeric IPs only). Discovered addresses, latency, and interface labels are live runtime state and are not persisted.

Clipboard Sync

Optional bi-directional clipboard text sync between paired peers. Disabled by default; enable per pair from the GUI or by editing config.toml.

Per-pair gates

Each direction is independently gated. Both ends must opt in for clipboard text to flow that way:

• Outgoing: clipboard_send on each [[clients]] entry — when true, copies on this device propagate to that peer.
• Incoming: clipboard_receive on each [authorized_fingerprints] entry — when true, clipboard text from that peer is applied to this device's clipboard.

Defaults are false. Existing pairs see no behavior change on upgrade.

Limitations

• Text only. No images, files, RTF/HTML, or multi-format pasteboard.
• 4 KiB max payload (originator fingerprint + content + length prefixes, conservative against typical UDP MTU). Larger copies are dropped at the sender with a debug log; the local clipboard is unaffected.
• UTF-8 only. Invalid byte sequences are rejected.
• Polling-based change detection (no native pasteboard event API exists on macOS), so very rapid recopies within a single poll tick may be coalesced.

App-source suppression

A per-OS suppression list lets you mark applications whose clipboard contents must never propagate (password managers, sensitive editors, Apple Messages, etc.). The frontmost app at the moment of copy is checked against the host-OS slot of clipboard_suppress_apps:

[clipboard_suppress_apps]
macos = ["com.1password.1password", "com.apple.MobileSMS"]
windows = ["1Password.exe"]
linux_wayland = ["org.keepassxc.KeePassXC"]
linux_x11 = ["KeePassXC"]

Each machine reads/writes only the slot matching its own OS — the others round-trip untouched, so a single config can be shared across machines (dotfiles / Syncthing / etc.) without any one machine bleeding identifiers into the wrong section.

The GUI exposes this via Clipboard Privacy → Manage: a searchable picker of the apps currently running on this device (with name + icon), plus a list of currently-suppressed apps with one-click removal.

Automatic suppression on macOS

In addition to the user list, macOS clipboards stamped with the org.nspasteboard.ConcealedType UTI (the community convention used by 1Password, Bitwarden, KeePassXC, and most modern password managers) are auto-suppressed without needing a manual entry.

Loop prevention for 3+ peer fan-out

The wire frame carries the originator's TLS certificate fingerprint. The Service tracks (originator_fp, content_hash) for 1 second to prevent rebroadcast cycles in N-peer topologies (A→B→C won't echo back to A).

Roadmap

• Graphical frontend (gtk + libadwaita)
• respect xdg-config-home for config file location.
• IP Address switching
• Liveness tracking Automatically ungrab mouse when client unreachable
• Liveness tracking: Automatically release keys, when server offline
• MacOS KeyCode Translation
• Libei Input Capture
• MacOS Input Capture
• Windows Input Capture
• Encryption
• X11 Input Capture
• Latency measurement and visualization
• Bandwidth usage measurement and visualization
• Clipboard support (text, per-pair, with app-source suppression)

Detailed OS Support

In order to use a device for sending events, an input-capture backend is required, while receiving events requires a supported input-emulation and input-capture backend.

A suitable backend is chosen automatically based on the active desktop environment / compositor.

The following sections detail the emulation and capture backends provided by mousehop and their support in desktop environments / operating systems.

Input Emulation Support

Desktop / Backend	wlroots	libei	remote-desktop portal	windows	macos	x11
Wayland (wlroots)	✔️
Wayland (KDE)		✔️	✔️
Wayland (Gnome)		✔️	✔️
Windows				✔️
MacOS					✔️
X11						✔️

• wlroots: This backend makes use of the wlr-virtual-pointer-unstable-v1 and virtual-keyboard-unstable-v1 protocols and is supported by most wlroots based compositors.
• libei: This backend uses libei and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
• xdp: This backend uses the freedesktop remote-desktop-portal and is supported on GNOME and Plasma.
• x11: Backend for X11 sessions.
• windows: Backend for Windows.
• macos: Backend for MacOS.

Input Capture Support

Desktop / Backend	layer-shell	libei	windows	macos	x11
Wayland (wlroots)	✔️
Wayland (KDE)	✔️	✔️
Wayland (Gnome)		✔️
Windows			✔️
MacOS				✔️
X11					WIP

• layer-shell: This backend creates a single pixel wide window on the edges of Displays to capture the cursor using the layer-shell protocol.
• libei: This backend uses libei and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
• windows: Backend for input capture on Windows.
• macos: Backend for input capture on MacOS.
• x11: TODO (not yet supported)