Open-source RGB lighting engine for Linux, Windows, and macOS
✦ Your world is a canvas: paint every pixel. ✦
Vision • How It Works • Features • The UI • The TUI • Get Started • Effect SDK • Architecture • Status • Security • Contributing
RGB lighting is a mess. Single-vendor tools that don't talk to each other, half-working daemons, and effects that look like they were designed in 2012. The one great effects engine is proprietary, Windows-only, and behind a subscription.
Hypercolor is the fix.
One app. Every RGB device you own. Motherboards, keyboards, mice, LED strips, smart lights, case fans, all driven by the same engine at up to 60fps. Effects aren't hardcoded routines. They're web pages, rendered by an embedded Servo browser and sampled onto your physical LED layout every frame. And it runs on Linux, Windows, and macOS.
Your world is a canvas. Paint every pixel.
graph LR
subgraph Input
A[Audio FFT]
B[Screen Capture]
C[Keyboard / MIDI]
end
subgraph Engine
D[Effect Renderer<br><i>Servo · wgpu · Canvas</i>]
E[Canvas<br><i>640 × 480 default</i>]
SF[SparkleFlinger<br><i>compositor</i>]
F[Spatial Sampler]
end
subgraph Hardware
G[Razer · Corsair · ASUS<br><i>USB / HID / I2C</i>]
H[WLED · Hue · Nanoleaf<br><i>UDP / REST / mDNS</i>]
I[QMK · Push 2<br><i>USB HID · USB MIDI</i>]
end
A & B & C --> D
D --> E --> SF --> F
F --> G & H & I
Effects render to a virtual RGBA canvas, 640×480 by default and tunable in the daemon's rendering
settings. SparkleFlinger, the render-thread compositor, latches the newest surface from each
producer at the frame boundary and blends them into one canonical frame every tick. The spatial
engine samples that frame at each LED's physical position. Effects use normalized [0.0, 1.0]
coordinates, so they stay resolution-independent across canvas sizes. Audio, screen capture, and
keyboard input feed the render every frame. One effect paints the whole room. Your keyboard,
your LED strip, your case fans, all drawing from the same source.
Hypercolor tracks 414 devices across 32 vendors in data/drivers/vendors/. 179 ship with a working driver today across 12 driver families. 233 more are researched or known, awaiting implementation or hardware to test.
| Vendor | Supported | In progress | Researched | Blocked | Drivers |
|---|---|---|---|---|---|
| Ableton | 1 | — | — | — | push2 |
| Alienware | — | — | 3 | — | — |
| Aqua Computer | — | — | 4 | — | — |
| ASRock | — | — | 4 | — | — |
| ASUS | 10 | — | 10 | — | asus |
| Cooler Master | — | — | 20 | — | — |
| Corsair | 49 | — | 34 | — | corsair |
| Dygma | — | — | — | 2 | dygma |
| EVGA | — | — | 7 | — | — |
| Fnatic | — | — | 3 | — | — |
| Gigabyte | — | — | 8 | — | — |
| Glorious | 1 | — | 4 | — | qmk |
| Govee | 4 | — | — | — | govee |
| HyperX | — | — | 16 | — | — |
| HYTE | — | — | 2 | — | — |
| Lian Li | 9 | — | 2 | — | lianli |
| Logitech | — | — | 9 | — | — |
| Mountain | — | — | 4 | — | — |
| MSI | — | — | 11 | — | — |
| Nanoleaf | 1 | — | — | — | nanoleaf |
| Nollie | 19 | — | — | — | nollie |
| NZXT | — | — | 17 | — | — |
| Philips | 1 | — | — | — | hue |
| PrismRGB | 3 | — | — | — | nollie, prismrgb |
| QMK | 10 | — | — | — | qmk |
| Razer | 70 | — | 38 | — | razer |
| Roccat | — | — | 14 | — | — |
| Sony | — | — | 3 | — | — |
| SteelSeries | — | — | 6 | — | — |
| Thermaltake | — | — | 10 | — | — |
| WLED | 1 | — | — | — | wled |
| Wooting | — | — | 4 | — | — |
New drivers land often. Full matrix: docs/content/hardware/compatibility.md. If you own hardware Hypercolor doesn't support yet, see CONTRIBUTING.md.
- Servo: an embedded browser rendering HTML Canvas, WebGL, and GLSL shaders headless at 60fps. Existing community effects work unmodified.
- wgpu: native GPU shaders compiled to Vulkan, OpenGL, or Metal for maximum performance.
Hypercolor ships 57 built-in effects (46 authored with the SDK, 11 native Rust) spanning ambient, audio-reactive, shader, generative, and interactive styles, plus 7 display faces for devices with LCD panels. Ambient backgrounds, shader-heavy showpieces, beat-synced visualizers, and Keystrike, an interactive effect that lights up under your keystrokes. Every one is open source and built to be forked, and the catalog ships with curated cover art and tuned presets.
| Borealis | Neon City | Hyperspace | Cymatics |
| Synth Horizon | Fractalux | Iris | Arc Storm |
| Voidweaver | Lava Lamp | Ink Tide | Wormhole |
| Nebula Drift | Frequency Cascade | Spectral Fire | Cyber Descent |
| Bubble Garden | Nyan Dash | Deep Current | Breakthrough |
Map your physical desk in the UI. Drag devices onto a 2D canvas, define LED topologies (strips, matrices, rings), and the spatial sampler resolves pixels to LEDs. Pick nearest, bilinear, area average, or Gaussian sampling at every position.
FFT with beat detection, mel-band analysis, chromagram, and spectral features. Effects react to bass hits, BPM, spectral centroid, or the full 200-bin spectrum. Lock-free buffering keeps the render loop from ever blocking on audio.
Effects can react to your keyboard and mouse. The input pipeline is consent-gated and demand-driven: it is off by default, sources open devices only while an interactive effect is running, and input events ride a dedicated control-tier channel that never leaves the render pipeline. Native backends per platform: evdev on Linux, Raw Input on Windows, and a polling bridge on macOS.
- Scene engine with priority stacking, Oklab cross-fades, and automation rules
- Display faces for LCD-equipped devices: clocks, sensor dashboards, now-playing panels
- Screen capture input for ambient backlighting: Desktop Duplication on Windows (works out of the box), Wayland portal on Linux (opt-in)
- Portable device identity: devices keep their identity across cable moves, IP churn, and BIOS renumbering, and layouts can be rebound after hardware swaps
- REST API + WebSocket for full programmatic control
- MCP server for AI assistant integration (Claude Code, Cursor, and friends)
- CLI tool (
hypercolor) with table/JSON output and shell completions - Hot-reload on effect changes, no restart required
- Session and power awareness on Linux (logind, screensaver) via D-Bus
The web UI is built right in: open http://localhost:9420 and everything is there, no
separate install. Browse effects, tweak controls live, manage devices, and design spatial
layouts from any browser. The whole thing is responsive, so your phone works as a remote
control for the rig.
 Effects browser with live preview |
 Control panel with canvas preview |
 Drag-and-drop spatial layout editor |
 Device management |
 Fullscreen canvas: Bubble Garden |
 Fullscreen canvas: Cymatics, audio-reactive |
