# Input Remapper: remapping keys, mouse buttons and gamepads on Linux

> Input Remapper is a GPL-3.0 Python tool that maps any input device event to any other input on Linux, across X11 and Wayland. It is a strong fit for Linux users with unusual hardware; it is not a Windows tool, and its service model has real consequences.

**sezanzeb/input-remapper** — 🎮 ⌨ An easy to use tool to change the behaviour of your input devices.

- Repository: https://github.com/sezanzeb/input-remapper
- Stars: 5,970 · Forks: 231
- Language: Python
- License: GPL-3.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/sezanzeb-input-remapper

## What Input Remapper solves, and for whom

Linux exposes input devices as event nodes under /dev/input, and most desktop environments only let you change a keyboard layout or a pointer speed. If you have a gamepad with a broken stick, a mouse with extra buttons that no settings panel recognises, or a wheel whose triggers you want to behave like keys, the desktop gives you nothing. Input Remapper fills that gap. The README describes it as "an easy to use tool for Linux to change the behaviour of your input devices" and lists X11, Wayland, combinations, programmable macros, joysticks, wheels, triggers, keys and mouse movements as the supported surface. The audience is Linux users with non-standard hardware, not people who want a general purpose automation daemon. The repository topics (gamepad, gaming, keyboard, keyboard-shortcuts, linux, mouse) point at the same group. If your problem is "this button should send that key", this is the tool. If your problem is "this application should react to a sequence of events across programs", it is not.

## How the mapping actually works: a service that grabs devices

The architecture is visible in the package layout. The Python package is inputremapper, the entry points live under bin/, and the Debian packaging ships separate units named input-remapper-daemon and input-remapper-gtk, which the README's purge command confirms. That split matters: the GTK application is the configuration front end, and the daemon is what keeps reading and re-emitting events after you close the window. On Fedora, Arch and Void the README instructs you to enable the service explicitly with systemctl enable --now input-remapper, which means mappings are applied by a system service rather than by a session process. Because the daemon has to intercept the original device to substitute its output, it takes the device away from the rest of the system while a mapping is active. The README's uninstall path (sudo python3 -m install.uninstall) and the purge list of four packages exist precisely because that service and its files are installed system-wide. The practical consequence is that a misconfigured mapping can make a device behave unexpectedly in every application, not just the one you were configuring, until you disable the mapping or stop the service.

## Installing Input Remapper on Ubuntu, Fedora, Arch and Void

The README gives a packaged install per distribution, and the Debian-family route is the most explicit. It downloads the .deb attached to the 2.2.1 release and installs it with apt, which resolves dependencies automatically. Note the exact filename, since it carries the version.

```bash
wget https://github.com/sezanzeb/input-remapper/releases/download/2.2.1/input-remapper-2.2.1.deb
sudo apt install -f ./input-remapper-2.2.1.deb
```

If you prefer the distribution's own archive, the README also lists sudo apt install input-remapper for Debian and Ubuntu, and states that Input Remapper 2.0 and later requires at least Ubuntu 22.04. Fedora, Arch and Void each have a package plus a service to enable.

```bash
sudo dnf install input-remapper
sudo systemctl enable --now input-remapper
```

```bash
yay -S input-remapper-git
sudo systemctl enable --now input-remapper
```

```bash
sudo xbps-install -S input-remapper
sudo ln -s /etc/sv/input-remapper /var/service
sudo sv up input-remapper
```

After the install command finishes, the service should be enabled and running; on Fedora, Arch and Void the second command is what starts it. To remove it again, the README gives sudo python3 -m install.uninstall for source installs.

## A first mapping, and the constraints the README states

After installation the README points to readme/usage.md and readme/macros.md for the workflow; the repository screenshots show the GTK window with a device list on one side and the mapping editor on the other. The general shape is: pick the device, create a mapping, choose the input event to capture, then choose the output event to send. Macros are documented separately, which is where combinations and programmable sequences live. Two constraints are worth stating plainly because they come from the packaging rather than from the UI. First, the service must be running for mappings to take effect outside the configuration window, which is why every distribution section ends with a systemctl or sv command. Second, Python packages must be installed globally for the service to import them; the README says explicitly not to use --user and warns that Conda and similar environments may cause problems due to changed python paths and versions. That warning is the single most useful line for anyone installing from source, and the README's own source route reflects it:

```bash
sudo pip install evdev pydantic dasbus PyGObject
```

```bash
git clone https://github.com/sezanzeb/input-remapper.git
cd input-remapper
sudo python3 -m install --root /
sudo systemctl enable --now input-remapper
```

The README lists the remaining dependencies as python3-evdev >=1.3.0, gtksourceview4, python3-devel, python3-pydantic, python3-dasbus and python3-psutil, and notes that python3 -m install --help lists the other options.

