# Corsair Lighting Protocol turns an Arduino into a device iCUE recognises

> Corsair Lighting Protocol is an Arduino library that implements Corsair's DIY device protocol, so a board with the right USB descriptor shows up in iCUE as a Lighting Node PRO and can be driven from Corsair's own software. The supported board list is narrow and stated precisely, since the protocol runs over USB and that decides what can host it.

**Legion2/CorsairLightingProtocol** — Control LEDs connected to an Arduino with iCUE, create an unofficial Corsair iCUE compatible Arduino LED controller.

- Repository: https://github.com/Legion2/CorsairLightingProtocol
- Stars: 572 · Forks: 72
- Language: C++
- License: Apache-2.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/legion2-corsairlightingprotocol

## What the library actually does

Corsair Lighting Protocol is described as a library that can be used to integrate custom or unofficial RGB strips with iCUE, and it is stated clearly that this is not an official Corsair project.

The mechanism is the DIY device protocol. The first feature is support of the Corsair DIY device protocol to Arduino, the second is control of LEDs with the Corsair iCUE software, and the third is support for common LED chipsets with WS2812B and WS2801 given as examples.

So the flow is that you flash an Arduino with a sketch that presents the right USB device identity, and then Corsair's own software enumerates it and lets you assign effects to it the way you would to a real Corsair strip. That is a different proposition from driving pixels with FastLED directly, and the difference is that the software doing the driving is Corsair's.

The rest of the feature list covers the practical dimensions. FastLED is supported as the underlying LED library, so the chipset coverage follows FastLED's chipset list rather than the library maintaining its own. Supported platforms are Arduino AVR and TinyUSB supported cores. Hardware Lighting mode is supported, which is the mode where a lighting effect is rendered by the device itself rather than by the host. Multiple devices can be used at the same time. And LED channels can be repeated or scaled to arbitrary size, which is how a single physical strip is presented as several logical ones to the host software.

That last one is a detail with a clear purpose. If you have an addressable strip of thirty LEDs and want iCUE to show a 60-LED effect on it, scaling the channel achieves the visual result without a second physical device.

The supported device list covers the Corsair DIY hardware the protocol talks to. Lighting Node PRO, Commander PRO, Lighting Node CORE, LS100 Smart Lighting Controller and LT100 Smart Lighting Towers.

The project is C++, Apache-2.0 licensed, with the default branch dev and the last push on 2026-08-20. The tagged releases are older, v0.15.0 from 2022-02-19, v0.14.2 from 2020 and v0.14.1 from 2020, which is worth noting for anyone deciding whether to depend on it.

## The board list is the real constraint

The requirements section is where the practical limits are, and it is unusually specific.

The library is compatible with all boards using the MCU ATmega32U4, which includes the Arduino Leonardo, the SparkFun Pro Micro, the Arduino Micro and the Adafruit 32u4 AVR boards.

Then a second path. Any board compatible with Adafruit TinyUSB for Arduino is also supported without the use of custom board definitions, and you have to define USE_TINYUSB, which is done automatically when using a supported core and selecting TinyUSB for the USB stack.

And then a third path with a catch. The Arduino Uno and the Arduino Mega are supported, but this requires the HoodLoader2 bootloader, and there is a wiki page with the details.

The reason for all of this is the USB peripheral. The DIY protocol is a USB HID device, and the board has to be able to present that device identity. The ATmega32U4 has native USB, the RP2040 on a Raspberry Pi Pico gets it through TinyUSB, and the ATmega328 on an Uno does not, so the HoodLoader2 bootloader stands in for the missing USB hardware. The README names the incompatible controllers explicitly: it is not compatible with the ATmega328 as used in the Arduino Nano, the STM8S103F3, the teensy or the ESP8266, and there is a linked issue list with a detailed description of why each is not supported.

The convention in the documentation is worth noting because it saves a lot of confusion. In the rest of the documentation Arduino is used as a synonym for all supported boards regardless of the manufacturer, so a guide that says Arduino means any board on the list.

And the last instruction is the practical one. When you have problems with a board not listed here, please open an issue.

