Noureddine RAMDI / HyperHDR: floating-point color pipeline for low-latency ambient lighting

Created Mon, 04 May 2026 10:23:01 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
992 Words
github-stars c++ ambient-lighting embedded led color-processing raspberry-pi

awawa-dev/HyperHDR

Ambient lighting systems often struggle with color banding and flickering due to limited color precision and latency issues. HyperHDR tackles these challenges head-on with a floating-point color processing pipeline and custom LED control protocols that run efficiently even on resource-constrained platforms like the Raspberry Pi. This repo is worth a look if you care about smooth, high-quality ambient lighting synchronized to video or audio sources without taxing your CPU.

What HyperHDR does: a high-performance ambient lighting platform

HyperHDR is an open-source ambient lighting system written in C++ designed to process real-time video and audio streams and drive LED strips behind TVs or around music setups. Its core functionality revolves around capturing screen content or audio signals, processing them with advanced color algorithms, and outputting signals to a variety of LED hardware.

Under the hood, HyperHDR implements the v22 Infinite Color Engine, which uses floating-point arithmetic instead of the usual 24-bit RGB integer math. This approach eliminates the typical precision loss and banding artifacts that plague 8-bit per channel color pipelines. The color pipeline supports HDR tone mapping, automatic detection and conversion between HDR and SDR content, and RGB-to-RGBW conversion with temporal dithering to reduce flickering on LED strips.

The system supports hardware-accelerated screen capture techniques such as DirectX on Windows and PipeWire on Linux, ensuring efficient frame grabbing. It also supports USB grabbers with multiple video formats including P010, NV12, and YUYV, which are common in video capture devices. These features allow smooth video processing at 1080p or higher resolutions with low CPU overhead, even on single-board computers like the Raspberry Pi 4 or Intel N100.

Output to LEDs is handled through ultra-fast custom controllers such as HyperSPI, HyperSerial, and Hyperk, supporting popular LED protocols like WS281x, APA102, SK6812, and even more complex devices like Philips Hue and HD108. The communication channels can reach speeds of 2Mb+ over USB serial connections, which helps maintain ultra-low latency.

Why HyperHDR stands out: floating-point color pipeline and custom LED control

The standout technical feature is the Infinite Color Engine’s floating-point pipeline for color processing. Most ambient lighting systems rely on 24-bit RGB integer math, which introduces quantization errors leading to visible banding and color artifacts, especially in smooth gradients or HDR content. HyperHDR avoids this by using floating-point arithmetic internally, preserving color fidelity and enabling seamless tone mapping.

This design choice is not trivial — floating-point math typically demands more CPU and memory. However, HyperHDR achieves ultra-low CPU usage on embedded platforms by optimizing video processing pipelines and using hardware acceleration for capture. This balance between precision and performance is a key tradeoff.

Another technically interesting aspect is the RGB-to-RGBW conversion with temporal dithering. RGBW LEDs add a dedicated white channel to improve brightness and color accuracy but complicate color conversion. HyperHDR’s algorithm dynamically converts colors into RGBW space and applies temporal dithering to reduce flickering that can occur when LED brightness values rapidly change frame to frame. This results in smoother, more stable lighting.

The custom LED controllers (HyperSPI, HyperSerial, Hyperk) are designed for extremely fast data transfer and minimal latency. Unlike some generic LED control libraries, these controllers are tailored to specific hardware protocols and support deep-color devices. The repo demonstrates careful low-level engineering to squeeze high throughput from USB serial ports and SPI buses.

The system’s architecture avoids heavy runtime dependencies, which is crucial for embedded use cases where footprint and reliability matter. It’s clear the codebase is production-ready with an emphasis on performance, hardware compatibility, and extensibility.

Explore the project: navigating HyperHDR’s codebase and documentation

The repo’s README provides a comprehensive overview of features and supported hardware. It also details the Infinite Color Engine’s principles and the LED output protocols.

Key directories to check out:

  • src/capture: Implements hardware-accelerated screen and video capture methods.
  • src/color: Contains the Infinite Color Engine algorithms, including floating-point color math and tone mapping.
  • src/output: Houses the custom LED controllers and output drivers for various LED protocols.
  • docs/: Documentation on installation, configuration, and hardware support.

The project uses C++17 and targets Linux and Windows primarily, with cross-compilation support for embedded devices like Raspberry Pi. The build system is based on CMake, which should be familiar to C++ developers.

The repository encourages contributions and provides detailed issue templates and guidance for hardware integration and bug reports.

Verdict: who should use HyperHDR and what to expect

HyperHDR is a solid choice for developers and hobbyists looking to build high-quality ambient lighting solutions that can run on low-power devices like Raspberry Pi or Intel N100. Its floating-point color pipeline and low-latency LED control make it suitable for setups where color smoothness and responsiveness matter.

The tradeoff is the complexity of the codebase and C++ build environment, which may present a steeper learning curve compared to simpler, Python-based projects. Also, while optimized for embedded platforms, it still relies on specific hardware capture methods and LED controllers, so hardware compatibility should be verified in advance.

Overall, HyperHDR offers a pragmatic balance between advanced color processing techniques and real-world performance constraints, backed by a clean, maintainable C++ codebase. If you want to avoid the usual banding and flickering issues in ambient lighting and are comfortable with C++ and embedded development, this repo is worth exploring.

→ GitHub Repo: awawa-dev/HyperHDR ⭐ 1,935 · C++