rogauracore: a small Linux CLI for the RGB keyboard on Asus ROG laptops

Why a Linux tool exists for a Windows-only lighting suite

Asus ROG laptops ship with a lighting control panel for their RGB keyboard that only runs on Windows. rogauracore is a Linux-compatible open-source libusb implementation that does the same job from a command line, and the project describes it as similar to the ROG Aura Core software.

The scope is deliberately narrow. There is no daemon, no config file format and no lighting profile system. A command is executed, the USB device is sent a message, and the program exits. For a user whose only goal is a differently coloured keyboard in a shell script or a window manager keybinding, that is the whole feature set, and the small surface area is also why it can run on a machine that Asus never shipped Linux lighting software for.

The cost of that focus is that this is a device tool, not a lighting platform. The upstream project points to OpenRGB as something that can probably do everything rogauracore can do, and to two graphical front ends built on top of this command line tool.

The USB IDs that decide whether your laptop is supported

Support is defined by the USB vendor and product ID of the keyboard controller, and the list is the single most important fact to check before anything else. The documented IDs are 0b05:1854 for the GL553 and GL753, 0b05:1869 for the GL503, FX503 and GL703, 0b05:1866 for the GL504, GL533, GL703, GX501 and GM501, 0b05:19b6 for the GA503, and 0b05:1a30 for the GZ302EA.

That enumeration is the compatibility contract, and it is a contract in both directions. A laptop from a listed family is likely to work, but the list is not a promise of behaviour, since the project does not document which lighting effects each model implements. A model outside the list has no path in this tool, because the message format is the vendor protocol rather than a generic HID feature that a generic driver could drive.

The three-digit hex strings you pass to the colour commands are RGB triplets in the same order, which is why the examples in the documentation use 0000ff, 00ff00 and ffff00 for blue, green and yellow. The command set also includes named colours, so the shorthand is there for interactive use.

Building rogauracore from a release tarball on Ubuntu

Installation is a conventional autotools build, and the documentation gives two routes to the sources. The runtime and development libraries come first:

sudo apt install libusb-1.0-0 libusb-1.0-0-dev

Build tools are optional but usually needed:

sudo apt install build-essential autoconf git

The first route downloads a tagged release tarball, with the version pinned in a shell variable so the archive name and directory match:

VERSION=1.6
curl -LOs https://github.com/wroberts/rogauracore/releases/download/$VERSION/rogauracore-$VERSION.tar.gz
tar xf rogauracore-$VERSION.tar.gz
cd rogauracore-$VERSION/

The second route clones the repository and regenerates the build system, which is the path to take if you want the source newer than the newest tagged release:

git clone https://github.com/wroberts/rogauracore.git
cd rogauracore
autoreconf -i

Both routes end the same way, with configure, make and an install into the system paths:

./configure
make
sudo make install

The repository tree shows a Makefile.am and configure.ac at the top level, with the C sources under src, a data directory and a prototype directory, which is the standard shape for a project built with autotools and libusb.

The command list: static, breathing, cycle and named colours

The usage text is the entire user interface, and it is short enough to read in full:

Usage:
   rogauracore COMMAND ARGUMENTS

COMMAND should be one of:
   single_static
   single_breathing
   single_colorcycle
   multi_static
   multi_breathing
   rainbow_cycle
   red
   green
   blue
   yellow
   gold
   cyan
   magenta
   white
   black
   rainbow
   brightness
   initialize_keyboard

The naming distinguishes two axes. The single and multi prefixes separate lighting every key in one colour from assigning a colour per key, and the static, breathing and colorcycle suffixes are the three effects. The single_effect forms take one RGB value, and multi_static takes one value per key:

sudo rogauracore single_static 0000ff
sudo rogauracore single_static 00ff00
sudo rogauracore single_static ffff00
sudo rogauracore multi_static ff0000 ffff00 00ff00 00ffff
sudo rogauracore single_colorcycle 1

Those five lines are the quick check the documentation suggests. If the keyboard lights up blue, then green, then yellow, and the per-key command paints four zones, you have a working device. Beyond that, rainbow_cycle and rainbow cover a rotating rainbow effect, and the colour names cover the common cases without hex codes.