The example sketches directory shows the shape of the supported matrix. There is LightingNodePRO, LightingNodeCORE, CommanderPRO, LS100 and LT100 for the device types, and then TinyUSB, SingleStripLightingNodePRO, MultipleFans, AmbientBacklight, NoEEPROM, NonAddressable, RepeatAndScale, AdditionalFeatures, HoodLoader2CLPBridge, HoodLoader2UnoMegaController, TransformLLFansFormatToStrip, DebugSketch, DeviceIDTool and UnitTests.

The names are a map of the feature set. NoEEPROM and NonAddressable are the two cases that break the general assumptions, and UnitTests and UnitTests2 show the library is tested rather than demoed.

## Installing it through the Arduino library manager

The install path is the ordinary Arduino one, and the library states it plainly: to use this library you must install it with the Library-Manager.

Open the Library-Manager in Arduino IDE via Tools->Manage Libraries...
Search for "Corsair Lighting Protocol" and install the Corsair Lighting Protocol library.
This library also requires the FastLED library.
Search for "FastLED" in the Library-Manager and install the FastLED library.
If using TinyUSB, also install the latest "Adafruit TinyUSB Library" as it supersedes some of the core versions.

The FastLED dependency is not optional, and the TinyUSB note matters for anyone on a board that needs it, since the Adafruit TinyUSB Library supersedes some of the core versions.

There is also a separate piece for the boards themselves. The guides refer to the CLP Boards, installed from a companion repository called CorsairLightingProtocolBoards, which provide the Arduino board definitions that let the IDE present the board as a Lighting Node. If you are on a SparkFun Pro Micro you also install the SparkFun Boards definition.

So there are three installs for the full setup: the library itself, FastLED, and the board definitions. That is more than a typical Arduino library, and it is because the protocol is not just about driving LEDs, it is about presenting a specific USB device to the host, which needs a board definition to say so.

The example sketches are how the tool teaches you to use it. Opening the LightingNodePRO example is the first check, and the documentation says that if you cannot open it, the library is not installed correctly. That is a useful diagnostic instruction, since a missing example means a broken install rather than a code problem.

Then you upload the sketch, wire the LEDs following the FastLED wiring documentation, and verify the device works. The verification step is at the operating system level: open the Windows settings, then devices, then Other devices, and somewhere in the list there should be a device called Lighting Node PRO. Only after that do you open iCUE, where you should see the Lighting Node PRO.

That ordering is the point of the whole guide. The device has to enumerate as a Corsair DIY device before iCUE will show it, so if iCUE shows nothing the problem is almost always in the enumeration step rather than in iCUE itself.

## The Pico path exists because of a FastLED gap

There is a separate guide for building a Lighting Node PRO with a Raspberry Pi Pico using TinyUSB, and it carries a note that explains a lot about how this library is maintained.

FastLED currently does not support the RP2040 natively, so you have to merge support manually by modifying your library to include the six RP2040 platform files in the FastLED platform directory, plus the conditional compilation and include statements in the header file.

That is a real burden on anyone who wants to use a Pico, and it is a symptom of the dependency relationship. The library sits on top of FastLED for the chipset support, so it inherits FastLED's platform matrix, and where FastLED has a gap the user has to patch it.

The alternative would have been for the library to implement its own timing layer, but then it would have to maintain chipset support that FastLED already does well, and the whole value of the dependency is that the chipset list comes from elsewhere.

The guide structure is the same as the AVR one, which is a sign the authors thought about the two paths as parallel rather than one being a lesser variant. The requirements, the install of the libraries, then a per-board section for creating a Lighting Node PRO, then a section on using the Lighting Node PRO, and a troubleshooting section linked from the setup steps.

The troubleshooting link is at the end of the AVR guide, and the wording is that if you have any problem during setup you may find the solution there.

The documentation also links to the other RGB control software projects the library is compatible with in spirit. There are badges for iCUE itself, for RGBSync, for the OpenRGB project on GitLab and for SignalRGB. Those are the programs that talk to Corsair devices, and the library is another way to appear in that ecosystem rather than a replacement for any of them.

The Unmaintained badge is worth checking for anyone considering a dependency, since the last tagged release is from 2022 while the last push to the dev branch is from August 2026.

