diff --git a/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp b/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp
new file mode 100644
index 00000000..9701f336
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp
@@ -0,0 +1,121 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.cpp                                      |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include "AsusAuraRyuoAIOController.h"
+
+AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+{
+	const int szTemp = ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR;
+	wchar_t tmpName[szTemp];
+
+	/*-----------------------------------------------------*\
+	| Add addressable devices                               |
+	|    Manually adding device info for now                |
+	|    TODO: Implement config table accurately            |
+	\*-----------------------------------------------------*/
+	device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+}
+
+AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
+{
+	hid_close(dev);
+}
+
+std::string AsusAuraRyuoAIOController::GetLocation()
+{
+	return("HID: " + location);
+}
+
+void AsusAuraRyuoAIOController::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
+{
+	/*---------------------------------------------------------*\
+	| This interface is not used in this controller however is  |
+	|   required by the abstract class                          |
+	\*---------------------------------------------------------*/
+}
+
+void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
+{
+	//check if update is needed
+	if(!((current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction)))
+	{
+		current_mode        = mode;
+		current_speed       = speed;
+		current_direction   = direction;
+		current_red         = RGBGetRValue(colour);
+		current_green       = RGBGetGValue(colour);
+		current_blue        = RGBGetBValue(colour);
+		SendUpdate();
+	}
+}
+
+void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+	/*---------------------------------------------------------*\
+	| This interface is not used in this controller however is  |
+	|   required by the abstract class                          |
+	\*---------------------------------------------------------*/
+}
+
+void AsusAuraRyuoAIOController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
+{
+	uint8_t buffer[write_packet_size]   = { 0xEC, 0x40, 0x80, 0x00, led_count };
+
+	/*---------------------------------------------------------*\
+	| Set the colour bytes in the packet                        |
+	\*---------------------------------------------------------*/
+	for(uint8_t index = 0; index < led_count; index++)
+	{
+		uint8_t offset      = (index * 3) + RED_BYTE;
+
+		buffer[offset + 0]  = RGBGetRValue(led_colours[index]);
+		buffer[offset + 1]  = RGBGetGValue(led_colours[index]);
+		buffer[offset + 2]  = RGBGetBValue(led_colours[index]);
+	}
+
+	hid_write(dev, buffer, write_packet_size);
+}
+
+void AsusAuraRyuoAIOController::GetStatus()
+{
+	uint8_t buffer[write_packet_size]   = { 0xEC, 0x01, 0x02 };
+
+	hid_write(dev, buffer, write_packet_size);
+	hid_read_timeout(dev, buffer, read_packet_size, ASUSAURARYUOAIOCONTROLLER_TIMEOUT);
+
+	current_red   = buffer[RED_BYTE - 1];
+	current_green = buffer[GREEN_BYTE - 1];
+	current_blue  = buffer[BLUE_BYTE - 1];
+}
+
+void AsusAuraRyuoAIOController::SendUpdate()
+{
+	uint8_t buffer[write_packet_size];
+
+	/*-----------------------------------------------------*\
+	| Zero out buffer                                       |
+	\*-----------------------------------------------------*/
+	memset(buffer, 0x00, write_packet_size);
+
+	buffer[REPORTID_BYTE] = reportid;
+	buffer[COMMAND_BYTE]  = modefx;
+	buffer[ZONE_BYTE]     = 0;
+	buffer[PROGRAM_ID_BYTE]  = program_id;
+	buffer[MODE_BYTE]     = current_mode;
+	buffer[RED_BYTE]      = current_red;
+	buffer[GREEN_BYTE]    = current_green;
+	buffer[BLUE_BYTE]     = current_blue;
+
+	buffer[DIRECTION_BYTE]= current_direction;
+	buffer[SPEED_BYTE]    = current_speed;
+
+	hid_write(dev, buffer, write_packet_size);
+}
+
diff --git a/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h b/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h
new file mode 100644
index 00000000..40696949
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h
@@ -0,0 +1,94 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.h                                        |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
+#pragma once
+
+#define ASUSAURARYUOAIOCONTROLLER_TIMEOUT        250
+#define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR    255
+
+#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN 0
+#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX 255
+
+class AsusAuraRyuoAIOController : public AuraUSBController
+{
+public:
+    enum
+    {
+        MODE_DIRECT       = 0xFF, //Direct Led Control - Independently set LEDs in zone
+        MODE_STATIC       = 0x01, //Static Mode - Set entire zone to a single color.
+        MODE_BREATHING    = 0x02, //Breathing Mode - Fades between fully off and fully on.
+        MODE_FLASHING     = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
+        MODE_SPECTRUM     = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
+        MODE_RAINBOW      = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
+        MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
+    };
+
+    enum PacketMap
+    {
+        REPORTID_BYTE  = 0,
+        COMMAND_BYTE   = 1,
+        ZONE_BYTE      = 2,
+        PROGRAM_ID_BYTE= 3,
+        MODE_BYTE      = 4,
+        RED_BYTE       = 5,
+        GREEN_BYTE     = 6,
+        BLUE_BYTE      = 7,
+        DIRECTION_BYTE = 8,
+        SPEED_BYTE     = 9,
+    };
+
+    enum
+    {
+        SPEED_SLOWEST     = 0x04, // Slowest speed
+        SPEED_SLOW        = 0x03, // Slower speed
+        SPEED_NORMAL      = 0x02, // Normal speed
+        SPEED_FAST        = 0x01, // Fast speed
+        SPEED_FASTEST     = 0x00, // Fastest speed
+    };
+
+    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
+    ~AsusAuraRyuoAIOController();
+
+    std::string             GetLocation();
+
+    void                    SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
+    void                    SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
+
+    void                    SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
+private:
+    static const uint8_t    read_packet_size    = 65;
+    static const uint8_t    write_packet_size   = 65;
+    static const uint8_t    modefx   = 0x3B;
+    static const uint8_t    direct   = 0x40;
+    static const uint8_t    reportid = 0xEC;
+    static const uint8_t    program_id = 0x22;
+
+    std::string             location;
+
+    uint8_t                 zone_index;
+    uint8_t                 current_mode;
+    uint8_t                 current_speed;
+
+    uint8_t                 current_red;
+    uint8_t                 current_green;
+    uint8_t                 current_blue;
+    uint8_t                 current_direction;
+
+    void                    GetStatus();
+    void                    SendUpdate();
+    void                    SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SendDirectApply(unsigned char channel);
+};
diff --git a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
index cb627a8a..8113b3f8 100644
--- a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
+++ b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
@@ -8,6 +8,7 @@
 #include "AsusAuraMousematController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
