On my desk there's a tiny board — a Teensy 4.0, a thumbnail-sized 600 MHz microcontroller — flashed with firmware from Rebind. My keyboard and mouse plug into it; it plugs into the PC. To Windows, it is the keyboard and mouse. But in between, every keypress and every mouse delta runs through code I control before the OS ever sees it. That's the whole idea, and once it clicks, you start seeing uses for it everywhere — from a locked-down clinic workstation to a fighting-game arcade stick.
What it actually is
Rebind is a programmable input layer that lives in hardware, not software. Most macro tools — AutoHotkey, vendor software like Razer Synapse, Steam Input — sit somewhere in the operating system, which means they need to be installed, they need permissions, and anything watching the machine can see them. Rebind sits one layer lower: it's a USB device that intercepts input at the firmware level and re-emits a clean, standard HID stream. The tagline says it plainly — "your input, intercepted at hardware level." The OS only sees the result.
Three properties fall out of that design, and they're the reason it's interesting:
- No drivers, no install. It enumerates as a bog-standard USB keyboard and mouse. Plug it into any machine — Windows, macOS, Linux, identical behavior — and it just works. No admin rights, no software footprint.
- It's fast. The pipeline runs at 8,000 Hz — every input event is processed on a ~125 microsecond budget — so the interception, modification, suppression, or injection happens sub-millisecond. You don't feel a layer in the way.
- It's programmable, not just configurable. Logic is written in Luau (the typed Lua dialect), with 20-plus namespaces exposed — HID output, screen sampling, window/app detection, clipboard, an HTTP server, WebSockets, and macro recording with drift compensation. It's a real little runtime, not a remap table.
The dashboard makes it approachable
The part that surprised me is how low the on-ramp is. You don't have to live in the scripting layer to get value — there's a web dashboard where you upload macros, bind keys, and manage profiles, and you're productive in minutes. The depth is there when you want it (you can drop into Luau, talk to the device over a remote protocol from TypeScript / Python / Rust, record and replay sequences), but day one is "drag a macro in and go." That combination — trivial to start, deep when you need it — is rare in hardware like this.
Why "looks like a normal keyboard" is the killer feature
It's easy to read the spec sheet and think the headline is the 8 kHz polling. It isn't. The headline is that it needs nothing from the host machine. That single fact is what unlocks the use cases most people never consider, because it lets a programmable input layer go places software automation legally and practically cannot.
From the clinic: input where you can't install anything
Healthcare IT is locked down for good reasons — regulated, audited, no unsanctioned software on the endpoints touching patient data. That's exactly the environment where a hardware input layer shines, because there's nothing to install. The device is a keyboard. Hospital IT policy has no opinion about a keyboard.
Concretely, where this earns its keep:
- Text expansion in any app, including the EHR. Clinicians retype the same boilerplate hundreds of times a shift — normal-exam templates, discharge phrasing, order sets. A hardware text expander turns a short trigger into the full block inside the electronic health record, the lab portal, the PACS viewer — any field, with zero integration and zero install, on a terminal where you'd never be allowed to run AutoHotkey.
- One key for a documented sequence. Repetitive navigation — the same tab-tab-tab-enter dance through a charting screen — collapses into a single, recorded, repeatable keystroke. With drift compensation on the recorder, the playback stays aligned instead of slowly desyncing.
- Foot-pedal and single-switch workflows. Transcriptionists and sonographers already use pedals; a programmable layer lets you map any cheap USB control surface into rich, context-aware actions (it can detect which app is focused and behave differently per window).
None of that touches the protected system's software stack. It rides in on the USB port like any other peripheral.
Accessibility: remapping the human-to-machine seam
The same "it's just a keyboard, but smart" property is a genuinely good accessibility primitive. Because the logic is yours, you can reshape input to fit the person instead of forcing the person to fit the input:
- Collapse multi-key chords (Ctrl+Alt+Shift+something) into a single press for users with limited dexterity.
- Add hold-to-repeat, dwell, debounce, or de-bounce-the-tremor filtering at the firmware level, before the OS applies its own clumsy key-repeat.
- Build a fully custom layout on a tiny secondary pad and have it work on every machine the person sits down at — home, library, clinic — with nothing to configure on each one.
Software AT (assistive tech) is great until you hit a computer where you can't install it. Hardware AT travels.
And the fun part: gaming
This is where most people meet a device like this, and there's a wide, completely legitimate band of uses:
- SOCD cleaning. For fighting games and platform fighters, resolving simultaneous opposing cardinal directions (left+right) in hardware is standard and tournament-relevant — many controllers ship it. Doing it on a programmable layer means you set the resolution rule yourself.
- Remaps and layers the game won't give you. Per-title profiles via window detection, a second "shift" layer of binds, turning an awkward default scheme into something your hands actually like — all without the game needing to support it.
- Macro recording for the grindy stuff. Single-player and creative-mode quality-of-life: crafting routines, base layout stamping, menu sequences you'd otherwise do by hand a thousand times.
- Stream and rig control. Because it can run an HTTP server and talk WebSockets, a key on the device can fire a scene change, hit your lights, or poke any local service — input device and control surface in one.
One honest line on competitive play: the same invisibility that makes this perfect for a locked-down clinic also means it can do things in online games that the game can't detect. That's a reason to be principled, not reckless — keep the recoil-script, aim-assist territory out of competitive multiplayer where it's against the rules and against the spirit. Use the power where it's welcome: accessibility, single-player, fighting-game hardware norms, your own stream rig. The tool is neutral; the etiquette is on us.
The caveats
- It's an inline dongle — it physically sits between your devices and the PC, so it's one more thing in the chain and one more thing to carry if you want it on a different machine.
- The deep power lives in Luau scripting. The dashboard covers the common cases beautifully, but the genuinely clever automations mean writing a little code. Worth it, but it's not nothing.
- Bring Your Own Hardware (the BYOH route I'm on) means you flash a board like the Teensy 4.0 yourself. It's well-documented, but it is a flash-the-firmware step, not unbox-and-plug.
- As always with input automation: just because you can inject anything doesn't mean every venue allows it. Read the room — and the rulebook.
Bottom line
What I keep coming back to is that Rebind isn't really a "gaming gadget" or a "medical tool" — it's a primitive. It's a fast, OS-invisible, programmable seam between a human and a computer, and it asks nothing of the computer to work. Point that at a clinic terminal and it's a compliance-friendly productivity multiplier. Point it at an arcade stick and it's a tournament-legal edge. Point it at an accessibility need and it's freedom. Same little board on my desk, doing all three. Shout-out to the Rebind team for building the layer and then handing you the keys to program it.