## Where Input Remapper is the wrong tool

There is no Windows build. The README's installation section covers Ubuntu/Debian, Fedora, Arch, Void and a generic dependency list for other distributions, all of them Linux, and the project description says the same. Anyone searching for a Windows equivalent will not find one here, and no amount of configuration will change that. The second limitation is the device grab itself. A tool that substitutes input events has to own the device while a mapping is active, so if the daemon stops while a mapping is applied, or if a mapping sends an event the desktop interprets as a system shortcut, the effect is not scoped to one application. The third is packaging drift: the README's source install path (sudo python3 -m install --root /) installs into the system Python, so a distribution upgrade that changes the Python version can leave the installed modules unreachable. None of these are defects in the design; they are the price of operating at the input layer rather than inside an application.

## How it differs from remapping at the compositor or desktop level

Desktop environments and compositors already offer key remapping: X11 keyboard layout options, and per-compositor input configuration on Wayland. Those tools operate on the keyboard layout and on pointer settings, and they generally do not cover gamepads, wheels or arbitrary event nodes. Input Remapper works one layer lower, at the evdev event level, which is exactly why it can map a trigger to a key or a joystick axis to a mouse movement. The trade-off runs the other way too: because it sits below the desktop, it cannot know which application is focused, so a mapping is global. A compositor-level remap is narrower but stays inside the session and disappears when you log out. Choosing between them is a question of whether your device is a keyboard at all.

## Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-09-20. Releases are not frequent: 2.1.1 in February 2025, 2.2.0 in November 2025 and 2.2.1 in June 2026. That cadence suggests a project in maintenance rather than rapid development, which is normal for a tool whose interface is the kernel's input layer and therefore changes slowly. Upgrading from a distribution package is the cheapest path; upgrading from a source install means re-running the build and re-installing, and the README's own build instructions purge the four input-remapper packages before installing the freshly built .deb, which is a hint that mixing a source build with a distribution package causes conflicts.

```bash
sudo apt purge input-remapper input-remapper-daemon input-remapper-gtk python3-inputremapper
sudo apt install -f ./dist/input-remapper-2.2.1.deb
```

The licence is GPL-3.0-or-later, declared in pyproject.toml with a LICENSE file at the repository root. That is a copyleft licence, so if you redistribute a modified Input Remapper you take on source distribution obligations; if you merely install and use it, the licence does not restrict you. This is a description of the licence text, not legal advice.

## Conclusion

Adopt Input Remapper if you run Linux on X11 or Wayland and need to remap a gamepad, wheel, trigger or mouse button into keyboard or mouse output, and you accept a background service that grabs devices. Do not adopt it on Windows: there is no Windows build, and the README only covers Linux distributions. Before committing, verify on your own machine that the packaged version for your distribution is at least 2.0 (2.0 requires Ubuntu 22.04 or newer), that the service starts with systemctl, and that your specific device appears in the GTK interface after a replug.

## FAQ

### How does Input Remapper work?

It runs a system service that reads events from your input devices and re-emits them as different events, with a GTK application for configuring the mappings. The README lists X11, Wayland, combinations, macros, joysticks, wheels, triggers, keys and mouse movements as supported.

### How to use Input Remapper on Linux?

Install it from your distribution's package or the release .deb, enable the service, then use the GTK interface to pick a device and map an input to an output. The README points to readme/usage.md and readme/macros.md for the workflow details.

### Is there an Input Remapper available for Windows?

No. The README's installation instructions cover Ubuntu/Debian, Fedora, Arch, Void and a generic dependency list for other distributions, all of them Linux, and the project describes itself as a tool for Linux.

### How can I remap my controller to a keyboard with Input Remapper?

The project states that it maps any input to any other input, and the repository topics include gamepad alongside keyboard, so a controller input can be mapped to a keyboard output. The mapping editor in the GTK application is where you choose the input event and the output event.

### How do I install Input Remapper?

On Ubuntu or Debian you can download the .deb from the 2.2.1 release and install it with apt, or use sudo apt install input-remapper. Fedora, Arch and Void each have their own package, and the README also documents a source install with sudo python3 -m install --root /.

## Sources

- [Issues](https://github.com/sezanzeb/input-remapper/issues)
- [License: GPL-3.0](https://github.com/sezanzeb/input-remapper/blob/main/LICENSE)
- [README](https://github.com/sezanzeb/input-remapper/blob/main/README.md)
- [Releases](https://github.com/sezanzeb/input-remapper/releases)
- [sezanzeb/input-remapper on GitHub](https://github.com/sezanzeb/input-remapper)

---

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