an anti-synapse for your razer gear.

Neuron is one small binary that replaces Razer Synapse. It talks to your mouse and keyboard directly over raw HID, sending the same bytes Synapse does, worked out from wire captures and a lot of live probing. Doesn't require a kernel driver, vendor SDK, account, or cloud-anything. Neuron does what you tell it then gets out of your way.

Synapse grew into a two-gigabyte, account-gated, cloud-synced install that re-enables features you turned off and bolts a login screen onto your mouse dpi. Neuron is the opposite design on purpose: one tray process sitting at a few megabytes, your config as plain TOML on your own disk, and nothing running in the background that you didn't ask for.

everything is one sentence: when this, do that.

The whole app runs on a single idea. Something happens, so it does something. A button press, a drawn glyph, a radial flick, the foreground app changing, a tap on your mic mute, a held hypershift layer: those are all triggers. A keystroke, a macro, a dpi cycle, a profile switch, a raw python script: those are all actions. Bind any trigger to any action and everything further down this page is built out of that one pairing.

no driver. no sdk. just hid.

Razer's control interface answers HID feature reports, and those don't need read or write access to the device, so Neuron opens your mouse with zero desired access and speaks the exact bytes Synapse sends. That one detail is the whole foundation. There's no kernel driver to sign allowing Neuron to sidestep the "vulnerable driver" quarantines that bricked OpenRGB and SignalRGB in 2025.

On top of that sits the everyday stuff: dpi and the full stage cycle, polling up to 8000 Hz where the hardware exposes it, brightness, lift-off distance, scroll stages, battery and charge. Reads decode the device's own bytes and match Synapse to the byte. Press the onboard dpi button or snap a side-plate onto a Naga and Neuron hears the mouse announce it live, on a separate channel, without polling for it.

lighting that means something.

You get everything Synapse's lighting does (the native static, breathing, spectrum, wave, reactive and starlight effects, invoked by their real firmware ids), and then the actual point: an open theme engine sitting on top. An effect is two halves that compose, a pattern that decides where light lands and how bright, and a spectrum that decides what colour and when. Since a frame is just data, a live readout (battery, cpu, your mic peak) drops in as its own layer over a running effect, and painting the fire sim with an ocean gradient gives you cold fire with zero code. Changes apply live.

Three I built for the fun of it, so you can see what the engine gives you past the stock set:

Alongside more. Because a preset is only a pattern plus a spectrum, more will come as development goes, and adding your own is a bit of data.

hold, draw, cast.

Hold a trigger, weave a stroke, release, and it fires an action live as a real keybind. Glyphs aren't matched pixel against pixel. Each stroke is fit to a small dynamical model and identified by its eigenmotion, its natural frequency and decay, which is what makes it hold up no matter where on the screen you drew it, how big, or how fast, and lets clockwise and counter-clockwise fall out as genuinely different shapes. There's a fair amount of signal-processing work under that; the method is written up in a short paper (coming soon after release).

Because a resolved gesture is just another trigger, one capture drives a whole family of instruments: teleport pops a live minimap of your monitors you fling the cursor across, glance pulls every matching window into a magnetic collage, a dial turns the next hold into an analog slide where speed is sensitivity, and knockback is a little rhythm game your mouse plays back at you while you wait in queue.

macros are real python.

A macro is a python file with a def macro(ctx). Neuron runs it in a bundled interpreter that stays warm in the background, so firing one is basically a function call, comfortably under a frame. Unsandboxed (on purpose): ctypes, subprocess, sockets, files, anything a program can do your macro can do. In its own process, so no macro can take Neuron down... unless it explicitly takes Neuron down.

# lift.py — double-tap ctrl to boost mic gain while you talk
from neuron import on, mic, keys
 
@on(keys.double_tap("ctrl"))
def lift(ctx):
    with mic.gain(+4):
        keys.wait_release("ctrl")

Every run gets a snapshot of where you were when you fired it, frozen at trigger time, so the whole thing reasons about one consistent moment. And if you'd rather not write python, the GUI has a block builder that writes the source for you, losslessly both ways :)

hold a key, get a second keyboard.

Razer ships hypershift as hold-only. Neuron makes the layer first-class and gives it four stances, then makes sure releasing one layer only drops that layer, so two held layers never stomp each other.

it changes what you ask, and nothing else.

This is a tool whose whole job is injecting input and writing to your hardware, so the safety has to be real. Every synthesised keystroke runs through one switch that starts disarmed, and only the running app ever flips it on. Every write backs the device up first, takes effect in volatile memory before anything gets flashed, then reads itself back to confirm the bytes actually landed. A mismatch is a hard error, never a silent success, and where there's no opcode Neuron trusts, it simply refuses.

Nothing changes quietly, either. Every committed change pops a small card on screen after it lands, and you drag a little mock-monitor to say where those cards appear. Think of it as the OSD Synapse throws at you, minus the part where you can't turn it off.

bring your settings, then purge synapse.

Synapse's export files are just zips of plaintext xml, so Neuron reads one directly, keeps only the binds you actually changed, and throws away the hundred keys still sitting on their defaults. Run it dry and it shows you exactly what it would import and what it dropped, before anything is committed.

When you're ready to be rid of it, Neuron can figure out which services are Razer's by asking who installed them, stops them respawning, and ends the whole tree. 

run and done.

A few megabytes, source-available, Windows today with Linux and macOS kept behind seams for later^TM. Your config is plain TOML you own, and deleting the binary leaves nothing running and nothing behind. Fair warning: this is public beta mk1, from one dev on one desk. It runs on mine every day, but it honestly hasn't been tested on yours... yet ;)