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 detectable. When software generates synthetic input events, there are detectable differences — injected input has different characteristics than real hardware input at the driver level. Anti-cheat systems, some applications, and increasingly websites can distinguish software-generated input from hardware input.
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 is not software on your PC. The scripting runtime runs on a dedicated Teensy 4.x microcontroller connected to your machine via USB. Your physical keyboard and mouse plug into the Rebind device. Your Rebind device plugs into your computer.
Every input event from your physical devices is processed by the Rebind scripting engine — running Luau (a typed, fast variant of Lua) on top of a Rust-backed SDK — at up to 8,000 times per second. The processed output is sent through the Teensy as standard USB HID input. Your operating system sees a generic USB keyboard and mouse. Your actual peripherals are invisible to software.
The practical consequences:
- Consistent timing. The microcontroller runs a hard real-time loop. There is no OS scheduler interfering with your sequence timing.
- No detectable software footprint. The output comes from real USB hardware. There is no injected input, no driver hook, no process running on the host.
- Scripts survive OS reinstalls. Your scripts live on the device. Connect it to a new machine and everything works immediately.
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, undetectable output, or independence from the host OS. AutoHotkey runs on Windows and depends on Windows. Rebind's scripting engine is peripheral-agnostic 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 output that's indistinguishable from real hardware input
- 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.