Your input, intercepted at hardware level.

Every keypress and mouse movement passes through your code at 8,000 Hz — then outputs through dedicated USB hardware. The OS only sees the result.

A programmable input primitive.

Your physical devices are captured in a sealed environment. A scripting engine transforms every event. Dedicated hardware outputs the result. The OS never sees the original input.

Invisible to the Host

Your PC sees a standard keyboard and mouse. The transformation layer — your scripts, your logic, your timing — lives on dedicated hardware between your devices and the OS. No drivers. No hooks. Nothing to detect.

8,000 Hz Transform Pipeline

Every input event passes through your code at 125 microsecond intervals. Sub-millisecond interception, modification, suppression, or injection — with deterministic timing independent of system load.

Windows, macOS, and Linux

One unified protocol across all three desktop operating systems. Same scripts, same hardware, same behavior. Write on Windows, run on macOS. Switch platforms and nothing changes.

Any USB Device, Zero Drivers

Plug in any keyboard or mouse you already own. No proprietary peripherals. No vendor lock-in. Your devices are captured at the USB level and forwarded through the scripting engine.

Full Scripting SDK

20+ namespaces: HID output, screen sampling, window detection, HTTP servers, WebSocket, clipboard, macro recording with drift compensation, shared memory IPC, and more. Scripts define their own UI panels.

Remote Access Protocol

Control input programmatically from any language. Typed clients in TypeScript, Python, and Rust. Fire-and-forget HID writes at 100k msg/s or request-response RPCs at 1ms p50.

Context-Aware Without Being Visible

Read pixel colors, detect active windows, react to application state, sample mouse position — all while output flows through clean hardware that presents as a generic USB device.

SDK & Examples

Scripts are Luau with full access to HID output, screen sampling, network I/O, window management, and macro playback. Every example runs at hardware level.

1-- rebind: name=SOCD Cleaner
2-- rebind: process=cs2.exe
3-- rebind: process=valorant.exe
4
5local cfg = UI.Schema({
6 enabled = UI.Toggle(true, { label = "Enable" }),
7 overlap_min = UI.Slider(12, { min = 0, max = 50, suffix = "ms" }),
8 overlap_max = UI.Slider(28, { min = 0, max = 80, suffix = "ms" }),
9})
10
11local held = {}
12local virt = {}
13local lastH = nil
14
15local function setVirt(key, on)
16 if virt[key] == on then return end
17 if on then HID.Down(key) else HID.Up(key) end
18 virt[key] = on
19end
20
21local function resolve()
22 if held["A"] and held["D"] then
23 setVirt(lastH, true)
24 local other = lastH == "A" and "D" or "A"
25 local delay = Math.Random(cfg.overlap_min, cfg.overlap_max)
26 Timer.After(delay, function()
27 if held["A"] and held["D"] then
28 setVirt(other, false)
29 end
30 end)
31 else
32 setVirt("A", held["A"] or false)
33 setVirt("D", held["D"] or false)
34 end
35end
36
37function OnDown(key)
38 if not cfg.enabled then return true end
39 if key == "A" or key == "D" then
40 held[key] = true
41 lastH = key
42 resolve()
43 return false
44 end
45 return true
46end
47
48function OnUp(key)
49 if not cfg.enabled then return true end
50 if key == "A" or key == "D" then
51 held[key] = false
52 resolve()
53 return false
54 end
55 return true
56end
57
58function OnBlur()
59 for k, _ in pairs(virt) do setVirt(k, false) end
60 held = {}
61 virt = {}
62end

Questions & Answers

Your input.
Your logic.
Invisible.