RRebind
All posts
·Rebind

SnapTap and SOCD on Hardware: How to Set It Up with Rebind

SnapTap (Simultaneous Opposing Cardinal Directions) handling at the hardware level — no game client detection, no driver hooks, just clean USB HID output from a dedicated device.

snaptapsocdhardware macrosrebind scriptrebind luacompetitive

SnapTap — Razer's marketing name for automatic SOCD (Simultaneous Opposing Cardinal Directions) resolution — became a flashpoint in competitive shooters in 2024. The idea: when you press both A and D simultaneously, instead of cancelling out, the most recently pressed key takes priority. This eliminates the stutter that comes from trying to counter-strafe manually with precise timing.

Razer built it into their keyboard firmware. Wooting calls theirs Snappy Tappy. Other keyboard vendors followed. The catch: all of these are software features running on firmware that your OS can see, profile, and in some cases detect.

Rebind implements the same behavior as a Luau script running on a dedicated USB microcontroller. The output is indistinguishable from a standard keyboard. Here's how to set it up.

How SOCD resolution works

In most games, pressing A and D simultaneously results in either cancellation (no movement) or undefined behavior. The "last input wins" approach means:

  1. You press A — character moves left
  2. You press D while still holding A — character immediately moves right (D is now the active direction)
  3. You release D while still holding A — character immediately moves left again

This enables much faster counter-strafing than waiting for precise manual timing. In games like CS2 and Valorant where stopping acceleration is instant, this lets you reach a stopped state more reliably before shooting.

The Rebind SOCD script

This script handles the W/A/S/D cluster with last-input-wins semantics. Each opposing pair (A/D and W/S) resolves independently:

-- rebind: name=SOCD / SnapTap
-- rebind: description=Last input wins for WASD opposing directions

local cfg = UI.Schema({
    enabled = UI.Toggle(true, { label = "Enable" }),
})

-- track held state for each direction
local held = { W = false, A = false, S = false, D = false }

-- opposing pairs
local opposites = { W = "S", S = "W", A = "D", D = "A" }

function OnDown(key)
    if not cfg.enabled then return true end
    if not held[key] then return true end

    held[key] = true
    local opp = opposites[key]

    -- if the opposite is held, release it so this key wins
    if opp and held[opp] then
        HID.Up(opp)
    end

    return true  -- pass the new keypress through
end

function OnUp(key)
    if not cfg.enabled then return true end
    if not held[key] then return true end

    held[key] = false
    local opp = opposites[key]

    -- if the opposite is still physically held, re-press it
    if opp and held[opp] then
        HID.Down(opp)
    end

    return true
end

What this does on each keypress:

  • Tracks which WASD keys are physically held
  • When a new direction key comes in, checks if the opposing direction is held
  • If so, releases the opposing key in the HID output (the PC stops seeing it)
  • When the new key is released, if the opposite is still physically held, re-presses it

The result from the PC's perspective: it always sees only the last-pressed direction key in any opposing pair.

Why hardware matters here

Software SOCD implementations — including the ones built into Razer's and Wooting's driver stacks — run on the PC as firmware features that the OS is aware of. The keyboard reports its capabilities, and the driver intercepts and modifies input before it reaches games.

Rebind's implementation runs on the Teensy microcontroller. The SOCD resolution happens before the output device even speaks to the PC. By the time Windows sees anything, it's already seeing clean, resolved USB HID key events from what looks like a standard keyboard. There's nothing in the driver stack to profile.

This also means the script works the same way on any USB keyboard you plug into Rebind — not just one specific brand.

Targeting a specific game

If you only want SOCD active in certain games, add a process= modeline:

-- rebind: name=SOCD - CS2 Only
-- rebind: process=cs2.exe

-- ... same script body

The script becomes completely dormant when CS2 isn't focused. Other applications see your raw, unmodified keypresses. You can keep the global version and the game-specific version as separate scripts and enable whichever you want.

Extending to other key pairs

The same pattern works for any opposing pair — not just WASD. Arrow keys, game-specific bindings, anything:

local held = {}
local opposites = {
    -- WASD
    W = "S", S = "W", A = "D", D = "A",
    -- Arrow keys
    Up = "Down", Down = "Up", Left = "Right", Right = "Left",
}

Add any pairs you want resolved to the opposites table and add their names to the initial held table.

Writing this with RebindGPT

If you'd rather describe what you want than write it yourself, RebindGPT can generate this script — and much more complex ones — from a plain English description. The SnapTap script above was one of the first things users asked for when RebindGPT launched.

Back to all posts