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 — including the exploits
This is where most people meet a device like this, and I'm not going to be coy about what it does. Because the OS — and therefore the anti-cheat — sees nothing but a standard keyboard and mouse, a hardware layer can pull off things that software simply can't, with nothing on the machine to inspect:
- Recoil removal. A weapon's recoil is a known, deterministic pattern. Shape the mouse output in hardware to cancel it and the gun just… doesn't climb. No client-side process to flag, because the work happens below the OS.
- Aim-assist-style behavior. Pair screen sampling with color and trigger logic and you can build the kind of input shaping that feels like console aim-assist — running underneath everything the game's local anti-cheat can actually see.
- The uninteresting-to-argue-about stuff too: SOCD cleaning for fighting sticks, per-title remaps via window detection, macro recording for grindy single-player loops, and — since it runs an HTTP server and speaks WebSockets — stream and rig control, where one key fires a scene change or hits your lights.
Here's my actual position, and it isn't the cautious one. I think this stuff should be poked at, out in the open. I'm a white-hat at heart: the value of an exploit isn't in hoarding it, it's in showing it. Every undetectable hardware trick demonstrated in daylight is pressure on the defensive side to get smarter — better behavioral detection, input-provenance checks, server-side sanity that doesn't just trust the client. The cheats and the anti-cheats are two halves of one long, genuinely fun cat-and-mouse, and that game only gets better when people are willing to play the attacker's side and publish what they find.
Hiding the capability doesn't make it stop existing — it just means the only people wielding it are the ones who'd never tell you. So I'd honestly rather more people explored exactly what a Teensy in the line can do, because the next generation of anti-cheat should be built by folks who've already stared the problem in the face. Break it, understand why it works, show your work. That's how the workarounds after this one come out smarter — and that loop, to me, is the whole sport.
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 a game and it's an exploit worth dragging into daylight so the defenders catch up. 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.