Root privileges, a sleeping keyboard and a dark backlight

Two things get in the way of a first successful run, and the documentation addresses both with specific commands. The first is permissions. Direct communication with the laptop keyboard needs root, and the tool is normally invoked through sudo:

sudo rogauracore initialize_keyboard

That command is the answer to a keyboard that does not respond at all. The documentation describes sending an initialisation message to the keyboard to wake it up, which is worth remembering as the first thing to try before assuming the USB ID is unsupported.

The second is brightness. If the keyboard remains dark after a colour command, the brightness may have defaulted to 0, and the fix is to set it explicitly:

sudo rogauracore brightness 3

Both are hardware state problems rather than software bugs, and both are cheap to check. A user who sees nothing at all should try brightness before spending time on the USB ID, and should keep initialize_keyboard in mind for a machine that has been asleep or suspended.

The upower side effect that leaves the backlight controls dead

There is one documented side effect worth knowing about in advance. On some machines, running rogauracore causes the system power management to no longer find the keyboard backlight control, which shows up as unresponsive user interface controls for brightening and darkening the backlight. The fix suggested in the documentation, credited to @willlovesbearz, is to restart upower after running the tool:

sudo systemctl restart upower.service

That is a genuine trade-off, and it is the kind that a lighting utility should not need. The tool itself does not appear to modify system configuration, yet running it can leave a desktop power service unable to see the backlight device, which means brightness controls in the desktop stop working until the service is restarted. On a laptop where the panel is your only light source in a dark room, that is worth knowing before you make rogauracore part of a login routine.

Note the shape of the workaround: it is a manual command, not a documented integration, so a script that sets the colour automatically at boot would need to run the restart itself.

OpenRGB for general lighting, GUIs for convenience

The project lists its own alternatives, and the difference in approach matters. OpenRGB is described as something that can probably do all the things rogauracore can do. The distinction is scope: rogauracore speaks one vendor protocol for a specific set of Asus ROG keyboards over libusb, whereas OpenRGB is a general lighting control project aimed at many vendors and many devices. If your goal is one ASUS laptop keyboard and you want a small, predictable tool with a documented command set, rogauracore is the narrower and simpler answer. If you have several RGB devices from different manufacturers, the general tool is the one built for that.

The other two entries are front ends rather than competitors. rogauracore-gui is an Electron-based GUI for rogauracore by @rastafaninplakeibol, and rog-auracore-gui is a native GTK3 GUI for rogauracore by @alek.cora.glez, installable through a PPA. Both wrap the same command line program, so they inherit its device list, its root requirement and its upower caveat.

That inheritance is the point to weigh. A GUI does not broaden hardware support, it only removes the memorising of hex colour codes and the command names.

A small C project, an MIT licence and a slow release history

The code is C, the licence is MIT, and the repository is not archived. The last push was on 2026-05-13, while the most recent tagged releases are 1.6 from 2022-05-28, 1.5 from 2021-09-06 and 1.4 from 2020-12-02. The gap between the last push and the newest release is the thing to keep in mind: the project is still being touched, but version 1.6 is what the installation instructions fetch, so a fresh install gives you a 2022 build unless you clone the repository and run autoreconf.

For a tool whose whole job is talking to a USB device, that is an acceptable situation. The protocol is fixed by the hardware vendor, so there is rarely a reason to change the code, and the source tree with src, data and prototype directories suggests the shape of a self-contained utility rather than a growing framework. The cost of a stale tag is that any fix made after 2022 lives only on the main branch, and the MIT licence means the code can be read, modified and redistributed with attribution, which is what the two GUI front ends have done.

Editorial conclusion

rogauracore is the right choice for an Asus ROG owner on Linux who wants a scriptable way to set the keyboard colour and is comfortable running a root-privileged USB tool, and it is the wrong choice if you need per-key effects, a graphical control panel, or support for a laptop family outside the listed USB IDs. Before installing, check that your keyboard appears under one of the documented IDs, and confirm that the release you install matches the laptop model, since the newest tagged release is 1.6 from 2022 while the last push was on 2026-05-13.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. wroberts/rogauracore on GitHub