Every major peripheral brand ships macro software: Logitech has G Hub, Razer has Synapse, Corsair has iCUE, SteelSeries has GG. These tools have improved significantly over the years. They support application-specific profiles, some have scripting modes, and they're generally polished for the hardware they're designed for.
The problem isn't the software. The problem is the model: your macros belong to a hardware vendor.
What vendor lock-in looks like in practice
You spend an hour setting up profiles in Logitech G Hub. Shortcuts for your most-used apps, a few gaming macros, some DPI switching behavior. Everything works exactly how you want it.
Then you switch to a Razer mouse — better sensor, fits your grip better, whatever the reason. Your G Hub profiles are useless. You open Razer Synapse and start over, re-building everything from scratch in a different interface with different limitations and a different scripting model.
If you ever end up with mixed hardware — a Logitech keyboard and a Razer mouse is a common combination — you're now running two macro ecosystems simultaneously, with no way to share logic between them.
This isn't an oversight in the design. It's intentional. Peripheral vendors want you to stay in their ecosystem. Your macros being locked to their software is a retention mechanism.
Rebind's model
Rebind is not affiliated with a peripheral brand. It works with any USB keyboard and mouse. You plug your existing devices into the Rebind hardware unit, and they gain the full capabilities of the Rebind scripting engine — regardless of manufacturer.
When you switch hardware, you unplug your old mouse, plug in a new one, and your scripts keep working. The script doesn't know or care what brand of mouse generated the input event. It just sees mouse events.
This extends to mixed setups. If you use a Logitech keyboard and a Corsair mouse, they both route through the same Rebind engine and are both scriptable from the same set of scripts. One scripting environment. One place to define your automation logic.
Your scripts live on the device
Peripheral software stores your profiles on the vendor's servers or in local application data. If you reinstall your OS, you need to reinstall G Hub or Synapse, log back in, and hope your profiles sync correctly. If the vendor discontinues the software, your macros are gone.
Rebind scripts are stored on the USB device itself. Connect the Rebind device to a new machine and everything works immediately — no installation, no account, no sync. The device is self-contained.
This also means your scripts work on machines where you can't or don't want to install software. A work computer with IT restrictions, a borrowed machine, a clean OS install. The device carries its own firmware and scripts.
What you keep when you switch devices
Because scripts are peripheral-agnostic, switching hardware is additive rather than destructive:
- Switch your mouse? Your keyboard macros are unaffected, and your mouse macros work on the new hardware immediately.
- Get a new keyboard? Same thing.
- Go from a full-size keyboard to a 60% layout? Update the key bindings in your scripts — the logic stays the same.
You're maintaining one set of scripts that describe your automation, not a parallel set of profiles in each vendor's application.
The tradeoff
Peripheral software has one genuine advantage: the macros are bound directly to physical device buttons, including buttons that only exist on that hardware — the extra G-keys on a Logitech mouse, the macro row on a Corsair keyboard. Rebind works with standard HID input, so if you have hardware with proprietary extra buttons, those won't route through the Rebind engine unless they appear as standard key events to the host OS.
For most users, the macro keys on their existing peripherals are underused or unused. For users who rely heavily on proprietary extra buttons, that's worth factoring in.
For everything else — keyboard shortcuts, remapping, mouse behavior, per-application profiles, sequences, and automation — Rebind handles it without vendor dependency, and takes it further than any peripheral software does.
The marketplace has community scripts across gaming, productivity, and accessibility categories. The SDK documentation covers the full scripting API.