Every major peripheral brand ships macro software. Logitech has G Hub, Razer has Synapse, Corsair has iCUE, SteelSeries has GG. The tools are decent at what they do: application profiles, some scripting, reasonable polish for the hardware they ship with.
The problem is not the software. The problem is the model. Your macros belong to a hardware vendor.
What lock-in looks like in practice
You spend an hour building profiles in one vendor's app. Shortcuts for your most-used apps, a few gaming macros, some DPI switching. Everything works.
Then you switch to a different mouse. Better sensor, better grip, whatever the reason. Your profiles are useless. You open the new vendor's app and rebuild everything from scratch, in a different interface with different limitations and a different scripting model.
Mixed hardware is worse. A Logitech keyboard and a Razer mouse is a common combination, and it means running two macro ecosystems at once with no way to share logic between them.
The structure is simple: your macros live in the vendor's app, and the vendor's app stops at the vendor's catalog.
Rebind's model
Rebind is not affiliated with a peripheral brand. It is software that runs on your machine and works with your USB keyboards and mice, regardless of manufacturer. Scripts run in the Rebind Engine on the host, so a script never knows or cares which brand generated an input event. It just sees events.
Switch mice and your scripts keep working. Mixed setups collapse into one scripting environment: a Logitech keyboard and a Corsair mouse both route through the same engine and are scriptable from the same set of scripts.
Scripts are files, not profiles
Vendor software stores your profiles in its own application data or on the vendor's servers. Reinstall your OS and you reinstall the app, log back in, and hope the sync worked. If the vendor discontinues the software, the profiles go with it.
Rebind scripts are Luau files on your machine. They copy, back up, and version control like any other code, because they are code.
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.
- New keyboard? Same thing.
- Full-size to 60% layout? Update the key bindings in your scripts. The logic stays.
You maintain one set of scripts that describe your automation, not a parallel set of profiles in each vendor's application.
The tradeoff
Vendor software has one genuine advantage: it can bind macros to proprietary buttons that only exist on that hardware, like the extra G-keys on a Logitech mouse or the macro row on a Corsair keyboard. Rebind works with standard HID input, so a button that does not reach the host OS as a standard key event will not route through the Rebind Engine.
For most people those buttons sit unused. If your workflow leans on them, factor that in.
For everything else, keyboard shortcuts, remapping, mouse behavior, per-application profiles, sequences, and automation, Rebind handles it without asking which logo is on the shell.
Download free and point it at the gear you already own. The in-app marketplace has community scripts across gaming, productivity, and accessibility. The Documentation covers the full scripting API.