## Where the library sits against the other RGB control tools

There is a second way to get non-Corsair hardware into the same RGB ecosystem, and it is worth understanding how this library relates to it.

The badges at the top of the documentation point at four projects. There is iCUE itself, which is Corsair's own software. There is RGBSync, which is an open source implementation of the Corsair protocol that aims to work without the proprietary software. There is the OpenRGB project on GitLab, which is the well known cross-vendor effort covering many manufacturers at once. And there is SignalRGB, another of the Corsair-protocol implementations.

So the DIY device protocol has an ecosystem around it, and this library is one way in from the Arduino side rather than from the PC software side.

The difference from the others is what the Arduino contributes. The PC-side tools need a Corsair device or a USB proxy that emulates one, since they speak to hardware over USB. This library makes the Arduino the device. The board is the thing that enumerates as a Lighting Node PRO, and the PC software talks to it as if it were real Corsair hardware.

That reframing explains why the board support is so specific. The library is not just driving pixels, it is impersonating a Corsair USB device, and the requirements are the requirements of that impersonation rather than of LED timing.

The practical consequence for an adopter is that this library sits in a different category from the software alternatives. OpenRGB and SignalRGB replace iCUE on your computer. This library replaces a Corsair device with an Arduino, keeping iCUE in place. If you want to drive a strip of your own LEDs from your own Arduino code, FastLED on its own is the simpler answer. If you want your hardware to show up in the Corsair software alongside your real Corsair gear, this is the tool.

That is a narrow but real use case, and it explains the shape of the repository. The extra/ directory holds the images for the documentation, the library.properties and keywords.txt files are the Arduino library manifest, and the src/ directory holds the implementation with the examples/ directory carrying one sketch per supported device and feature.

## Conclusion

Adopt Corsair Lighting Protocol if you want your own LED hardware to appear inside Corsair's iCUE software alongside your real Corsair gear, since it implements the DIY protocol on an Arduino. Skip it if you would rather drive the strips from your own code without iCUE in the picture, because FastLED alone does that, and if your board is not on the supported list. Verify first that your board uses an MCU with native USB, since the ATmega328 and ESP8266 are explicitly out, that FastLED supports your chipset, and that the device shows up in your operating system's device list before you open iCUE.

## FAQ

### What does the Corsair Lighting Protocol library do?

It adds support of the Corsair DIY device protocol to Arduino, so you can control LEDs with the Corsair iCUE software. It supports common LED chipsets through FastLED, such as WS2812B and WS2801, and it also supports hardware lighting mode, using multiple devices at the same time, and repeating or scaling LED channels to arbitrary size.

### Which Arduino boards does Corsair Lighting Protocol support?

All boards using the MCU ATmega32U4, which includes the Arduino Leonardo, the SparkFun Pro Micro, the Arduino Micro and the Adafruit 32u4 AVR boards. Any board compatible with Adafruit TinyUSB for Arduino is also supported without custom board definitions, and the Arduino Uno and Mega work but require the HoodLoader2 bootloader. It is not compatible with the ATmega328 used in the Arduino Nano, the STM8S103F3, the teensy or the ESP8266.

### How do I install Corsair Lighting Protocol and check it works?

Install it with the Library-Manager in the Arduino IDE by searching for Corsair Lighting Protocol, install the FastLED library as well, and if you are using TinyUSB also install the Adafruit TinyUSB Library. Install the CLP Boards from the companion CorsairLightingProtocolBoards repository, upload the LightingNodePRO example sketch, wire the LEDs, then check Windows settings under devices and Other devices for a device called Lighting Node PRO before opening iCUE.

## Sources

- [Issues](https://github.com/Legion2/CorsairLightingProtocol/issues)
- [Legion2/CorsairLightingProtocol on GitHub](https://github.com/Legion2/CorsairLightingProtocol)
- [License: Apache-2.0](https://github.com/Legion2/CorsairLightingProtocol/blob/dev/LICENSE)
- [README](https://github.com/Legion2/CorsairLightingProtocol/blob/dev/README.md)
- [Releases](https://github.com/Legion2/CorsairLightingProtocol/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/legion2-corsairlightingprotocol