- Effects browser: search, filter by category, favorites, audio-reactive tags
- Live canvas preview: the active effect streams in the sidebar and control panel
- Auto-generated controls: sliders, dropdowns, color pickers, and toggles derived from effect metadata
- Spatial layout editor: drag-and-drop device placement on a 2D canvas
- Ambient reactivity: the UI tints its edges to match the active effect
- Command palette (⌘K) for keyboard-driven navigation
A terminal UI with true-color LED preview, audio visualization, and fullscreen effect rendering. Runs wherever you have a terminal.
 Dashboard with live preview and device table |
 Effects browser with control sliders |
- Live effect preview rendered in true-color half-block characters
- Fullscreen mode (
z) fills the entire terminal with the active effect - Audio spectrum with level meter and beat indicators
- Quick actions: number keys for instant effect switching
Hypercolor ships installers for Linux, Windows, and macOS with every release. Grab the artifact for your platform from the GitHub releases page, or use one of the paths below.
The release installer downloads the right tarball, verifies its checksum, sets up the
systemd user service, and offers to install udev rules and i2c-dev persistence:
curl -fsSL https://raw.githubusercontent.com/hyperb1iss/hypercolor/main/scripts/install-release.sh | bashDebian and Ubuntu users can install the .deb from the releases page. Arch users have
hypercolor-bin on the AUR, and the
Homebrew formula works on Linux too: brew install hyperb1iss/tap/hypercolor.
Building from source instead:
git clone https://github.com/hyperb1iss/hypercolor.git
cd hypercolor
cargo install just
just setup
just installSetup installs the Rust toolchain, system packages, Bun, Trunk, cargo-deny, and frontend
dependencies. The installer then builds the daemon, CLI, TUI, web UI, and bundled effects,
installs a systemd user service, sets up udev rules for USB and input device access, and
persists i2c-dev so SMBus RGB devices survive reboot.
Grab Hypercolor_<version>_x64-setup.exe from the
GitHub releases page. The install is
per-machine, so expect one UAC prompt; hardware setup runs inside that same elevated pass,
including the optional PawnIO driver that unlocks
motherboard and DRAM SMBus lighting (ASUS Aura and friends). Hypercolor only offers the
PawnIO step when compatible hardware is detected. Tested on Windows 10 22H2 and
Windows 11 23H2/24H2, x64.
Current Windows builds are not code-signed, so SmartScreen will warn on first run. Choose More info, then Run anyway.
Hue, WLED, Nanoleaf, Govee, and USB-HID lighting (Razer, Corsair, Lian Li, and friends) work out of the box. So do screen-reactive effects: Windows capture uses Desktop Duplication and is enabled by default.
The macOS DMGs (Hypercolor-<version>-arm64.dmg for Apple Silicon, -x86_64.dmg for
Intel) are on the
GitHub releases page. Drag the app
into /Applications and launch. Minimum macOS 11 (Big Sur).
Or via Homebrew Cask:
brew install --cask hyperb1iss/tap/hypercolor-appCurrent builds carry an ad-hoc signature rather than a notarized Developer ID one, so Gatekeeper flags the first launch. Right-click the app and choose Open to confirm.
Hue, WLED, Nanoleaf, Govee, and USB-HID lighting all work out of the box. On first run, macOS prompts for Microphone access if you enable audio-reactive effects.
| Capability | Linux | Windows | macOS |
|---|---|---|---|
| Effects, devices, web UI, TUI, CLI | ✓ | ✓ | ✓ |
| Audio-reactive (microphone) | ✓ | ✓ | ✓ |
| Audio-reactive (system audio) | ✓ native monitor | loopback device¹ | loopback device¹ |
| Screen capture | Wayland portal, opt-in | Desktop Duplication, default on | not available |
| Keyboard/mouse input | evdev | Raw Input² | polling bridge |
| Motherboard / DRAM RGB (SMBus) | i2c-dev |
PawnIO helper | not available |
| Session and power integration | logind + screensaver | not yet | not yet |
| Background service | systemd user service | Windows service³ | launchd agent |
¹ System-audio reactivity needs a loopback input the OS exposes: Stereo Mix or a virtual cable on Windows, BlackHole or Loopback on macOS. ² A daemon installed as a Windows service cannot see host input across the session boundary; run it in your session for interactive effects. ³ Or per-user autostart via the desktop app.
Installed the desktop app? Just launch Hypercolor and you're done: it starts the engine, sits in your tray, and opens the UI. The terminal route works everywhere too:
# Start the engine (serves the UI at http://localhost:9420)
hypercolor-daemon
# Control from the command line
hypercolor effects list
hypercolor effects activate "Neon City"
hypercolor devices list
# Or drop into the interactive terminal dashboard (auto-starts a local daemon)
hypercolor tuiHacking on Hypercolor itself? We use just for development workflows.
just daemon # Run daemon locally
just tui # Run the TUI
just ui-dev # Leptos UI dev server on :9430
just sdk-dev # SDK dev server with HMR
just verify # fmt + lint + testjust verify covers the Rust workspace. Use the focused gates for surfaces outside
that workspace: just ui-test && just ui-build for the Leptos UI, just sdk-lint && just sdk-check && just sdk-build for the TypeScript SDK, just python-verify
for the Python client, just compat-check for device data, and just docs-build
for documentation.
Effects are TypeScript, Canvas, or pure GLSL. The SDK compiles them to self-contained HTML files that the engine renders at 60fps. Audio data, control values, and canvas context are all injected automatically.
import { effect } from "hypercolor";
import shader from "./fragment.glsl";
export default effect(
"Borealis",
shader,
{
speed: [1, 10, 5], // → slider
intensity: [0, 100, 82], // → slider
palette: ["Northern Lights", "SilkCircuit", "Cyberpunk"], // → dropdown
},
{
description: "Aurora borealis, layered curtains of light",
},
);Four tiers, pick the one that fits: GLSL (single file, zero JS), effect() (one-liner
shader binding), canvas() (Canvas 2D draw functions), and full OOP (class-based with
lifecycle hooks).
See the Effect SDK Guide for the full API reference.
graph TD
subgraph types [hypercolor-types]
T[Shared vocabulary<br><i>zero deps</i>]
end
subgraph hal [hypercolor-hal]
H[USB/HID Drivers<br><i>Razer · Corsair · ASUS · Nollie · QMK · ...</i>]
end
subgraph platform [Platform Interop]
LGI[linux-gpu-interop<br><i>GL→wgpu import</i>]
MGI[macos-gpu-interop<br><i>IOSurface import</i>]
WGI[windows-gpu-interop<br><i>ANGLE/D3D11 import</i>]
WCA[windows-capture<br><i>Desktop Duplication</i>]
WIN[windows-input<br><i>Raw Input</i>]
WPI[windows-pawnio<br><i>SMBus via PawnIO</i>]
end
subgraph core [hypercolor-core]
C[Engine<br><i>render loop · spatial · audio · effects</i>]
end
subgraph drivers [Network Drivers]
API[driver-api]
DB[driver-builtin<br><i>compile-time bundle</i>]
API --> HUE[Hue]
API --> NL[Nanoleaf]
API --> WL[WLED]
API --> GV[Govee]
HUE & NL & WL & GV --> DB
end
subgraph daemon [hypercolor-daemon]
D[REST API · WebSocket · MCP<br><i>Axum on :9420</i>]
end
subgraph clients [Clients]
CLI[CLI<br><i>hypercolor</i>]
TUI[TUI<br><i>Ratatui</i>]
UI[Web UI<br><i>Leptos WASM</i>]
DT[Desktop<br><i>Tauri</i>]
TR[Tray<br><i>System applet</i>]
APP[app<br><i>unified shell</i>]
end
T --> H & C & LGI & MGI & WGI & WCA & WIN & WPI
H --> C
LGI & MGI & WGI & WCA & WIN & WPI --> C
C --> API
H --> DB
C & H & DB --> D
D --> CLI & TUI & UI
APP --> DT & TR & D
It's Rust all the way down. The daemon, CLI, TUI, tray applet, and HAL drivers are all Rust. The web UI is Rust compiled to WASM via Leptos. Even the embedded browser is Servo (Rust). The only non-Rust code is the TypeScript effect SDK and the GLSL shaders it compiles.
The render thread runs on a dedicated OS thread with adaptive FPS (10 to 60, auto-shifting
across 5 tiers based on measured budget). Each tick, SparkleFlinger composes frame producers
into one canonical surface, with a zero-copy bypass fast path when a single full-opacity
layer is active. The event bus uses lock-free tokio::sync::watch channels for high-frequency
frame data and broadcast for discrete events. zerocopy structs handle wire-format encoding
at zero allocation cost per frame. The spatial engine caches LED positions and samples the
composed frame with configurable interpolation (nearest, bilinear, area average, Gaussian).
Workspace lints forbid unsafe in application, driver, and domain crates. The explicit
exceptions are the audited platform interop crates (GPU surface import on all three
platforms, Windows capture, host input, the PawnIO SMBus broker, and platform filesystem
glue) plus the desktop app shell; each opts out explicitly and denies undocumented unsafe
blocks. Edition 2024. Rust 1.94+.
Hypercolor is in active development. The core engine, effect SDK, web UI, TUI, and 12 shipping driver families work today on Linux, Windows, and macOS, and every release ships installers for all three. Every screenshot in this README was captured from a live instance running on real hardware.
Worth knowing before you install:
- macOS has no screen capture path yet, and SMBus (motherboard/DRAM RGB) is Linux and Windows only. The "What works where" table above has the full picture.
- Session and power integration (idle dim, sleep/resume device rescan) is Linux-only today.
- Windows and macOS binaries are not yet code-signed, so expect a SmartScreen or Gatekeeper speed bump on first launch.
- The
hypercolorSDK andcreate-hypercolorscaffolder are on npm; scaffold an effect workspace withbun create hypercolor. The Python client is on PyPI ashypercolor.
Coming soon: effect marketplace, Wasmtime plugin system for community backends, Wooting analog keyboards, and driver families for Cooler Master, NZXT, and Logitech. See the full compatibility matrix for researched hardware waiting on implementation.
Please report vulnerabilities through the process in SECURITY.md. Community
participation follows the CODE_OF_CONDUCT.md.
Hypercolor grows on contributions. Drivers, effects, UI polish, docs, all of it lands here.
Writing effects is the fastest way in. The SDK compiles TypeScript, Canvas, or GLSL straight to HTML, and the engine picks them up on save. Device drivers are where the leverage is highest. If you own hardware that isn't on the supported list, you're the person to add it.
See CONTRIBUTING.md for guidelines.
Apache-2.0. See LICENSE.
If Hypercolor lights up your desk, give us a ⭐ or support the project
✦ Built with obsession by Hyperbliss ✦