If you've spent time automating keyboard and mouse input, you've likely landed on one of a handful of tools: AutoHotkey for general scripting, Logitech G Hub, Razer Synapse, SteelSeries GG, or Corsair iCUE if you're using their hardware, or a game's built-in macro system. These tools all solve real problems. They also share a set of limitations that are hard to work around because those limitations are structural — they come from how the tools are built, not from missing features.
Rebind addresses the same problems, but from a different position in the stack.
The structural problem with software macros
AutoHotkey, G Hub, Synapse, and every other software macro tool run as processes on your operating system. When you press a key, the OS receives the input, routes it to the macro application, the application executes its logic, and then synthesizes new input events back into the OS input stack.
This creates several problems that can't be fixed by adding features:
Timing is OS-dependent. Your macro tool competes with every other process on your machine. A garbage collection pause, a background sync, or a momentary CPU spike will cause your precisely-timed macro to fire at 11ms instead of 10ms. For sequences that require consistent timing, software scheduling is fundamentally unreliable.
The output is software-injected. When software generates synthetic input events, that input enters through the OS input stack rather than from a physical device. Rebind takes the other path: output leaves a dedicated USB device as standard HID, so your computer sees a standard USB keyboard and mouse.
Your macros live in the software. If the application crashes, your macros stop. If you reinstall your OS, you need to reinstall your macro software, re-import your scripts, and reconfigure. If AutoHotkey stops being maintained, your automation is at risk.
How Rebind is different
Rebind sits between your devices and your PC. In hardware mode, your physical keyboard and mouse plug into a dedicated Rebind USB device — a Rebind Link, or your own Teensy 4.x running Rebind firmware — instead of directly into your computer, and that device plugs into your machine.
Every input event runs through the Rebind engine — Luau (a typed, fast variant of Lua) on a Rust-backed SDK — at up to 8,000 times per second, within a 125-microsecond budget. The engine reads your devices' raw input and the processed result leaves the Rebind device as standard USB HID. Your computer never sees your raw input — only a standard USB keyboard and mouse, vendor-agnostic, with no host-side driver for your physical peripherals.
The practical consequences:
- Hardware-isolated input and output. Your raw keystrokes and movements never reach the OS — only the device's clean HID output does. That isolation is what lets Rebind intercept and transform mouse movement, which software-only tools cannot do on any OS.
- Deterministic output timing. The result is emitted by real USB hardware, so it does not drift the way OS-injected input does when the system scheduler is under load.
- Portable, peripheral-agnostic scripts. Your scripts are plain Luau text that runs the same on Windows, macOS, and Linux, on any USB keyboard and mouse — carry them between machines instead of re-importing into vendor software.
Versus AutoHotkey specifically
AutoHotkey gives you a real scripting language — hotkeys, string manipulation, GUI creation, COM access — and it's remarkably capable for a software tool. Rebind is not trying to replace AutoHotkey for desktop automation tasks like launching applications, manipulating windows, or filling web forms. Software is the right tool for those problems.
Where Rebind goes further is input-level automation: anything that requires hardware-accurate timing, standard USB HID output from real hardware, or independence from the host OS. AutoHotkey runs on Windows and depends on Windows. Rebind's scripting engine is peripheral-agnostic, cross-platform (Windows, macOS, Linux), and hardware-isolated.
Rebind also uses Luau rather than AutoHotkey's custom syntax, which gives you real type safety, coroutines, a familiar standard library, and a language that transfers to other contexts.
Versus G Hub, Synapse, iCUE, and SteelSeries GG
Peripheral software macros have an additional constraint: they only work with the vendor's hardware. Your Logitech macros live in G Hub and only execute when a Logitech device is in use. If you switch to a Razer mouse, you start over in Synapse. If you ever use a mix of brands — a Logitech keyboard and a Razer mouse, for example — you're managing two separate macro ecosystems simultaneously.
Rebind works with any USB input device. Plug in whatever mouse and keyboard you already own, attach them through the Rebind UI, and they immediately gain the full capabilities of the scripting SDK. When your hardware changes, your scripts don't. The automation belongs to you, not to a hardware vendor.
What they have in common
All of these tools, including Rebind, are trying to give you more control over your input devices. If your needs are modest — a few hotkeys, some text expansion, a key remap — any of these tools will work. The choice matters when:
- You need sub-millisecond timing precision
- You need standard USB HID output from real hardware
- You're using a mix of hardware brands or expect to change hardware in the future
- You want a full programming language with real control flow and async capabilities, not a sequence recorder
That's the space Rebind is designed for.