# InputShare: one keyboard and mouse for your PC and an Android phone

> InputShare shares the keyboard and mouse of your computer with an Android device over ADB, wired or wireless, with hotkey and edge switching plus clipboard sync. It is a Python GUI built on scrcpy, and the multi-device and key-mapping features live in a separate commercial edition.

**InputShare/InputShare** — InputShare enables you to share the keyboard and mouse of your computer with an Android device via ADB in wired / wireless way.

- Repository: https://github.com/InputShare/InputShare
- Website: https://inputshare.github.io/
- Stars: 619 · Forks: 44
- Language: Python
- License: Apache-2.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/inputshare-inputshare

## The problem is typing on a phone while sitting at a computer

InputShare enables you to share the keyboard and mouse of your computer with an Android device via ADB, in a wired or wireless way.

The use case is narrow and instantly recognisable. You are at a desk with a PC and a phone, and you want to type a long reply on the phone using the PC keyboard without picking up the phone, or you want to scroll and click on the phone's screen with the PC mouse because the phone's touch screen is awkward for a precise gesture. The phone stays in your hand, the input comes from the desktop.

The feature list spells out the mechanics. Switching between sources is quick: you move keyboard and mouse input between the PC and the Android device quickly, through a hotkey and through edge toggling, so when the pointer reaches the edge of the screen the target changes. The clipboard sync moves clipboard content between the computer and the Android device. Wide compatibility means it works with various Android devices rather than one specific brand. Everything is driven from an easy-to-use GUI.

The input is shared, not the screen. That distinction matters, and it is the difference between this tool and the project it is built on.

## A GUI and an ADB invocation on top of scrcpy

The README credits the foundation plainly. InputShare is based on the scrcpy project and provides a GUI with the built-in ADB invocation.

scrcpy is a screen mirroring tool that talks to Android over ADB. InputShare keeps that transport and changes the purpose. Instead of mirroring the phone's screen onto your desktop and forwarding clicks back, it forwards the desktop's keyboard and mouse events to the phone, and adds the two things a bare ADB tool does not give you: a way to switch between the two input sources, and clipboard synchronisation.

The repository layout reflects the split. There is a scrcpy_client/ directory for the upstream code, an adb-bin/ directory, a server/ directory for the component that runs on the device, an input/ directory for the input handling, ui/ for the interface, utils/ for shared helpers, and main.py at the root. A setup.iss file is an Inno Setup script, which is the Windows installer definition, and index.html and README_zh.md sit alongside the English README.

The practical upshot is that this is a desktop Python application. It runs on the computer, it drives an Android device over ADB, and the server/ directory holds the component that runs on the device side.

## The wired path is three steps and no pairing

You first need to enable the Developer Settings of your Android device. That is the prerequisite for both connection modes, and it is the reason this is a developer-adjacent tool rather than a consumer one.

For a wired connection the sequence is short.

1. Enable USB Debugging in the Developer Settings page.
2. Connect your device with the computer via a USB cable.
3. Just run the executable and skip the pairing and connecting steps.
4. Enjoy your mouse and keyboard on the Android device.

The third step is the one that surprises people. Because the cable is already there and the device is already enumerated, there is nothing to negotiate, so the pairing dialog that the wireless path requires is skipped entirely. Plug in, launch, and the input is shared.

That is the mode to use when the phone is docked and the workflow is continuous, since there is no per-session handshake to repeat. The cost is that the phone is physically tethered, which for a device that lives in a pocket is a limitation rather than a feature.

## Wireless mode needs two different pieces of information

The wireless path is more interesting because the phone is not on a cable, and it is where the ADB protocol shows through.

1. Enable Wireless Debugging in the Developer Settings page.
2. Run the executable.
3. On your Android device, open the Pair device with pairing code option and input the IP address and port and the pairing code into the pairing tab of the connecting window. This is the pairing step, which is generally needed for the first time use.
4. Input the IP address and port in the main Wireless Debugging into the connecting tab of the connection window.
5. Enjoy your mouse and keyboard on the Android device.

The subtlety is that wireless debugging uses two different pieces of information, and the README separates them into two tabs for a reason. The pairing code establishes trust for the device, and it is a one-time step. The IP address and port of the main Wireless Debugging screen is the actual endpoint you connect to afterwards. Confusing the two is the most common way to fail at this, and the app reduces the risk by giving each its own tab.

Because the endpoint is an address on the local network rather than a USB link, this mode is the one that depends on the phone and the computer being able to reach each other, and it is the mode where a firewall or a different subnet will show up as a connection failure rather than as a missing cable.

## The Python dependencies show what the program does

The requirements file is short and legible, and each entry points at one part of the application.

```
adbutils==1.2.15
customtkinter==5.2.2
pynput==1.8.1
notify_py==0.3.43
pyperclip==1.9.0
pystray==0.19.5
screeninfo==0.8.1
```