+#include "AsusAuraRyuoAIOController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
 #include "RGBController_AsusAuraHeadsetStand.h"
@@ -18,6 +19,7 @@
 #include "RGBController_ROGStrixLC_Controller.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
+#include "RGBController_AsusAuraRyuoAIO.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
@@ -80,6 +82,7 @@
 \*-----------------------------------------------------------------*/
 #define AURA_TERMINAL_PID                       0x1889
 #define ROG_STRIX_LC120_PID                     0x879E
+#define AURA_RYUO_AIO_PID                       0x1887
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
@@ -209,6 +212,19 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path);
+        RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
+        rgb_controller->name                          = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -337,6 +353,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAs
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",                     DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                          DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                          0x00FF, 1);
+REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUO_AIO_PID,                        0xFF72, 0x00A1);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);
diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp b/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp
new file mode 100644
index 00000000..7faa14c7
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp
@@ -0,0 +1,223 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.cpp                                  |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_AsusAuraRyuoAIO.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Ryuo AIO 
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBMousemats
+    @category Cooler
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController *controller_ptr)
+{
+    controller                  = controller_ptr;
+    uint8_t speed               = controller->SPEED_NORMAL;
+
+    name                        = "ROG Ryuo AIO";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_COOLER;
+    description                 = "ASUS Liquid Cooler with 120mm and 240mm radiators.";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = controller->MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = controller->MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = controller->MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.brightness_min    = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Breathing.speed_min         = controller->SPEED_SLOWEST;
+    Breathing.speed_max         = controller->SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = speed;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name               = "Flashing";
+    Flashing.value              = controller->MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.colors.resize(Flashing.colors_max);
+    Flashing.brightness_min     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Flashing.brightness_max     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Flashing.brightness         = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Flashing.speed_min          = controller->SPEED_SLOWEST;
+    Flashing.speed_max          = controller->SPEED_FASTEST;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.speed              = speed;
+    modes.push_back(Flashing);
+
+    mode Spectrum;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = controller->MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED;
+    Spectrum.brightness_min     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Spectrum.brightness_max     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.brightness         = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = controller->SPEED_SLOWEST;
+    Spectrum.speed_max          = controller->SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = speed;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = controller->MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.brightness_min      = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Rainbow.brightness_max      = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.brightness          = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.speed_min           = controller->SPEED_SLOWEST;
+    Rainbow.speed_max           = controller->SPEED_FASTEST;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = speed;
+    modes.push_back(Rainbow);
+
+    mode FlashAndDash;
+    FlashAndDash.name           = "Flash and Dash";
+    FlashAndDash.value          = controller->MODE_FLASHANDDASH;
+    FlashAndDash.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    FlashAndDash.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    FlashAndDash.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.brightness     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.speed_min      = controller->SPEED_SLOWEST;
+    FlashAndDash.speed_max      = controller->SPEED_FASTEST;
+    FlashAndDash.color_mode     = MODE_COLORS_NONE;
+    FlashAndDash.speed          = speed;
+    modes.push_back(FlashAndDash);
+
+    SetupZones();
+}
+
+RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
+{
+    delete controller;
+}
+
+void RGBController_AsusAuraRyuoAIO::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Set up zones                                      |
+    \*-------------------------------------------------*/
+    LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
+
+    zones.resize(controller->GetChannelCount());
+
+    LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
+        LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
+                 ((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
+                 zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
+
+        zones[zone_idx].name = name + " Zone ";
+        zones[zone_idx].name.append(std::to_string(zone_idx));
+        zones[zone_idx].type = ZONE_TYPE_LINEAR;
+        zones[zone_idx].leds_min = device_info.num_leds;
+        zones[zone_idx].leds_max = device_info.num_leds;
+        zones[zone_idx].leds_count = device_info.num_leds;
+
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        {
+            led new_led;
+
+            new_led.name = zones[zone_idx].name;
+            new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value = lp_idx;
+
+            leds.push_back(new_led);
+        }
+    }
+
+    LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
+    SetupColors();
+}
+
+void RGBController_AsusAuraRyuoAIO::ResizeZone(int zone, int new_size)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
+{
+    controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
+}
+
+void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(GetLED_Zone(led));
+}
+
+void RGBController_AsusAuraRyuoAIO::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()
+{
+    RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    controller->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour);
+}
+
+int RGBController_AsusAuraRyuoAIO::GetLED_Zone(int led_idx)
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        int zone_start = zones[zone_idx].start_idx;
+        int zone_end = zone_start + zones[zone_idx].leds_count - 1;
+
+        if( zone_start <= led_idx && zone_end >= led_idx)
+        {
+            return(zone_idx);
+        }
+    }
+
+    return -1;
+}
diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h b/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h
new file mode 100644
index 00000000..15141a74
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h
@@ -0,0 +1,38 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.h                                    |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "LogManager.h"
+#include "RGBController.h"
+#include "AsusAuraRyuoAIOController.h"
+#include <vector>
+
+class RGBController_AsusAuraRyuoAIO : public RGBController
+{
+public:
+    RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController* controller_ptr);
+    ~RGBController_AsusAuraRyuoAIO();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void SetCustomMode();
+    void DeviceUpdateMode();
+private:
+    int  GetDeviceMode();
+    int  GetLED_Zone(int led_idx);
+
+    AsusAuraRyuoAIOController* controller;
+};
+
diff --git a/OpenRGB.pro b/OpenRGB.pro
index 8df2671e..17d07be2 100644
--- a/OpenRGB.pro
+++ b/OpenRGB.pro
@@ -259,6 +259,7 @@ HEADERS +=
     Controllers/AsusAuraUSBController/AsusAuraMouseController.h                                 \
     Controllers/AsusAuraUSBController/AsusAuraMousematController.h                              \
     Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h                                    \
+    Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h                               \
     Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h                           \
     Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h                           \
     Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h                              \
@@ -267,6 +268,7 @@ HEADERS +=
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.h                           \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h                             \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h                          \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h                           \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h                       \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h                       \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h                               \
@@ -705,6 +707,7 @@ SOURCES +=
     Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp                             \
     Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp                               \
     Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp                            \
+    Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp                             \
     Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp                         \
     Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp                         \
     Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp                           \
@@ -713,6 +716,7 @@ SOURCES +=
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp                         \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp                           \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp                        \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp                         \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp                     \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp                     \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp                             \