How it works

Nikau accesses devices through Linux uinput APIs. Events are sent over UDP using the low-latency QUIC protocol. Any Linux machine should work, including Wayland, X11, and even Linux consoles. Keyboards, mice, and touchpads are all tested and supported, other device types should work as-is. OSX and Windows are not currently supported.

Nikau is packaged as a single standalone executable containing server and client modes. The server is where the input devices are plugged in. Clients running on other machines then connect to the server and wait to receive input events.

The Nikau server has configurable keyboard shortcuts for switching among connected clients. The defaults are LeftAlt+N to go to the next machine and LeftAlt+P to go to the previous machine. Another option is to send SIGUSR1 and SIGUSR2 unix signals to the Nikau server process.

When a client has been selected to receive input, the Nikau server collects input device events from the host and sends them over the network to the selected client. That client then emits the received input events to the host.

When Nikau is started from within a WM, clipboard contents can be automatically transferred between machines over the network. This transfer happens automatically in the background when the user creates a clipboard entry on one machine, switches to another machine, and then pastes to that machine. Server-to-client, client-to-server, and client-to-client transfers are all supported. Any content is supported, up to a configurable 5MB size limit.

Getting started

1. Decide which machine will run the server. The server will have attached input devices to be shared with the client(s). The server will listen for incoming client connections at UDP port 1213 by default.
2. Install Nikau to each machine:
   • Stable release: cargo install nikau, and then use sudo ~/.cargo/bin/nikau to run the binary.
   • Latest main: git clone https://git.sr.ht/~nickbp/nikau && cd nikau, then use ./server.sh and ./client.sh <server-host> helper scripts.
   • Docker: docker-server.sh and docker-client.sh provide example docker run commands. Note that --privileged is required and this has security implications. Image tags are based on commit SHAs and are listed here.
3. Run the nikau binary on each machine:
   • Run sudo nikau server on your server machine with the input devices to be shared
   • Run sudo nikau client <serverIP> on your client machine(s)

New connections need to be approved on both the server and the client. On each side of the connection, check that the displayed fingerprint matches what's printed on the other side. This manual approval is only required the first time a new connection is being made. Approved peer certificates are written to ~/.config/nikau/known_certs/<signature>.pem and can be revoked by deleting them.

Once the connection has been made, the client is added to the server's rotation. Keyboard shortcuts and signals are used to switch among the server and one or more clients.

• Forward/backward rotation: The default LeftAlt+N and LeftAlt+P shortcuts to switch forward and backward among a rotation of connected clients (in order of client IP) and the server itself. These shortcuts can be customized to use a different keyboard combination. Forward and backward rotation can also be triggered by sending SIGUSR1 and SIGUSR2 unix signals to the Nikau server process like this: sudo kill -USR1 <pid>
• Exact selection: One or more custom keyboard shortcuts can also be defined for switching to specific clients identified by fingerprint prefixes. For example:
  • LeftAlt+1 could be switch to a client whose fingerprint starts with abcd123
  • LeftAlt+2 for switching to another client whose fingerprint starts with efgh456
  • LeftAlt+0 could switch to the server (empty fingerprint)
  The above would be configured with: --shortcut-goto leftalt,1=abcd123 --shortcut-goto leftalt,2=efgh456 --shortcut-goto leftalt,0=

Keyboard shortcuts are configurable via commandline arguments on the Nikau server. For a full list of supported key names, see the list of KEY_* entries here. For example leftshift,rightctrl,x would be mapped to the KEY_LEFTSHIFT, KEY_RIGHTCTRL, and KEY_X keys on that list.

Status

I'm regularly using Nikau across a variety of machines and devices, making fixes and improvements as needed. As such it should "just work". Feel free to email me if you encounter problems.

Keyboards, mice, and touchpads should all be supported and are used regularly. Other input devices like joysticks, gamepads, tablets, etc should also work, but I haven't tried them yet. To maximize device compatibility, Nikau passes device events largely as-is, so most devices should Just Work.

The client/server protocol may change between releases. The server should automatically detect and refuse clients with incompatible versions. If you see version errors upon connection, check that the versions line up using nikau --version. Compare this to the latest stable release. Upgrade by running cargo install nikau again.

Known shortcomings:

• Clipboard transfers currently rely on X11 clipboard APIs, which are supported by all X11 WMs as well as some Wayland clients like GNOME. I plan to support wlroots clipboard APIs used by some other Wayland clients.
• Copying a file in a file manager and then pasting it in another machine's file manager doesn't currently work. This is because only the file's path is copied, not its content, and the path isn't valid between machines. A solution here could be to detect this and create a temp file with the content on the target machine, but for now the workaround is to copy the file's content manually.
• Nikau does not currently work on OSX or Windows. I think cross-platform client support could be done by translating received uinput events to e.g. Core Graphics events in the case of OSX. However, I don't have any plans to support Windows. Patches welcome.

Security

This software has NOT undergone any security review or audit. Use is at your own risk. See also terms and conditions of the licence.

Nikau's purpose is to collect keystrokes and clipboards and send them over the network between machines. This can include passwords and other sensitive information. You must decide whether this is an acceptable risk for you.

Assuming no flagrant bugs in Nikau or its dependencies, all communication is TLS-encrypted, with certificate-based authentication following a "prompt-once" model similar to OpenSSH. New connections must be approved bidirectionally, on both the client and the server, before the connection can proceed. However, even with encrypted channels, timing information could still be inferred from the event stream.

In order to allow direct access to uinput devices, the client and server must both be run as root (e.g. via sudo).

Other options

There are a few other packages for this sort of thing. Here's how Nikau compares, in my highly biased opinion:

• Synergy: Supports Linux, OSX, and Windows. On Linux, relies on X11-specific APIs which allow using the mouse cursor to switch between machines, but it doesn't support Wayland, nor the Linux console. Input suffers from perceptable lag, and can be especially hitchy over a Wifi connection. Commercially licensed, with pricing that has increased significantly over the years without improvements to show for it. Encryption support is a premium feature at extra cost, and it lacks bidirectional authentication. Supports clipboard transfer, but this seems to be limited to small text snippets.
• Barrier: A fork of Synergy that shares its upsides and downsides. Hasn't seen much development activity since 2021.
• rkvm: Very similar to Nikau in that it uses uinput and TLS encryption, is written in Rust, and is Linux-only. rkvm showed me that a uinput-based KVM was possible. However, rkvm has some downsides that I think Nikau addresses: Setup requires manual TLS certificate management across all machines, and certificates must be recreated if machines change hosts/IPs. Authentication is based on configuring a symmetric password on each machine, and revoking a client requires changing the password everywhere. Only a specific subset of uinput events is implemented, so e.g. touchpads are not supported. Clipboard transfers are not implemented.

License

This project is licensed under the AGPLv3 (or later versions) and is copyright Nicholas Parker.