adbutils is the ADB client the whole thing is built on, and it is what lets the executable talk to the phone. The repository also carries an adb-bin/ directory with a bundled ADB binary. customtkinter provides the themed desktop widgets for the windows you see in the screenshots, including the pairing panel, the connecting panel, the settings and the system tray. pynput is the library for observing and injecting keyboard and mouse events on the computer, which is the core of input sharing. pyperclip handles the clipboard side of the sync. pystray is what puts an icon in the system tray, and screeninfo describes the monitors so that edge toggling knows where the screen boundary is. notify_py raises desktop notifications.

Everything is pinned to an exact version, which is the right call for an application that ships as a compiled executable, and there are no version ranges to resolve at install time. There is also a note of thanks to a contributor who improved the performance of InputShare under high polling rate, which is the kind of edge that only shows up on a gaming mouse.

## Install is download and run, and the paid edition has the extras

Installation is not a package manager workflow. You go to the release page, download the latest compressed package, uncompress it, and the executable is inside.

That is a deliberate trade. The application bundles its Python environment and its dependencies, which is why the requirements file can pin exact versions and why the user does not need a Python installation, and why there is an Inno Setup script in the repository to build a Windows installer.

The user documentation is split into four documents in docs/: shortcuts, FAQs, limitations, and development. The limitations page is the one to read first, because the feature list in the README is written from the perspective of what the tool does rather than what it cannot do.

The note at the end of the feature list is also worth reading. The README suggests upgrading to InputShare2, a commercial edition with multi-device support, automatic device discovery, customizable key mappings, and a refreshed modern UI, distributed through the Microsoft Store. That tells you exactly where the boundary of the free version sits. In this repository you get one device, manual connection, and default key mappings. Multi-device, discovery and key mapping configuration are the paid features.

## Where InputShare is the wrong tool

The clearest case is when you need to see the phone's screen. InputShare shares input, so the phone's display stays on the phone. If your task involves reading something on the phone while acting on it, and you are not standing over the device, you need screen mirroring, which is what scrcpy itself does and what InputShare deliberately does not do.

The second case is multiple devices. The README points multi-device support to the commercial edition, so a workflow that involves a phone and a tablet, or two phones, is outside what this repository covers.

The third is fine-grained pointer behaviour. Edge toggling and hotkey switching are coarse mechanisms, and a task that depends on precise pointer coordinates inside a small on-screen element is a case where you may find the mapping surprising. The limitations document exists precisely because the author knows where the edges are, and it is the right place to look before you build a workflow on top of it.

A related constraint is that both sides must be willing to cooperate. The phone needs developer options enabled, which is a deliberate barrier for anyone outside the development world, and the computer and phone need a working ADB path, which means a USB cable in the wired case and a reachable network address in the wireless case.

## Conclusion

InputShare suits someone who types long messages on a PC and wants to hand the keyboard to a phone connected over USB or wireless ADB, and who is comfortable enabling developer options on the device. It does not suit a setup with several phones, since multi-device support is in the commercial edition rather than this repository, and it does not mirror the screen the way scrcpy does. Verify first that your Android device exposes USB debugging or wireless debugging, and read the limitations document in docs before you rely on it for a workflow that depends on precise pointer behaviour.

## FAQ

### How do I install InputShare?

Go to the project release page, download the latest compressed package, uncompress it, and the executable is inside. The repository also contains setup.iss, an Inno Setup script used to build a Windows installer.

### How do I connect an Android device to InputShare over wireless?

Enable Wireless Debugging in the developer settings, run the executable, then on the phone open the Pair device with pairing code option and enter the IP address, port and pairing code in the pairing tab of the connecting window. Afterwards enter the IP address and port from the main Wireless Debugging screen in the connecting tab.

### What does InputShare need from my Android device?

Developer Settings must be enabled. For a wired connection you turn on USB debugging and connect by USB cable, and the pairing and connecting steps are skipped. The features list states compatibility with various Android devices rather than a specific brand.

### How is InputShare different from scrcpy?

InputShare is based on the scrcpy project and provides a GUI with the built-in ADB invocation, but instead of mirroring the phone screen it shares your computer keyboard and mouse with the device, with hotkey and edge switching plus clipboard sync.

### Does the free version of InputShare support multiple devices?

The README points multi-device support, automatic device discovery, customizable key mappings and a refreshed interface to InputShare2, a commercial edition. The open source repository covers the single device case with manual connection.

## Sources

- [InputShare/InputShare on GitHub](https://github.com/InputShare/InputShare)
- [License: Apache-2.0](https://github.com/InputShare/InputShare/blob/master/LICENSE)
- [Project website](https://inputshare.github.io/)
- [README](https://github.com/InputShare/InputShare/blob/master/README.md)
- [Releases](https://github.com/InputShare/InputShare/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/inputshare-inputshare