Three stages
Capture. The Rebind engine captures your keyboard and mouse input — every keypress, mouse movement, and scroll-wheel delta. In software mode, capture is through OS event hooks. In hardware mode, through an isolated environment, before your OS sees the raw input.
Script. Each event fires your hooks — OnDown, OnUp, OnMove, OnScroll, OnTick — at up to 8,000 Hz. Remap keys, transform movement, run macros, make HTTP calls. Scripts are sandboxed Luau VMs with execution budgets and runaway protection. A script crash only stops that script.
Output. The transformed result reaches your PC as standard USB keyboard and mouse input. In software mode, through OS-level injection. In hardware mode, through the Rebind Link device — your OS sees a real USB keyboard and mouse. No special drivers, no kernel hooks.
Software output and hardware output
Rebind runs two ways from the same scripts — only the transport changes.
Software output needs no device. Input is captured through OS event hooks; output is injected at the OS level. Write and test a script end to end before deciding on hardware.
Hardware output runs through Rebind Link, a physical device. Input is captured in a sealed, isolated environment before reaching your OS, and output leaves through dedicated hardware as real USB HID — your OS sees a standard keyboard and mouse. Hardware mode unlocks 8,000 Hz deterministic timing, mouse-movement suppression, and DRM-protected script execution.
Hardware output enables one capability software cannot offer on any OS: suppressing and transforming mouse movement. The operating system draws the cursor below anything a host process can intercept — only a device that owns the input stream can rewrite motion. Keys, buttons, and scroll can be blocked in both modes.
A script declares its own rules
Modelines are comment lines at the top of a script. They set the tick rate, target specific apps, and declare permissions.
-- rebind: min_sdk=3.0.0
-- rebind: name=Precision Mode
-- rebind: process=Photoshop.exe
-- rebind: tick_rate=8000
-- rebind: mouse_block=true
function OnMove(dx, dy)
if Input.IsDown("LShift") then
HID.Move(dx * 0.25, dy * 0.25) -- fine control with Shift
else
HID.Move(dx, dy)
end
end
The runtime
The scripting runtime is Luau — a fast, typed variant of Lua — running on a Rust core. Scripts are sandboxed VMs with memory limits and execution budgets. When no scripts are loaded, the engine passes input straight through. When a script crashes, only that script stops.
Remote-control clients for TypeScript, Python, and Rust connect over a JSON-RPC WebSocket. RPC round-trips in about 1 ms p50, sustaining ~10,000 requests per second on localhost.
No drivers. Standard USB output.
Rebind Link outputs standard USB HID — the same protocol every keyboard and mouse uses. There's no custom driver to install, no kernel-mode filter, no companion process required on the host to receive its output. Your operating system sees an ordinary USB keyboard and mouse. The transformation layer lives on dedicated hardware between your peripherals and your OS.
Common questions
Do I need Rebind Link to start? No. Software mode runs the full SDK with no device — write and test end to end, then add Rebind Link when you want hardware HID output.
What's the difference between software and hardware output? Software output injects through OS APIs. Hardware output goes through Rebind Link as real USB HID, with deterministic 8,000 Hz timing and mouse-movement suppression.
What can scripts do? Remap any key. Transform mouse movement. Run macros with hardware-accurate timing. Start an HTTP or WebSocket server. Sample screen pixels. Control windows. Execute shell commands. The SDK has 26 namespaces — full reference at docs.rebind.gg.
Can a script crash the system? No. Each script runs in its own sandboxed VM with memory limits and execution budgets. A crash only stops that script; runaway scripts are killed automatically.