OpenRGB Release Candidate 1.0rc2

Update warning message if I2C doesn't load
Update SMBus documentation for PawnIO
2025-09-14 14:31:57 -05:00 · 2025-09-14 14:31:46 -05:00 · 2025-09-14 14:31:33 -05:00 · 2025-09-14 14:31:23 -05:00 · 2025-09-14 14:31:13 -05:00 · 2025-09-14 14:31:02 -05:00
2875 changed files with 88203 additions and 455943 deletions
@@ -1,6 +1,6 @@
 # These are supported funding model platforms

-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: CalcProgrammer1
 patreon: CalcProgrammer1
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
@@ -0,0 +1,21 @@
+name: Issue Opened
+
+on:
+  issues:
+    types: [opened,reopened]
+
+jobs:
+  issue_greeting:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - name: Greeting
+        run: gh issue comment "$NUMBER" --body "$BODY"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          NUMBER: ${{ github.event.issue.number }}
+          BODY: >
+            This Github repo is a mirror of the main repository on Gitlab.
+            For any new issue please refer to https://gitlab.com/CalcProgrammer1/OpenRGB/-/issues
@@ -0,0 +1,21 @@
+name: PR Opened
+
+on:
+  pull_request:
+    types: [opened,reopened]
+
+jobs:
+  pr_greeting:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Greeting
+        run: gh pr comment "$NUMBER" --body "$BODY"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          NUMBER: ${{ github.event.pull_request.number }}
+          BODY: >
+            This Github repo is a mirror of the main repository on Gitlab.
+            Please fork https://gitlab.com/CalcProgrammer1/OpenRGB/ and raise the appropriate merge request on Gitlab.
@@ -28,6 +28,7 @@ Build/
 .qmake.stash
 .vscode
 .vs
+.idea

 # Generic Files
 .DS_Store
@@ -7,6 +7,22 @@
 #-----------------------------------------------------------------------#
 # OpenRGB GitLab CI Configuration                                       #
 #-----------------------------------------------------------------------#
+.fork_local_runner_rules:
+  rules:
+  - if: $CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" || $CI_PIPELINE_SOURCE == "push"
+    when: on_success
+
+.fork_gitlab_runner_rules:
+  rules:
+  - if: $CI_PROJECT_PATH != "CalcProgrammer1/OpenRGB" && $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+.upstream_rules:
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - !reference [.fork_gitlab_runner_rules, rules]

 .shared_windows_runners:
  tags:
@@ -17,21 +33,18 @@
 stages:
  - build
  - test
+  - deploy
+
+variables:
+  GIT_DEPTH: 0

 before_script:
 - echo "started by ${GITLAB_USER_NAME}"

-#reusable templates
-.ccache_init: &ccache_init
-  before_script:
-    - export QT_SELECT=qt5
-    - export APPIMAGE_EXTRACT_AND_RUN=1
-
 #-----------------------------------------------------------------------#
 # Supported Devices Build Target                                        #
 #-----------------------------------------------------------------------#
 "Supported Devices":
-  <<: *ccache_init
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
  tags:
  - linux
@@ -49,248 +62,226 @@ before_script:
    expire_in: 30 days

  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+    - !reference [.upstream_rules, rules]
+
+#-----------------------------------------------------------------------#
+# OpenRGB Common Appimage Build Steps                                   #
+#-----------------------------------------------------------------------#
+.hidden_appimage_script: &appimage_script_steps
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
+  tags:
+  - linux
+  - ${TGT_ARCH}
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh ${TGT_QT}
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_${TGT_NAME}_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-${TGT_PATH}.AppImage
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
+
+  rules:
+    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------------------#
 # Linux (AppImage) i386 Build Target                                    #
 #-----------------------------------------------------------------------#
 "Linux i386 AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
-  tags:
-  - linux
-  - i386
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  variables:
+    TGT_ARCH: "i386"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_i386_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB-i386.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (AppImage) Qt6 i386 Build Target                                #
+#-----------------------------------------------------------------------#
+"Linux i386 AppImage Qt6":
+  variables:
+    TGT_ARCH: "i386"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps

 #-----------------------------------------------------------------------#
 # Linux (AppImage) amd64 Build Target                                   #
 #-----------------------------------------------------------------------#
 "Linux amd64 AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  variables:
+    TGT_ARCH: "amd64"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}"
+    TGT_PATH: "x86_64"
+  <<: *appimage_script_steps
+  rules:
+  - !reference [.fork_local_runner_rules, rules]

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_amd64_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB-x86_64.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
+"Linux amd64 AppImage (gitlab.com runner)":
+  extends: "Linux amd64 AppImage"
+  rules:
+  - !reference [.fork_gitlab_runner_rules, rules]
+  tags:
+  - "saas-linux-small-amd64"
+
+#-----------------------------------------------------------------------#
+# Linux (AppImage) Qt6 amd64 Build Target                               #
+#-----------------------------------------------------------------------#
+"Linux amd64 AppImage Qt6":
+  variables:
+    TGT_ARCH: "amd64"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_PATH: "x86_64"
+  <<: *appimage_script_steps

 #-----------------------------------------------------------------------#
 # Linux (AppImage) armhf Build Target                                   #
 #-----------------------------------------------------------------------#
 "Linux armhf AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
-  tags:
-  - linux
-  - armhf
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  variables:
+    TGT_ARCH: "armhf"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_armhf_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB-armhf.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (AppImage) Qt6 armhf Build Target                               #
+#-----------------------------------------------------------------------#
+"Linux armhf AppImage Qt6":
+  variables:
+    TGT_ARCH: "armhf"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps

 #-----------------------------------------------------------------------#
 # Linux (AppImage) arm64 Build Target                                   #
 #-----------------------------------------------------------------------#
 "Linux arm64 AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
+  variables:
+    TGT_ARCH: "arm64"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps
+
+#-----------------------------------------------------------------------#
+# Linux (AppImage) Qt6 arm64 Build Target                               #
+#-----------------------------------------------------------------------#
+"Linux arm64 AppImage Qt6":
+  variables:
+    TGT_ARCH: "arm64"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_PATH: "${TGT_ARCH}"
+  <<: *appimage_script_steps
+
+#-----------------------------------------------------------------------#
+# OpenRGB Common Debian Build Steps                                     #
+#-----------------------------------------------------------------------#
+.hidden_deb_script: &debian_script_steps
+  stage: build
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:$TGT_DEB-$TGT_ARCH
  tags:
  - linux
-  - arm64
-  stage: build
+  - $TGT_ARCH
  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_arm64_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_deb_${CI_COMMIT_SHORT_SHA}"
    paths:
-    - OpenRGB-arm64.AppImage
-    - 60-openrgb.rules
-    - README.md
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
    expire_in: 30 days
-
  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bookworm i386 Build Target                        #
 #-----------------------------------------------------------------------#
 "Linux i386 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
-  tags:
-  - linux
-  - i386
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  variables:
+    TGT_ARCH: "i386"
+    TGT_DEB: "bookworm"
+  <<: *debian_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_i386_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Trixie i386 Build Target                          #
+#-----------------------------------------------------------------------#
+"Linux i386 .deb (Debian Trixie)":
+  variables:
+    TGT_ARCH: "i386"
+    TGT_DEB: "trixie"
+  <<: *debian_script_steps

 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bookworm amd64 Build Target                       #
 #-----------------------------------------------------------------------#
 "Linux amd64 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  variables:
+    TGT_ARCH: "amd64"
+    TGT_DEB: "bookworm"
+  <<: *debian_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_amd64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Trixie amd64 Build Target                         #
+#-----------------------------------------------------------------------#
+"Linux amd64 .deb (Debian Trixie)":
+  variables:
+    TGT_ARCH: "amd64"
+    TGT_DEB: "trixie"
+  <<: *debian_script_steps

 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bookworm armhf Build Target                       #
 #-----------------------------------------------------------------------#
 "Linux armhf .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
-  tags:
-  - linux
-  - armhf
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  variables:
+    TGT_ARCH: "armhf"
+    TGT_DEB: "bookworm"
+  <<: *debian_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_armhf_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Trixie armhf Build Target                         #
+#-----------------------------------------------------------------------#
+"Linux armhf .deb (Debian Trixie)":
+  variables:
+    TGT_ARCH: "armhf"
+    TGT_DEB: "trixie"
+  <<: *debian_script_steps

 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bookworm arm64 Build Target                       #
 #-----------------------------------------------------------------------#
 "Linux arm64 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
-  tags:
-  - linux
-  - arm64
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  variables:
+    TGT_ARCH: "arm64"
+    TGT_DEB: "bookworm"
+  <<: *debian_script_steps

-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_arm64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Trixie arm64 Build Target                         #
+#-----------------------------------------------------------------------#
+"Linux arm64 .deb (Debian Trixie)":
+  variables:
+    TGT_ARCH: "arm64"
+    TGT_DEB: "trixie"
+  <<: *debian_script_steps

 #-----------------------------------------------------------------------#
 # Linux (.rpm, F40) 64-bit Build Target                                 #
@@ -299,15 +290,12 @@ before_script:
  image: fedora:40
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
  - rpmdev-setuptree
  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
-  - ls /root/
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
-  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
-  - cd /root/rpmbuild/SOURCES
-  - tar -cf OpenRGB.tar.gz OpenRGB/
-  - cd ..
+  - cp -rp . /root/rpmbuild/SOURCES/OpenRGB
+  - cd /root/rpmbuild
  - dnf builddep SPECS/OpenRGB.spec -y
  - rpmbuild -ba SPECS/OpenRGB.spec
  - cd RPMS/x86_64/
@@ -321,11 +309,7 @@ before_script:
    expire_in: 30 days

  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------------------#
 # Debian i386 Bookworm test                                             #
@@ -414,61 +398,8 @@ before_script:
  - .shared_windows_runners
  stage: build
  script:
-  - $esc = "$([char]27)"
-  - $count = 0
-  - function _unix_tmsec_ { [int64](([datetime]::UtcNow)-(get-date "1/1/1970")).TotalSeconds }
-  - function _fold_start_ { param( [string]$TEXT_TAG ) $t=_unix_tmsec_; $global:count += 1; Write-Host -NoNewLine "`r`n`r`nsection_start:${t}:sect_${count}`r${esc}[0K${esc}[33m${TEXT_TAG}${esc}[39m`r`n"; }
-  - function _fold_final_ {                            $t=_unix_tmsec_;                     Write-Host -NoNewLine   "`r`n`r`nsection_end:${t}:sect_${count}`r${esc}[0K`r`n"           ; }
-
-
-  - _fold_start_ 'configuring the msvc environment variables'
-  - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
-  - '& cmd.exe /C "vcvarsall.bat x86 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }'
-  - Pop-Location
-  - _fold_final_
-
-  - _fold_start_ 'downloading precompiled versions of qtbase, qttools (for windeployqt) and jom (for a more parallel nmake)'
-  - mkdir _qt
-  - mkdir _qt_download
-  - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
-  - _fold_final_
-
-  - _fold_start_ 'extracting the downloaded qt binaries'
-  - 7z x qt-base.7z  '-o../_qt' -y
-  - 7z x qt-tools.7z '-o../_qt' -y
-  - 7z x qt-jom.zip  '-o../_qt' -y
-  - _fold_final_
-
-  - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
-  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019\mkspecs\qconfig.pri'
-  - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
-  - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
-  - Pop-Location
-  - _fold_final_
-
-  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
-  - mkdir _build; cd _build
-  - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
-  - _fold_final_
-
-  - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
-  - ..\_qt\jom
-  - _fold_final_
-
-  - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
-  - ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
-  - _fold_final_
-
-  - _fold_start_ 'Moving results for upload'
-  - mv release ../'OpenRGB Windows 32-bit'
-  - _fold_final_
-#  cache:
-#    key: same-key
-#    paths:
-#    - C:\vcpkg\installed\
+  - Set-MpPreference -DisableRealtimeMonitoring $true
+  - scripts\build-windows.bat 5.15.0 2019 32
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -478,75 +409,39 @@ before_script:
    expire_in: 30 days

  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
+    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------------------#
-# Windows (64-bit) Build Target                                         #
+# Windows (32-bit) Qt6 Build Target                                     #
 #-----------------------------------------------------------------------#
-"Windows 64":
+"Windows 32 Qt6":
  extends:
  - .shared_windows_runners
  stage: build
  script:
-  - $esc = "$([char]27)"
-  - $count = 0
-  - function _unix_tmsec_ { [int64](([datetime]::UtcNow)-(get-date "1/1/1970")).TotalSeconds }
-  - function _fold_start_ { param( [string]$TEXT_TAG ) $t=_unix_tmsec_; $global:count += 1; Write-Host -NoNewLine "`r`n`r`nsection_start:${t}:sect_${count}`r${esc}[0K${esc}[33m${TEXT_TAG}${esc}[39m`r`n"; }
-  - function _fold_final_ {                            $t=_unix_tmsec_;                     Write-Host -NoNewLine   "`r`n`r`nsection_end:${t}:sect_${count}`r${esc}[0K`r`n"           ; }
+  - Set-MpPreference -DisableRealtimeMonitoring $true
+  - scripts\build-windows.bat 6.8.3 2022 32
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_32_Qt6_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - 'OpenRGB Windows 32-bit'
+    exclude:
+    - 'OpenRGB Windows 32-bit\*.qm'
+    expire_in: 30 days

+  rules:
+    - !reference [.upstream_rules, rules]

-  - _fold_start_ 'configuring the msvc environment variables'
-  - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
-  - '& cmd.exe /C "vcvarsall.bat x64 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }'
-  - Pop-Location
-  - _fold_final_
-
-  - _fold_start_ 'downloading precompiled versions of qtbase, qttools (for windeployqt) and jom (for a more parallel nmake)'
-  - mkdir _qt
-  - mkdir _qt_download
-  - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
-  - _fold_final_
-
-  - _fold_start_ 'extracting the downloaded qt binaries'
-  - 7z x qt-base.7z  '-o../_qt' -y
-  - 7z x qt-tools.7z '-o../_qt' -y
-  - 7z x qt-jom.zip  '-o../_qt' -y
-  - _fold_final_
-
-  - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
-  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019_64\mkspecs\qconfig.pri'
-  - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
-  - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
-  - Pop-Location
-  - _fold_final_
-
-  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
-  - mkdir _build; cd _build
-  - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
-  - _fold_final_
-
-  - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
-  - ..\_qt\jom
-  - _fold_final_
-
-  - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
-  - ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
-  - _fold_final_
-
-  - _fold_start_ 'Moving results for upload'
-  - mv release ../'OpenRGB Windows 64-bit'
-  - _fold_final_
-#  cache:
-#    key: same-key
-#    paths:
-#    - C:\vcpkg\installed\
+#-----------------------------------------------------------------------#
+# Windows (64-bit) Build Target                                         #
+#-----------------------------------------------------------------------#
+"Windows 64 Base":
+  extends:
+  - .shared_windows_runners
+  stage: build
+  script:
+  - Set-MpPreference -DisableRealtimeMonitoring $true
+  - scripts\build-windows.bat 5.15.0 2019 64
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -555,6 +450,68 @@ before_script:
    - 'OpenRGB Windows 64-bit\*.qm'
    expire_in: 30 days

+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
+      when: never
+
+
+"Windows 64":
+  extends: "Windows 64 Base"
+  rules:
+  - !reference [.fork_local_runner_rules, rules]
+
+"Windows 64 (gitlab.com runner)":
+  extends: "Windows 64 Base"
+  before_script:
+    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
+    - cd OpenRGB-Qt-Packages
+    - .\install-chocolatey.bat
+    - cd ..
+  rules:
+  - !reference [.fork_gitlab_runner_rules, rules]
+  tags:
+  - "saas-windows-medium-amd64"
+
+#-----------------------------------------------------------------------#
+# Windows (64-bit) Qt6 Build Target                                     #
+#-----------------------------------------------------------------------#
+"Windows 64 Qt6 Base":
+  extends:
+  - .shared_windows_runners
+  stage: build
+  script:
+  - Set-MpPreference -DisableRealtimeMonitoring $true
+  - scripts\build-windows.bat 6.8.3 2022 64
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - 'OpenRGB Windows 64-bit'
+    exclude:
+    - 'OpenRGB Windows 64-bit\*.qm'
+    expire_in: 30 days
+
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
+      when: never
+
+
+"Windows 64 Qt6":
+  extends: "Windows 64 Qt6 Base"
+  rules:
+  - !reference [.fork_local_runner_rules, rules]
+
+"Windows 64 Qt6 (gitlab.com runner)":
+  extends: "Windows 64 Qt6 Base"
+  before_script:
+    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
+    - cd OpenRGB-Qt-Packages
+    - .\install-chocolatey.bat
+    - cd ..
+  rules:
+  - !reference [.fork_gitlab_runner_rules, rules]
+  tags:
+  - "saas-windows-medium-amd64"
+
 #-----------------------------------------------------------------------#
 # MacOS Build Target                                                    #
 #-----------------------------------------------------------------------#
@@ -607,3 +564,30 @@ before_script:
  - if: $CI_PIPELINE_SOURCE == "push"
    when: manual
    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Windows (64-bit) MSI Target                                           #
+#-----------------------------------------------------------------------#
+"Windows 64 MSI":
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
+  stage: deploy
+  tags:
+  - linux
+  - i386
+  script:
+  -  ls -la
+  -  ls -la "OpenRGB Windows 64-bit/"
+  -  ./scripts/build-msi.sh
+  dependencies:
+  - "Windows 64"
+  needs:
+  - "Windows 64"
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_64_msi_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB_Windows_64.msi
+    expire_in: 30 days
+
+  rules:
+    - !reference [.upstream_rules, rules]
@@ -23,9 +23,9 @@ Please add a link to the manufacturer's product page beneath this line
 ~"DeviceType::IDK" <!-- I Don't know -->
 ~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
 ~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
-~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
+~"DeviceType::GPU::NVidia" <!-- The device is a Nvidia GPU -->
 ~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
-~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->
+~"DeviceType::WMI"  <!-- The device is controlled through Windows Management Instrumentation -->

 <!-- Please delete any lines that are not relevant -->

@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If file doesn't exist, disable is successful      |
+        \*-------------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*---------------------------------------------*\
-        | Otherwise, delete the file                    |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, delete the file                        |
+        \*-------------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,39 +63,38 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*---------------------------------------------*\
-        | Error out if the file could not be opened     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Error out if the file could not be opened         |
+        \*-------------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, write the file                         |
+        \*-------------------------------------------------*/
        else
        {
-            //autostart_file_stream << desktop_file;
            autostart_file_stream.close();
            success = !autostart_file_stream.fail();

            if (!success)
            {
-                LOG_ERROR("An error occurred writing the auto start file.");
+                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -103,9 +102,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -118,9 +117,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-------------------------------------------------*\
-    | Create the OpenRGB executable path                |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Create the OpenRGB executable path                    |
+    \*-----------------------------------------------------*/
    char exepath[ PATH_MAX ];

    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
@@ -134,16 +133,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-------------------------------------------------*\
-    | Get home and config paths                         |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get home and config paths                             |
+    \*-----------------------------------------------------*/
    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    const char *home = getenv("HOME");

-    /*-------------------------------------------------*\
-    | Determine where the autostart .desktop files are  |
-    | kept                                              |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Determine where the autostart .desktop files are      |
+    | kept                                                  |
+    \*-----------------------------------------------------*/
    if(xdg_config_home != NULL)
    {
        autostart_dir = xdg_config_home;
@@ -155,9 +154,9 @@ void AutoStart::InitAutoStart(std::string name)
        autostart_dir = autostart_dir + "/.config/autostart/";
    }

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If file doesn't exist, disable is successful      |
+        \*-------------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*---------------------------------------------*\
-        | Otherwise, delete the file                    |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, delete the file                        |
+        \*-------------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,25 +63,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        std::string     desktop_file                = GenerateDesktopFile(autostart_info);
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*---------------------------------------------*\
-        | Error out if the file could not be opened     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Error out if the file could not be opened         |
+        \*-------------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, write the file                         |
+        \*-------------------------------------------------*/
        else
        {
            autostart_file_stream << desktop_file;
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

            if (!success)
            {
-                LOG_ERROR("An error occurred writing the auto start file.");
+                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -104,9 +104,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -119,9 +119,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-------------------------------------------------*\
-    | Create the OpenRGB executable path                |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Create the OpenRGB executable path                    |
+    \*-----------------------------------------------------*/
    char exepath[ PATH_MAX ];

    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
@@ -129,17 +129,17 @@ std::string AutoStart::GetExePath()
    return(std::string(exepath, (count > 0) ? count : 0));
 }

-/*-----------------------------------------------------*\
-| Linux AutoStart Implementation                        |
-| Private Methods                                       |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Linux AutoStart Implementation                            |
+| Private Methods                                           |
+\*---------------------------------------------------------*/

 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
-    /*-------------------------------------------------*\
-    | Generate a .desktop file from the AutoStart       |
-    | parameters                                        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Generate a .desktop file from the AutoStart           |
+    | parameters                                            |
+    \*-----------------------------------------------------*/
    std::stringstream fileContents;

    fileContents << "[Desktop Entry]"                               << std::endl;
@@ -151,9 +151,9 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
    fileContents << "Terminal=false"                                << std::endl;
    fileContents << "Type=Application"                              << std::endl;

-    /*-------------------------------------------------*\
-    | Add the executable path and arguments             |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Add the executable path and arguments                 |
+    \*-----------------------------------------------------*/
    fileContents << "Exec="              << autostart_info.path;

    if (autostart_info.args != "")
@@ -172,16 +172,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-------------------------------------------------*\
-    | Get home and config paths                         |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get home and config paths                             |
+    \*-----------------------------------------------------*/
    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    const char *home = getenv("HOME");

-    /*-------------------------------------------------*\
-    | Determine where the autostart .desktop files are  |
-    | kept                                              |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Determine where the autostart .desktop files are      |
+    | kept                                                  |
+    \*-----------------------------------------------------*/
    if(xdg_config_home != NULL)
    {
        autostart_dir = xdg_config_home;
@@ -193,9 +193,9 @@ void AutoStart::InitAutoStart(std::string name)
        autostart_dir = autostart_dir + "/.config/autostart/";
    }

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If file doesn't exist, disable is successful      |
+        \*-------------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*---------------------------------------------*\
-        | Otherwise, delete the file                    |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, delete the file                        |
+        \*-------------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,25 +63,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        std::string     desktop_file                = GenerateLaunchAgentFile(autostart_info);
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*---------------------------------------------*\
-        | Error out if the file could not be opened     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Error out if the file could not be opened         |
+        \*-------------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, write the file                         |
+        \*-------------------------------------------------*/
        else
        {
            autostart_file_stream << desktop_file;
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

            if (!success)
            {
-                LOG_ERROR("An error occurred writing the auto start file.");
+                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -104,9 +104,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -119,9 +119,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-------------------------------------------------*\
-    | Create the OpenRGB executable path                |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Create the OpenRGB executable path                    |
+    \*-----------------------------------------------------*/
    char     exepath[ PATH_MAX ];
    uint32_t exesize = PATH_MAX;

@@ -132,17 +132,17 @@ std::string AutoStart::GetExePath()
    return("");
 }

-/*-----------------------------------------------------*\
-| MacOS AutoStart Implementation                        |
-| Private Methods                                       |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| MacOS AutoStart Implementation                            |
+| Private Methods                                           |
+\*---------------------------------------------------------*/

 std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 {
-    /*-------------------------------------------------*\
-    | Generate a .plist file from the AutoStart         |
-    | parameters                                        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Generate a .plist file from the AutoStart             |
+    | parameters                                            |
+    \*-----------------------------------------------------*/
    std::stringstream fileContents;

    fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
@@ -180,16 +180,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-------------------------------------------------*\
-    | Determine where the autostart .desktop files are  |
-    | kept                                              |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Determine where the autostart .desktop files are      |
+    | kept                                                  |
+    \*-----------------------------------------------------*/
    autostart_dir = getenv("HOME");
    autostart_dir = autostart_dir + "/Library/LaunchAgents/";

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -25,34 +25,34 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool success                                    = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If file doesn't exist, disable is successful      |
+        \*-------------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*---------------------------------------------*\
-        | Otherwise, delete the file                    |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Otherwise, delete the file                        |
+        \*-------------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);

            if(!success)
            {
-                LOG_ERROR("An error occurred removing the auto start file.");
+                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return(success);
@@ -62,9 +62,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool success                                    = false;

-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        bool            weInitialised               = false;
@@ -79,9 +79,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);

-        /*---------------------------------------------*\
-        | If not initialized, initialize                |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If not initialized, initialize                    |
+        \*-------------------------------------------------*/
        if(result == CO_E_NOTINITIALIZED)
        {
            weInitialised                           = true;
@@ -89,10 +89,10 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
            result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
        }

-        /*---------------------------------------------*\
-        | If successfully initialized, save a shortcut  |
-        | from the AutoStart parameters                 |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | If successfully initialized, save a shortcut      |
+        | from the AutoStart parameters                     |
+        \*-------------------------------------------------*/
        if(SUCCEEDED(result))
        {
            shellLink->SetPath(exepathw.c_str());
@@ -114,9 +114,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
            shellLink->Release();
        }

-        /*---------------------------------------------*\
-        | Uninitialize when done                        |
-        \*---------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Uninitialize when done                            |
+        \*-------------------------------------------------*/
        if(weInitialised)
        {
            CoUninitialize();
@@ -124,7 +124,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
    }
    else
    {
-        LOG_ERROR("Could not establish correct autostart file path.");
+        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
    }

    return success;
@@ -132,9 +132,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Check if the filename is valid                        |
+    \*-----------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -147,9 +147,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-------------------------------------------------*\
-    | Create the OpenRGB executable path                |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Create the OpenRGB executable path                    |
+    \*-----------------------------------------------------*/
    char exepath[MAX_PATH] = "";

    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
@@ -157,10 +157,10 @@ std::string AutoStart::GetExePath()
    return(std::string(exepath, (count > 0) ? count : 0));
 }

-/*-----------------------------------------------------*\
-| Windows AutoStart Implementation                      |
-| Private Methods                                       |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Windows AutoStart Implementation                          |
+| Private Methods                                           |
+\*---------------------------------------------------------*/

 void AutoStart::InitAutoStart(std::string name)
 {
@@ -168,9 +168,9 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-------------------------------------------------*\
-    | Get startup applications path                     |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get startup applications path                         |
+    \*-----------------------------------------------------*/
    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);

    if(SUCCEEDED(result))
@@ -185,10 +185,10 @@ void AutoStart::InitAutoStart(std::string name)
    }
 }

-/*-----------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String       |
-| (from wmi.cpp)                                        |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String           |
+| (from wmi.cpp)                                            |
+\*---------------------------------------------------------*/
 std::wstring AutoStart::utf8_decode(const std::string& str)
 {
    if(str.empty())
@@ -67,3 +67,8 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 | This is a comment                |
 \*_-------------------------------*/
 ```
+
+## Translating
+
+Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
+In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
@@ -15,7 +15,6 @@
 \*-----------------------------------------------------*/
 #include <hidapi.h>
 #include "Detector.h"
-#include "RGBController.h"

 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
@@ -34,9 +33,8 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id);
+        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id, name);
        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
-        rgb_controller->name                        = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -48,16 +46,16 @@ void DetectBloodyB820R(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }

-REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -20,10 +20,11 @@
 | the second packet.                                                                    |
 \*-------------------------------------------------------------------------------------*/

-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev                 = dev_handle;
    location            = path;
+    name                = dev_name;

    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
 }
@@ -52,6 +53,11 @@ std::string BloodyB820RController::GetLocation()
    return("HID: " + location);
 }

+std::string BloodyB820RController::GetName()
+{
+    return(name);
+}
+
 void  BloodyB820RController::SendControlPacket(uint8_t data)
 {
    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]    = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
@@ -39,15 +39,17 @@ enum
 class BloodyB820RController
 {
 public:
-    BloodyB820RController(hid_device* dev_handle, const char* path);
+    BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~BloodyB820RController();

    std::string     GetSerial();
    std::string     GetLocation();
+    std::string     GetName();

    void            SetLEDDirect(std::vector<RGBColor> colors);
    void            SendControlPacket(uint8_t data);
 private:
    std::string     location;
+    std::string     name;
    hid_device*     dev;
 };
@@ -154,7 +154,7 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 {
    controller                  = controller_ptr;

-    name                        = "Bloody B820R";
+    name                        = controller->GetName();
    vendor                      = "A4Tech";
    type                        = DEVICE_TYPE_KEYBOARD;
    description                 = "A4Tech Bloody Keyboard";
@@ -12,11 +12,12 @@
 #include "BloodyMouseController.h"
 #include "StringUtils.h"

-BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
+BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name)
 {
    dev                 = dev_handle;
    location            = path;
    pid                 = product_id;
+    name                = dev_name;

    InitDevice();
 }
@@ -49,6 +50,11 @@ std::string BloodyMouseController::GetLocation()
    return("HID: " + location);
 }

+std::string BloodyMouseController::GetName()
+{
+    return(name);
+}
+
 void BloodyMouseController::InitDevice()
 {
    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
@@ -21,6 +21,7 @@
 #define BLOODY_W60_PRO_PID                          0x37EA
 #define BLOODY_W70_MAX_PID                          0x79EF
 #define BLOODY_W90_MAX_PID                          0x3666
+#define BLOODY_W90_PRO_PID                          0x39B6

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
@@ -49,18 +50,20 @@ enum
 class BloodyMouseController
 {
 public:
-    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
+    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name);
    ~BloodyMouseController();

    uint16_t        GetPid();
    std::string     GetSerial();
    std::string     GetLocation();
+    std::string     GetName();

    void            SetLedsDirect(std::vector<RGBColor> colors);

 private:
    uint16_t        pid;
    std::string     location;
+    std::string     name;
    hid_device*     dev;

    void            InitDevice();
@@ -71,6 +71,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
            type                = DEVICE_TYPE_MOUSE;
    }

+    name                        = controller->GetName();
    vendor                      = "Bloody";
    description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
    serial                      = controller->GetSerial();
@@ -111,6 +112,7 @@ void RGBController_BloodyMouse::SetupZones()
            break;
        case BLOODY_W70_MAX_PID:
        case BLOODY_W90_MAX_PID:
+        case BLOODY_W90_PRO_PID:
            layout = w90_max;
            break;
        case BLOODY_MP_50RS_PID:
@@ -0,0 +1,195 @@
+/*---------------------------------------------------------*\
+| AMBXController.cpp                                        |
+|                                                           |
+|   Driver for Philips amBX Gaming lights                   |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "AMBXController.h"
+#include "LogManager.h"
+#include "StringUtils.h"
+#include <cstring>
+#include <thread>
+#include <chrono>
+
+AMBXController::AMBXController(const char* path)
+{
+    initialized      = false;
+    usb_context      = nullptr;
+    dev_handle       = nullptr;
+
+    location = "USB: ";
+    location += path;
+
+    // Initialize libusb in this instance
+    if(libusb_init(&usb_context) < 0)
+    {
+        return;
+    }
+
+    // Get the device list
+    libusb_device** device_list;
+    ssize_t device_count = libusb_get_device_list(usb_context, &device_list);
+
+    if(device_count < 0)
+    {
+        return;
+    }
+
+    for(ssize_t i = 0; i < device_count; i++)
+    {
+        libusb_device* device = device_list[i];
+        struct libusb_device_descriptor desc;
+
+        if(libusb_get_device_descriptor(device, &desc) != LIBUSB_SUCCESS)
+        {
+            continue;
+        }
+
+        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
+        {
+            uint8_t bus = libusb_get_bus_number(device);
+            uint8_t address = libusb_get_device_address(device);
+
+            char current_path[32];
+            snprintf(current_path, sizeof(current_path), "%d-%d", bus, address);
+
+            if(strcmp(path, current_path) == 0)
+            {
+                // Try to open this device
+                if(libusb_open(device, &dev_handle) != LIBUSB_SUCCESS)
+                {
+                    continue;
+                }
+
+                // Try to detach the kernel driver if attached
+                if(libusb_kernel_driver_active(dev_handle, 0))
+                {
+                    libusb_detach_kernel_driver(dev_handle, 0);
+                }
+
+                // Set auto-detach for Windows compatibility
+                libusb_set_auto_detach_kernel_driver(dev_handle, 1);
+
+                // Claim the interface
+                if(libusb_claim_interface(dev_handle, 0) != LIBUSB_SUCCESS)
+                {
+                    libusb_close(dev_handle);
+                    dev_handle = nullptr;
+                    continue;
+                }
+
+                // Get string descriptor for serial number if available
+                if(desc.iSerialNumber != 0)
+                {
+                    unsigned char serial_str[256];
+                    int serial_result = libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
+                                                                         serial_str, sizeof(serial_str));
+                    if(serial_result > 0)
+                    {
+                        serial = std::string(reinterpret_cast<char*>(serial_str), serial_result);
+                    }
+                }
+
+                // Successfully opened and claimed the device
+                initialized = true;
+                break;
+            }
+        }
+    }
+
+    libusb_free_device_list(device_list, 1);
+}
+
+AMBXController::~AMBXController()
+{
+    if(initialized)
+    {
+        // Turn off all lights before closing
+        unsigned int led_ids[5] =
+        {
+            AMBX_LIGHT_LEFT,
+            AMBX_LIGHT_RIGHT,
+            AMBX_LIGHT_WALL_LEFT,
+            AMBX_LIGHT_WALL_CENTER,
+            AMBX_LIGHT_WALL_RIGHT
+        };
+
+        RGBColor colors[5] = { 0, 0, 0, 0, 0 };
+        SetLEDColors(led_ids, colors, 5);
+    }
+
+    if(dev_handle != nullptr)
+    {
+        // Release the interface
+        libusb_release_interface(dev_handle, 0);
+
+        // Close the device
+        libusb_close(dev_handle);
+        dev_handle = nullptr;
+    }
+
+    if(usb_context != nullptr)
+    {
+        libusb_exit(usb_context);
+        usb_context = nullptr;
+    }
+}
+
+std::string AMBXController::GetDeviceLocation()
+{
+    return location;
+}
+
+std::string AMBXController::GetSerialString()
+{
+    return serial;
+}
+
+bool AMBXController::IsInitialized()
+{
+    return initialized;
+}
+
+void AMBXController::SendPacket(unsigned char* packet, unsigned int size)
+{
+    if(!initialized || dev_handle == nullptr)
+    {
+        return;
+    }
+
+    int actual_length = 0;
+    libusb_interrupt_transfer(dev_handle, AMBX_ENDPOINT_OUT, packet, size, &actual_length, 100);
+}
+
+void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
+{
+    if(!initialized)
+    {
+        return;
+    }
+
+    unsigned char color_buf[6] =
+    {
+        AMBX_PACKET_HEADER,
+        static_cast<unsigned char>(led),
+        AMBX_SET_COLOR,
+        (unsigned char)RGBGetRValue(color),
+        (unsigned char)RGBGetGValue(color),
+        (unsigned char)RGBGetBValue(color)
+    };
+
+    SendPacket(color_buf, 6);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
+{
+    for(unsigned int i = 0; i < count; i++)
+    {
+        SetLEDColor(leds[i], colors[i]);
+    }
+}
@@ -0,0 +1,57 @@
+/*---------------------------------------------------------*\
+| AMBXController.h                                          |
+|                                                           |
+|   Driver for Philips amBX Gaming lights                   |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include <string>
+
+#ifdef _WIN32
+#include "dependencies/libusb-1.0.27/include/libusb.h"
+#else
+#include <libusb.h>
+#endif
+
+#define AMBX_VID                            0x0471
+#define AMBX_PID                            0x083F
+#define AMBX_ENDPOINT_OUT                   0x02
+#define AMBX_PACKET_HEADER                  0xA1
+#define AMBX_SET_COLOR                      0x03
+
+enum
+{
+    AMBX_LIGHT_LEFT         = 0x0B,
+    AMBX_LIGHT_RIGHT        = 0x1B,
+    AMBX_LIGHT_WALL_LEFT    = 0x2B,
+    AMBX_LIGHT_WALL_CENTER  = 0x3B,
+    AMBX_LIGHT_WALL_RIGHT   = 0x4B
+};
+
+class AMBXController
+{
+public:
+    AMBXController(const char* path);
+    ~AMBXController();
+
+    std::string     GetDeviceLocation();
+    std::string     GetSerialString();
+    
+    bool            IsInitialized();
+    void            SetLEDColor(unsigned int led, RGBColor color);
+    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
+
+private:
+    libusb_context*          usb_context;
+    libusb_device_handle*    dev_handle;
+    std::string              location;
+    std::string              serial;
+    bool                     initialized;
+    
+    void                    SendPacket(unsigned char* packet, unsigned int size);
+};
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------*\
+| AMBXControllerDetect.cpp                                  |
+|                                                           |
+|   Detector for Philips amBX Gaming lights                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "AMBXController.h"
+#include "RGBController.h"
+#include "RGBController_AMBX.h"
+
+#ifdef _WIN32
+#include "dependencies/libusb-1.0.27/include/libusb.h"
+#else
+#include <libusb.h>
+#endif
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAMBXControllers                                                                  *
+*                                                                                          *
+*       Detect Philips amBX Gaming devices                                                 *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAMBXControllers()
+{
+    libusb_context* ctx = NULL;
+
+    if(libusb_init(&ctx) < 0)
+    {
+        return;
+    }
+
+    libusb_device** devs;
+    ssize_t num_devs = libusb_get_device_list(ctx, &devs);
+
+    if(num_devs <= 0)
+    {
+        libusb_exit(ctx);
+        return;
+    }
+
+    for(ssize_t i = 0; i < num_devs; i++)
+    {
+        libusb_device* dev = devs[i];
+        libusb_device_descriptor desc;
+        
+        if(libusb_get_device_descriptor(dev, &desc) != 0)
+        {
+            continue;
+        }
+
+        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
+        {
+            uint8_t bus = libusb_get_bus_number(dev);
+            uint8_t address = libusb_get_device_address(dev);
+            char device_path[32];
+            snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
+
+            // Use the AMBXController to handle opening and initializing
+            AMBXController* controller = new AMBXController(device_path);
+
+            if(controller->IsInitialized())
+            {
+                RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+            }
+            else
+            {
+                delete controller;
+            }
+        }
+    }
+
+    libusb_free_device_list(devs, 1);
+    libusb_exit(ctx);
+}
+
+REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);
@@ -0,0 +1,179 @@
+/*---------------------------------------------------------*\
+| RGBController_AMBX.cpp                                    |
+|                                                           |
+|   RGB Controller for Philips amBX Gaming lights           |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AMBX.h"
+
+/**------------------------------------------------------------------*\
+    @name Philips amBX
+    @category Accessory
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAMBXControllers
+    @comment The Philips amBX Gaming lights system includes left and right
+    lights and a wall-washer bar with three zones.
+\*-------------------------------------------------------------------*/
+
+RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
+{
+    controller = controller_ptr;
+
+    name        = "Philips amBX";
+    vendor      = "Philips";
+    type        = DEVICE_TYPE_ACCESSORY;
+    description = "Philips amBX Gaming Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_AMBX::~RGBController_AMBX()
+{
+    delete controller;
+}
+
+void RGBController_AMBX::SetupZones()
+{
+    // Set up zones
+    zone side_lights_zone;
+    side_lights_zone.name       = "Side Lights";
+    side_lights_zone.type       = ZONE_TYPE_LINEAR;
+    side_lights_zone.leds_min   = 2;
+    side_lights_zone.leds_max   = 2;
+    side_lights_zone.leds_count = 2;
+    side_lights_zone.matrix_map = NULL;
+    zones.push_back(side_lights_zone);
+
+    zone wallwasher_zone;
+    wallwasher_zone.name       = "Wallwasher";
+    wallwasher_zone.type       = ZONE_TYPE_LINEAR;
+    wallwasher_zone.leds_min   = 3;
+    wallwasher_zone.leds_max   = 3;
+    wallwasher_zone.leds_count = 3;
+    wallwasher_zone.matrix_map = NULL;
+    zones.push_back(wallwasher_zone);
+
+    // Set up LEDs
+    led left_light;
+    left_light.name  = "Left";
+    left_light.value = AMBX_LIGHT_LEFT;
+    leds.push_back(left_light);
+
+    led right_light;
+    right_light.name  = "Right";
+    right_light.value = AMBX_LIGHT_RIGHT;
+    leds.push_back(right_light);
+
+    led wall_left;
+    wall_left.name  = "Wall Left";
+    wall_left.value = AMBX_LIGHT_WALL_LEFT;
+    leds.push_back(wall_left);
+
+    led wall_center;
+    wall_center.name  = "Wall Center";
+    wall_center.value = AMBX_LIGHT_WALL_CENTER;
+    leds.push_back(wall_center);
+
+    led wall_right;
+    wall_right.name  = "Wall Right";
+    wall_right.value = AMBX_LIGHT_WALL_RIGHT;
+    leds.push_back(wall_right);
+
+    SetupColors();
+}
+
+void RGBController_AMBX::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    // This device does not support resizing zones
+}
+
+void RGBController_AMBX::DeviceUpdateLEDs()
+{
+    if(!controller->IsInitialized())
+    {
+        return;
+    }
+
+    unsigned int led_values[5];
+    RGBColor led_colors[5];
+
+    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        led_values[led_idx] = leds[led_idx].value;
+        led_colors[led_idx] = colors[led_idx];
+    }
+
+    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
+}
+
+void RGBController_AMBX::UpdateZoneLEDs(int zone)
+{
+    if(!controller->IsInitialized())
+    {
+        return;
+    }
+
+    unsigned int start_idx = 0;
+    unsigned int zone_size = 0;
+
+    // Calculate start index and size
+    for(unsigned int z_idx = 0; z_idx < zones.size(); z_idx++)
+    {
+        if(z_idx == (unsigned int)zone)
+        {
+            zone_size = zones[z_idx].leds_count;
+            break;
+        }
+
+        start_idx += zones[z_idx].leds_count;
+    }
+
+    unsigned int led_values[5];
+    RGBColor led_colors[5];
+
+    for(unsigned int led_idx = 0; led_idx < zone_size; led_idx++)
+    {
+        unsigned int current_idx = start_idx + led_idx;
+        led_values[led_idx] = leds[current_idx].value;
+        led_colors[led_idx] = colors[current_idx];
+    }
+
+    controller->SetLEDColors(led_values, led_colors, zone_size);
+}
+
+void RGBController_AMBX::UpdateSingleLED(int led)
+{
+    if(!controller->IsInitialized())
+    {
+        return;
+    }
+
+    unsigned int led_value = leds[led].value;
+    RGBColor color = colors[led];
+    controller->SetLEDColor(led_value, color);
+}
+
+void RGBController_AMBX::DeviceUpdateMode()
+{
+    if(!controller->IsInitialized())
+    {
+        return;
+    }
+
+    DeviceUpdateLEDs();
+}
@@ -0,0 +1,32 @@
+/*---------------------------------------------------------*\
+| RGBController_AMBX.h                                      |
+|                                                           |
+|   RGB Controller for Philips amBX Gaming lights           |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AMBXController.h"
+
+class RGBController_AMBX : public RGBController
+{
+public:
+    RGBController_AMBX(AMBXController* controller_ptr);
+    ~RGBController_AMBX();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AMBXController* controller;
+};
@@ -12,7 +12,6 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
-#include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"

 /*---------------------------------------------------------*\
@@ -36,11 +35,12 @@
 void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
    {
        AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-        // Constructor sets the name
+
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -17,10 +17,11 @@

 using namespace std::chrono_literals;

-AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
+AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AOCKeyboardController::~AOCKeyboardController()
@@ -33,6 +34,11 @@ std::string AOCKeyboardController::GetDeviceLocation()
    return("HID " + location);
 }

+std::string AOCKeyboardController::GetDeviceName()
+{
+    return(name);
+}
+
 std::string AOCKeyboardController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -64,10 +64,11 @@ enum
 class AOCKeyboardController
 {
 public:
-    AOCKeyboardController(hid_device* dev_handle, const char* path);
+    AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AOCKeyboardController();

    std::string GetDeviceLocation();
+    std::string GetDeviceName();
    std::string GetSerialString();

    void SetLightingConfig
@@ -88,6 +89,7 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
+    std::string             name;

    void SendStartPacket();
    void SendEndPacket();
@@ -11,7 +11,6 @@

 #include "Detector.h"
 #include "AOCKeyboardController.h"
-#include "RGBController.h"
 #include "RGBController_AOCKeyboard.h"

 /*-----------------------------------------------------*\
@@ -35,9 +34,8 @@ void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
+        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
-        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -52,7 +52,7 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 {
    controller                      = controller_ptr;

-    name                            = "AOC Keyboard Device";
+    name                            = controller->GetDeviceName();
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "AOC Keyboard Device";
@@ -13,10 +13,11 @@
 #include "AOCMouseController.h"
 #include "StringUtils.h"

-AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
+AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AOCMouseController::~AOCMouseController()
@@ -29,6 +30,11 @@ std::string AOCMouseController::GetDeviceLocation()
    return("HID " + location);
 }

+std::string AOCMouseController::GetDeviceName()
+{
+    return(name);
+}
+
 std::string AOCMouseController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -56,10 +56,11 @@ enum
 class AOCMouseController
 {
 public:
-    AOCMouseController(hid_device* dev_handle, const char* path);
+    AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AOCMouseController();

    std::string GetDeviceLocation();
+    std::string GetDeviceName();
    std::string GetSerialString();

    void SendDirect
@@ -79,4 +80,5 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
+    std::string             name;
 };
@@ -11,7 +11,6 @@

 #include "Detector.h"
 #include "AOCMouseController.h"
-#include "RGBController.h"
 #include "RGBController_AOCMouse.h"

 /*-----------------------------------------------------*\
@@ -34,9 +33,8 @@ void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
+        AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
-        rgb_controller->name                   = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -26,7 +26,7 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 {
    controller                      = controller_ptr;

-    name                            = "AOC Mouse Device";
+    name                            = controller->GetDeviceName();
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_MOUSE;
    description                     = "AOC Mouse Device";
@@ -13,10 +13,11 @@
 #include "AOCMousematController.h"
 #include "StringUtils.h"

-AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
+AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AOCMousematController::~AOCMousematController()
@@ -29,6 +30,11 @@ std::string AOCMousematController::GetDeviceLocation()
    return("HID " + location);
 }

+std::string AOCMousematController::GetDeviceName()
+{
+    return(name);
+}
+
 std::string AOCMousematController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -55,10 +55,11 @@ enum
 class AOCMousematController
 {
 public:
-    AOCMousematController(hid_device* dev_handle, const char* path);
+    AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AOCMousematController();

    std::string GetDeviceLocation();
+    std::string GetDeviceName();
    std::string GetSerialString();

    void SendDirect
@@ -78,4 +79,5 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
+    std::string             name;
 };
@@ -11,7 +11,6 @@

 #include "Detector.h"
 #include "AOCMousematController.h"
-#include "RGBController.h"
 #include "RGBController_AOCMousemat.h"

 /*-----------------------------------------------------*\
@@ -34,9 +33,8 @@ void DetectAOCMousematControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
+        AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
-        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -26,7 +26,7 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 {
    controller                      = controller_ptr;

-    name                            = "AOC Mousemat Device";
+    name                            = controller->GetDeviceName();
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_MOUSEMAT;
    description                     = "AOC Mousemat Device";
@@ -11,7 +11,6 @@
 \*---------------------------------------------------------*/

 #include <cstring>
-#include <stdio.h>
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
@@ -10,16 +10,10 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
 #include <hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
-#include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"

 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -10,15 +10,12 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <stdio.h>
-#include <stdlib.h>
 #include <vector>
 #include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
 #include "LogManager.h"
-#include "RGBController.h"
 #include "RGBController_ASRockASRRGBSMBus.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
 #include "RGBController_ASRockPolychromeV2SMBus.h"
@@ -99,6 +99,11 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];

+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
    /*-----------------------------------------------------*\
    | Get firmware version                                  |
    \*-----------------------------------------------------*/
@@ -109,11 +114,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
    version             = fw_string.str();

-    /*-----------------------------------------------------*\
-    | Check if the device reports the wrong number of zones |
-    \*-----------------------------------------------------*/
-    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
-
    /*-----------------------------------------------------*\
    | Initialize Alienware zones                            |
    \*-----------------------------------------------------*/
@@ -9,7 +9,6 @@

 #include "Detector.h"
 #include "AlienwareController.h"
-#include "RGBController.h"
 #include "RGBController_Alienware.h"

 /*---------------------------------------------------------*\
@@ -14,10 +14,11 @@
 #include "AlienwareAW410KController.h"
 #include "StringUtils.h"

-AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
+AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;

    SendCommit();
 }
@@ -32,6 +33,11 @@ std::string AlienwareAW410KController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AlienwareAW410KController::GetDeviceName()
+{
+    return(name);
+}
+
 std::string AlienwareAW410KController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -75,10 +75,11 @@ struct SelectedButtons
 class AlienwareAW410KController
 {
 public:
-    AlienwareAW410KController(hid_device* dev_handle, const char* path);
+    AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AlienwareAW410KController();

    std::string GetDeviceLocation();
+    std::string GetDeviceName();
    std::string GetSerialString();

    void        SendInitialize();
@@ -140,6 +141,7 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
+    std::string             name;

    void        SendMode
                    (
@@ -176,7 +176,7 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 {
    controller                      = controller_ptr;

-    name                            = "Alienware AW410K Keyboard Device";
+    name                            = controller->GetDeviceName();
    vendor                          = "Alienware";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "Alienware AW410K Keyboard Device";
@@ -13,10 +13,11 @@
 #include "AlienwareAW510KController.h"
 #include "StringUtils.h"

-AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
+AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;

    SendCommit();
 }
@@ -31,6 +32,11 @@ std::string AlienwareAW510KController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AlienwareAW510KController::GetDeviceName()
+{
+    return(name);
+}
+
 std::string AlienwareAW510KController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -77,10 +77,11 @@ struct SelectedKeys
 class AlienwareAW510KController
 {
 public:
-    AlienwareAW510KController(hid_device* dev_handle, const char* path);
+    AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AlienwareAW510KController();

    std::string GetDeviceLocation();
+    std::string GetDeviceName();
    std::string GetSerialString();

    void        SendInitialize();
@@ -142,6 +143,7 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
+    std::string             name;

    void        SendMode
                    (
@@ -175,7 +175,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 {
    controller                      = controller_ptr;

-    name                            = "Alienware AW510K Keyboard Device";
+    name                            = controller->GetDeviceName();
    vendor                          = "Alienware";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "Alienware AW510K Keyboard Device";
@@ -11,7 +11,6 @@
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
 #include "AlienwareAW410KController.h"
-#include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
 #include "RGBController_AlienwareAW410K.h"

@@ -39,9 +38,9 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
    hid_device* dev = hid_open_path(info->path);
    if( dev )
    {
-        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path);
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
-        rgb_controller->name = name;
+
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -51,9 +50,9 @@ void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string&
    hid_device* dev = hid_open_path(info->path);
    if( dev )
    {
-        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
+        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
-        rgb_controller->name = name;
+
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }/* DetectAlienwareKeyboardControllers() */
@@ -0,0 +1,183 @@
+/*---------------------------------------------------------*\
+| AlienwareAW3423DWFController.cpp                          |
+|                                                           |
+|   Driver for the Alienware AW3423DWF monitor              |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <bitset>
+#include <chrono>
+#include <cstring>
+#include <thread>
+
+#include "AlienwareAW3423DWFController.h"
+#include "StringUtils.h"
+
+AlienwareAW3423DWFController::AlienwareAW3423DWFController(hid_device *dev_handle, const char *path) : dev(dev_handle), location(path){}
+
+void AlienwareAW3423DWFController::SendControlPacket(const unsigned char *data, size_t length)
+{
+    unsigned char buffer[256] = {0x00};
+    memcpy(buffer + 1, data, length);
+
+    hid_write(dev, buffer, length + 1);
+}
+
+std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
+{
+    uint8_t buffer[193];
+
+    memset(buffer, 0, 193);
+
+    hid_get_input_report(dev, buffer, 193);
+
+    return std::vector<unsigned char>(buffer + 1, buffer + 18);
+}
+
+void AlienwareAW3423DWFController::PerformLogin()
+{
+    unsigned char init_packet[64] =
+    {
+        0x40, 0xE1, 0x01
+    };
+    SendControlPacket(init_packet, 4);
+
+    std::vector<unsigned char> response = GetReportResponse();
+
+    std::vector<unsigned char> key = GenerateKey(response);
+
+    unsigned char login_packet[192] = {0x00};
+    login_packet[0] = 0x40;
+    login_packet[1] = 0xE1;
+    login_packet[2] = 0x02;
+    memcpy(login_packet + 64, key.data(), key.size());
+
+    SendControlPacket(login_packet, 192);
+}
+
+void AlienwareAW3423DWFController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
+{
+    unsigned char led_id_2 = (led_id == 0x01) ? 0xf6 : (led_id == 0x02) ? 0xf5
+                                                   : (led_id == 0x08)   ? 0xff
+                                                                        : 0xfc;
+    PerformLogin();
+
+    unsigned char color_packet[192] = {0x00};
+
+    color_packet[0]  = 0x40;
+    color_packet[1]  = 0xC6;
+    color_packet[6]  = 0x0A;
+    color_packet[8]  = 0x6E;
+    color_packet[10] = 0x82;
+    color_packet[64] = 0x51;
+    color_packet[65] = 0x87;
+    color_packet[66] = 0xD0;
+    color_packet[67] = 0x04;
+
+    color_packet[68] = led_id;
+    color_packet[69] = r;
+    color_packet[70] = g;
+    color_packet[71] = b;
+    color_packet[72] = 0x64;
+    color_packet[73] = led_id_2;
+
+    SendControlPacket(color_packet, 192);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+}
+
+std::vector<unsigned char> AlienwareAW3423DWFController::GenerateKey(
+    const std::vector<unsigned char> &response)
+{
+    std::vector<unsigned char> syn_key(8, 0);
+
+    const std::vector<unsigned char> oem_key = {
+        0xf5, 0x3f, 0xc1, 0x39, 0x44, 0x3a, 0x31, 0x79, 0x0d, 0xb1, 0x82, 0x76
+    };
+
+    size_t sk_idx = 0, ok_idx = 0;
+    while(ok_idx < oem_key.size() && sk_idx < 8)
+    {
+        unsigned char ok_sub_len = (oem_key[ok_idx] & 1) + ((oem_key[ok_idx] & 0x10) >> 4);
+
+        for(unsigned int i = 0; i < ok_sub_len && sk_idx < 8; i++)
+        {
+            syn_key[sk_idx] = oem_key[ok_idx + 1] ^ oem_key[ok_idx];
+            ok_idx++;
+            sk_idx++;
+        }
+        ok_idx++;
+    }
+
+    std::vector<unsigned char> out_buffer;
+
+    uint16_t v15 = static_cast<uint16_t>(response[15]) |
+                   (static_cast<uint16_t>(response[0]) << 8);
+    bool parity_odd = (std::bitset<16>(v15).count() % 2 != 0);
+
+    if(parity_odd)
+    {
+        size_t end = std::min<size_t>(8, response.size());
+        out_buffer = std::vector<unsigned char>(response.begin(), response.begin() + end);
+
+        if(response.size() > 14)
+        {
+            unsigned char idx = response[14] & 0x07;
+            if((idx + 8) < (unsigned char)response.size())
+            {
+                out_buffer[idx] ^= response[idx + 8];
+            }
+        }
+    }
+    else
+    {
+        size_t start = std::min<size_t>(8, response.size());
+        size_t end = std::min<size_t>(start + 8, response.size());
+        out_buffer = std::vector<unsigned char>(response.begin() + start, response.begin() + end);
+
+        if(response.size() > 6)
+        {
+            unsigned char idx = response[6] & 0x07;
+            if(idx < response.size())
+            {
+                out_buffer[idx] ^= response[idx];
+            }
+        }
+    }
+
+    for(size_t i = 0; i < 8 && i < out_buffer.size(); i++)
+    {
+        syn_key[i] ^= out_buffer[i];
+    }
+
+    return syn_key;
+}
+
+AlienwareAW3423DWFController::~AlienwareAW3423DWFController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+        dev = nullptr;
+    }
+}
+
+std::string AlienwareAW3423DWFController::GetLocation()
+{
+    return "HID: " + location;
+}
+
+std::string AlienwareAW3423DWFController::GetSerialString()
+{
+    wchar_t serial[256];
+    if(hid_get_serial_number_string(dev, serial, 256) >= 0)
+    {
+        std::wstring ws(serial);
+        return StringUtils::wstring_to_string(ws);
+    }
+    return "";
+}
@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+| AlienwareAW3423DWFController.h                            |
+|                                                           |
+|   Driver for the Alienware AW3423DWF monitor              |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <hidapi.h>
+#include <vector>
+#include <string>
+
+class AlienwareAW3423DWFController
+{
+public:
+    AlienwareAW3423DWFController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW3423DWFController();
+
+    std::string GetLocation();
+    std::string GetSerialString();
+    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
+
+private:
+    hid_device* dev;
+    std::string location;
+
+    static const std::vector<std::vector<unsigned char>> OEM_KEYS;
+
+    void PerformLogin();
+    std::vector<unsigned char> GenerateKey(const std::vector<unsigned char>& response);
+    void SendControlPacket(const unsigned char* data, size_t length);
+    std::vector<unsigned char> GetReportResponse();
+};
@@ -0,0 +1,146 @@
+/*---------------------------------------------------------*\
+| AlienwareMonitorController.cpp                            |
+|                                                           |
+|   Detector for Alienware monitors                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <chrono>
+#include <cstring>
+#include <thread>
+
+#include "AlienwareMonitorController.h"
+
+AlienwareMonitorController::AlienwareMonitorController(hid_device *dev_handle, const char *path, std::string dev_name)
+{
+    dev         = dev_handle;
+    location    = path;
+    name        = dev_name;
+
+    Initialize();
+}
+
+AlienwareMonitorController::~AlienwareMonitorController()
+{
+    hid_close(dev);
+}
+
+std::string AlienwareMonitorController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareMonitorController::GetName()
+{
+    return(name);
+}
+
+std::string AlienwareMonitorController::GetSerialString()
+{
+    return("");
+}
+
+void fillInChecksum(unsigned char *packet)
+{
+    unsigned char checksum = 110;
+
+    for(unsigned int index = 5; index <= 13; index++)
+    {
+      checksum ^= packet[index];
+    }
+
+    packet[14] = checksum;
+}
+
+void AlienwareMonitorController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
+{
+    unsigned char packet[65];
+
+    memset(packet, 0xFF, sizeof(packet));
+
+    packet[0] = 0x00;
+    packet[1] = 0x92;
+    packet[2] = 0x37;
+    packet[3] = 0x0a;
+    packet[4] = 0x00;
+    packet[5] = 0x51;
+    packet[6] = 0x87;
+    packet[7] = 0xd0;
+    packet[8] = 0x04;
+
+    packet[9] = led_id;
+    packet[10] = r;
+    packet[11] = g;
+    packet[12] = b;
+    packet[13] = 0x64;
+
+    fillInChecksum(packet);
+
+    hid_write(dev, packet, sizeof(packet));
+
+    /*-----------------------------------------------------*\
+    | Delay 50 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+}
+
+void AlienwareMonitorController::Initialize()
+{
+    unsigned char packet[65];
+
+    memset(packet, 0xFF, sizeof(packet));
+
+    packet[0] = 0x00;
+    packet[1] = 0x95;
+    packet[2] = 0x00;
+    packet[3] = 0x00;
+    packet[4] = 0x00;
+
+    hid_write(dev, packet, sizeof(packet));
+
+    /*-----------------------------------------------------*\
+    | Delay 50 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+
+    memset(packet, 0xFF, sizeof(packet));
+
+    packet[0] = 0x00;
+    packet[1] = 0x92;
+    packet[2] = 0x37;
+    packet[3] = 0x08;
+    packet[4] = 0x00;
+    packet[5] = 0x51;
+    packet[6] = 0x85;
+    packet[7] = 0x01;
+    packet[8] = 0xFE;
+    packet[9] = 0x03;
+    packet[10] = 0x00;
+    packet[11] = 0x06;
+    packet[12] = 0x40;
+
+    hid_write(dev, packet, sizeof(packet));
+
+    /*-----------------------------------------------------*\
+    | Delay 50 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+
+    memset(packet, 0x00, sizeof(packet));
+
+    packet[0] = 0x00;
+    packet[1] = 0x93;
+    packet[2] = 0x37;
+    packet[3] = 0x12;
+
+    hid_write(dev, packet, sizeof(packet));
+
+    /*-----------------------------------------------------*\
+    | Delay 50 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+}
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| AlienwareMonitorController.h                              |
+|                                                           |
+|   Detector for Alienware monitors                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <hidapi.h>
+#include <vector>
+#include <string>
+
+class AlienwareMonitorController
+{
+public:
+AlienwareMonitorController(hid_device* dev_handle, const char* path, std::string dev_name);
+    ~AlienwareMonitorController();
+
+    std::string GetLocation();
+    std::string GetName();
+    std::string GetSerialString();
+    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
+
+private:
+    hid_device* dev;
+    std::string location;
+    std::string name;
+
+    void Initialize();
+};
@@ -0,0 +1,66 @@
+/*---------------------------------------------------------*\
+| AlienwareMonitorControllerDetect.cpp                      |
+|                                                           |
+|   Detector for Alienware monitors                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "AlienwareAW3423DWFController.h"
+#include "AlienwareMonitorController.h"
+#include "RGBController_AlienwareAW3423DWF.h"
+#include "RGBController_AlienwareMonitor.h"
+#include <hidapi.h>
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x187C
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW3423DWF_PID                     0x100E
+#define ALIENWARE_AW3225QF_PID                      0x1013
+#define ALIENWARE_USAGE_PAGE                        0xFFDA
+#define ALIENWARE_USAGE                             0x00DA
+
+/******************************************************************************************\
+*                                                                                          *
+*   AlienwareAW3423DWFControllerDetect                                                     *
+*                                                                                          *
+*       Tests the USB address to see if an Alienware AW3423DWF exists there.               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
+        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
+        RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
+REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareAW3423DWF.cpp                      |
+|                                                           |
+|   RGBController for the Alienware AW3423DWF monitor       |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AlienwareAW3423DWF.h"
+
+/**------------------------------------------------------------------*\
+    @name AW3423DWF
+    @category Accessory
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAlienwareAW3423DWFControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = "Alienware AW3423DWF";
+    vendor                  = "Alienware";
+    type                    = DEVICE_TYPE_MONITOR;
+    description             = "Alienware AW3423DWF Monitor Device";
+    location                = controller->GetLocation();
+    serial                  = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    active_mode             = 0;
+
+    SetupZones();
+}
+
+RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
+{
+    delete controller;
+}
+
+void RGBController_AlienwareAW3423DWF::SetupZones()
+{
+    zone Logo;
+    Logo.name               = "Logo";
+    Logo.type               = ZONE_TYPE_SINGLE;
+    Logo.leds_min           = 1;
+    Logo.leds_max           = 1;
+    Logo.leds_count         = 1;
+    Logo.matrix_map         = NULL;
+    zones.push_back(Logo);
+
+    led Logo_LED;
+    Logo_LED.name           = "Logo";
+    Logo_LED.value          = 0x01;
+    leds.push_back(Logo_LED);
+
+    zone Number;
+    Number.name             = "Number";
+    Number.type             = ZONE_TYPE_SINGLE;
+    Number.leds_min         = 1;
+    Number.leds_max         = 1;
+    Number.leds_count       = 1;
+    Number.matrix_map       = NULL;
+    zones.push_back(Number);
+
+    led Number_LED;
+    Number_LED.name         = "Number";
+    Number_LED.value        = 0x02;
+    leds.push_back(Number_LED);
+
+    zone PowerButton;
+    PowerButton.name        = "Power Button";
+    PowerButton.type        = ZONE_TYPE_SINGLE;
+    PowerButton.leds_min    = 1;
+    PowerButton.leds_max    = 1;
+    PowerButton.leds_count  = 1;
+    PowerButton.matrix_map  = NULL;
+    zones.push_back(PowerButton);
+
+    led PowerButton_LED;
+    PowerButton_LED.name    = "Power Button";
+    PowerButton_LED.value   = 0x08;
+    leds.push_back(PowerButton_LED);
+
+    SetupColors();
+}
+
+void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+}
+
+void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
+{
+    /*-----------------------------------------------------*\
+    | If all three colors are the same value, speed up the  |
+    | direct mode by using the ALL target (0x0B) instead of |
+    | setting each LED individually.                        |
+    \*-----------------------------------------------------*/
+    if((colors[0] == colors[1]) && (colors[1] == colors[2]))
+    {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
+        controller->SendColor(0x0B, red, grn, blu);
+    }
+    else
+    {
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            UpdateSingleLED(led_idx);
+        }
+    }
+}
+
+void RGBController_AlienwareAW3423DWF::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AlienwareAW3423DWF::UpdateSingleLED(int led)
+{
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);
+    controller->SendColor(leds[led].value, red, grn, blu);
+}
+
+void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()
+{
+}
@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareAW3423DWF.h                        |
+|                                                           |
+|   RGBController for the Alienware AW3423DWF monitor       |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "AlienwareAW3423DWFController.h"
+#include "RGBController.h"
+
+class RGBController_AlienwareAW3423DWF : public RGBController
+{
+public:
+    explicit RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr);
+    ~RGBController_AlienwareAW3423DWF();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW3423DWFController* controller;
+};
@@ -0,0 +1,143 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareMonitor.cpp                        |
+|                                                           |
+|   RGBController for Alienware monitors                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AlienwareMonitor.h"
+
+/**------------------------------------------------------------------*\
+    @name Alienware Monitor
+    @category Accessory
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAlienwareMonitorControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = controller->GetName();
+    description             = "Alienware Monitor";
+    vendor                  = "Alienware";
+    type                    = DEVICE_TYPE_MONITOR;
+    location                = controller->GetLocation();
+    serial                  = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    active_mode             = 0;
+
+    SetupZones();
+}
+
+RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
+{
+    delete controller;
+}
+
+void RGBController_AlienwareMonitor::SetupZones()
+{
+    zone Logo;
+    Logo.name               = "Logo";
+    Logo.type               = ZONE_TYPE_SINGLE;
+    Logo.leds_min           = 1;
+    Logo.leds_max           = 1;
+    Logo.leds_count         = 1;
+    Logo.matrix_map         = NULL;
+    zones.push_back(Logo);
+
+    led Logo_LED;
+    Logo_LED.name           = "Logo";
+    Logo_LED.value          = 0x01;
+    leds.push_back(Logo_LED);
+
+    zone Number;
+    Number.name             = "Number";
+    Number.type             = ZONE_TYPE_SINGLE;
+    Number.leds_min         = 1;
+    Number.leds_max         = 1;
+    Number.leds_count       = 1;
+    Number.matrix_map       = NULL;
+    zones.push_back(Number);
+
+    led Number_LED;
+    Number_LED.name         = "Number";
+    Number_LED.value        = 0x02;
+    leds.push_back(Number_LED);
+
+    zone PowerButton;
+    PowerButton.name        = "Power Button";
+    PowerButton.type        = ZONE_TYPE_SINGLE;
+    PowerButton.leds_min    = 1;
+    PowerButton.leds_max    = 1;
+    PowerButton.leds_count  = 1;
+    PowerButton.matrix_map  = NULL;
+    zones.push_back(PowerButton);
+
+    led PowerButton_LED;
+    PowerButton_LED.name    = "Power Button";
+    PowerButton_LED.value   = 0x08;
+    leds.push_back(PowerButton_LED);
+
+    SetupColors();
+}
+
+void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
+{
+    /*-----------------------------------------------------*\
+    | If all three colors are the same value, speed up the  |
+    | direct mode by using the ALL target (0x0B) instead of |
+    | setting each LED individually.                        |
+    \*-----------------------------------------------------*/
+    if((colors[0] == colors[1]) && (colors[1] == colors[2]))
+    {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
+        controller->SendColor(0x0B, red, grn, blu);
+    }
+    else
+    {
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            UpdateSingleLED(led_idx);
+        }
+    }
+}
+
+void RGBController_AlienwareMonitor::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AlienwareMonitor::UpdateSingleLED(int led)
+{
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);
+    controller->SendColor(leds[led].value, red, grn, blu);
+}
+
+void RGBController_AlienwareMonitor::DeviceUpdateMode()
+{
+
+}
@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareMonitor.h                          |
+|                                                           |
+|   RGBController for Alienware monitors                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareMonitorController.h"
+
+class RGBController_AlienwareMonitor : public RGBController
+{
+public:
+RGBController_AlienwareMonitor(AlienwareMonitorController* controller_ptr);
+    ~RGBController_AlienwareMonitor();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+AlienwareMonitorController* controller;
+};
@@ -11,7 +11,6 @@

 #include "Detector.h"
 #include "AnnePro2Controller.h"
-#include "RGBController.h"
 #include "RGBController_AnnePro2.h"
 #include <hidapi.h>

@@ -41,11 +40,12 @@
 void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
    {
        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
-        // Constructor sets the name
+
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -76,9 +76,9 @@ void ArcticController::SetChannels(std::vector<RGBColor> colors)
    {
        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;

-        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
-        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
-        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
+        buffer[offset + 0x00] = (char)std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
+        buffer[offset + 0x01] = (char)std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
+        buffer[offset + 0x02] = (char)std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
    }

    serialport.serial_write(buffer, sizeof(buffer));
@@ -9,12 +9,9 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <stdio.h>
-#include <stdlib.h>
 #include <vector>
 #include "Detector.h"
 #include "ArcticController.h"
-#include "RGBController.h"
 #include "RGBController_Arctic.h"
 #include "find_usb_serial_port.h"

@@ -35,7 +35,7 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*n
    {
        AuraCoreController*     controller                  = new AuraCoreController(dev, info->path);
        RGBController_AuraCore* rgb_controller              = new RGBController_AuraCore(controller);
-        // Constructor sets the name
+
        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
        {
            ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -55,7 +55,7 @@ void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::strin
    {
        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
-        // Constructor sets the name
+
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -67,6 +67,7 @@ AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handl
    | Only set power config for known devices                   |
    \*---------------------------------------------------------*/
    SetPowerConfigFromJSON();
+    SendInitDirectMode();
 }

 AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
@@ -178,6 +179,7 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t

        if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
        {
+            SendBrightness();
            SendInitDirectMode();
            return;
        }
@@ -204,7 +206,7 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
    |   zones are sent in one final packet afterwards.          |
    \*---------------------------------------------------------*/
    const uint8_t   key_set                                 = 167;
-    const uint8_t   led_count                               = colors.size();
+    const uint8_t   led_count                               = (uint8_t)colors.size();
    const uint16_t  map_size                                = 3 * led_count;
    const uint8_t   leds_per_packet                         = 16;
    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
@@ -213,7 +215,7 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)

    memset(key_buf, 0, map_size);

-    for(size_t led_index = 0; led_index < led_count; led_index++)
+    for(uint8_t led_index = 0; led_index < led_count; led_index++)
    {
        std::size_t buf_idx     = (led_index * 3);

@@ -222,9 +224,9 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
        key_buf[buf_idx + 2]    = RGBGetBValue(*colors[led_index]);
    }

-    for(size_t i = 0; i < key_set; i+=leds_per_packet)
+    for(uint8_t i = 0; i < key_set; i += leds_per_packet)
    {
-        uint8_t leds_remaining  = key_set - (uint8_t)i;
+        uint8_t leds_remaining  = key_set - i;

        if(leds_remaining < leds_per_packet)
        {
@@ -235,7 +237,7 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
                   ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
        }

-        buffer[06]              = (uint8_t)i;
+        buffer[06]              = i;
        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));

        LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
@@ -68,19 +68,99 @@ keyboard_keymap_overlay_values g533zm_layout
        }
    },
    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
-        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      4,      13,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
-        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      5,      12,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow
-        {   0,      5,      13,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
-        {   0,      5,      14,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
+        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop
+        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous
+        {   0,      4,      13,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
+        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next
+        {   0,      5,      12,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow
+        {   0,      5,      13,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
+        {   0,      5,      14,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
+    }
+};
+
+keyboard_keymap_overlay_values g533zw_layout
+{
+    KEYBOARD_SIZE_SEVENTY_FIVE,
+    {
+        aura_core_laptop_15_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
+        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop
+        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous
+        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Media Next
+        {   0,      5,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Function key
+        {   0,      5,       4,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Unused key
+        {   0,      5,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Func key
+        {   0,      5,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Context key
+        {   0,      5,      13,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
+        {   0,      5,      15,         142,        KEY_EN_PRINT_SCREEN,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Print Screen
+        {   0,      5,      16,         175,        "Keystone",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Keystone (Red only)
+        {   0,      6,      12,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow on new row
+        {   0,      6,      13,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
+        {   0,      6,      14,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
+        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row before function keys
+        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Vol Up
+        {   0,      0,       4,           4,        "Mic On / Off",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mic On / Off
+        {   0,      0,       5,           5,        "Hyperfan",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Hyperfan
+        {   0,      0,       6,           6,        "Armoury Crate",            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Armoury Crate
+    }
+};
+
+keyboard_keymap_overlay_values g533zw_lid_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         167,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         176,        "Vertical Cut Left",        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         177,        "Vertical Cut Right",       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
+    }
+};
+
+keyboard_keymap_overlay_values g533zw_lightbar_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         174,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         173,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         172,        "Lightbar L3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
+        {   0,      0,       3,         171,        "Lightbar R3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
+        {   0,      0,       4,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       5,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
    }
 };

@@ -94,55 +174,55 @@ keyboard_keymap_overlay_values g713rw_keyboard_layout
        }
    },
    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
-        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
-        {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
-        {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
-        {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
-        {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
-        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-        {   0,      6,      10,         136,        KEY_EN_RIGHT_FUNCTION,      KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Fuction
-        {   0,      6,      10,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+        {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+        {   0,      0,       5,           5,        "Key: Fan",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+        {   0,      0,       6,           6,        "Key: ROG",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+        {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_FUNCTION,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Fuction
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_WINDOWS,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key

-        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },
-        {   0,      1,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
-        {   0,      1,      15,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Delete key
-        {   0,      1,      17,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
-        {   0,      1,      18,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // gap before arrow up key
-        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },
+        {   0,      1,      15,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      1,      15,          38,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Delete key
+        {   0,      1,      17,          40,        KEY_EN_PRINT_SCREEN,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+        {   0,      1,      18,          41,        KEY_EN_HOME,                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // gap before arrow up key
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad

-        {   0,      6,      11,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key before arrow keys
-        {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
-        {   0,      6,      16,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key between numpad 0 and .
+        {   0,      6,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key before arrow keys
+        {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      6,      16,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key between numpad 0 and .

        // Close numpad gap completely
-        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      6,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      6,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },

        // Move Arrow keys
-        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Up
-        {   0,      6,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Down
-        {   0,      6,      12,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_SWAP_ONLY,          },  // Shift Arrow Up
-        {   0,      7,      11,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      12,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      13,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Up
+        {   0,      6,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Down
+        {   0,      6,      12,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Shift Arrow Up
+        {   0,      7,      11,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      12,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      13,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
    }
 };

@@ -156,16 +236,109 @@ keyboard_keymap_overlay_values g713rw_lightbar_layout
        }
    },
    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         174,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         173,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         172,        "Lightbar L3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
-        {   0,      0,       3,         171,        "Lightbar R3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
-        {   0,      0,       4,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-        {   0,      0,       5,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         174,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         173,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         172,        "Lightbar L3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
+        {   0,      0,       3,         171,        "Lightbar R3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
+        {   0,      0,       4,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       5,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
+    }
+};
+
+keyboard_keymap_overlay_values g713rw_test_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,           7,        "Test01",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       1,           8,        "Test02",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       2,           9,        "Test03",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       3,          10,        "Test04",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       4,          11,        "Test05",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       5,          12,        "Test06",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       6,          13,        "Test07",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       7,          14,        "Test08",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       8,          15,        "Test09",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,       9,          16,        "Test10",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      10,          17,        "Test11",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      11,          18,        "Test12",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      12,          19,        "Test13",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      13,          20,        "Test14",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      14,          22,        "Test15",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      15,          27,        "Test16",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      16,          55,        "Test17",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      17,          57,        "Test18",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,          58,        "Test19",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,          77,        "Test20",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      20,          78,        "Test21",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      21,          79,        "Test22",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      22,          96,        "Test23",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      23,          97,        "Test24",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      24,          99,        "Test25",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      25,         100,        "Test26",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      26,         104,        "Test27",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      27,         117,        "Test28",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      28,         118,        "Test29",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      29,         120,        "Test30",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      30,         121,        "Test31",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      31,         130,        "Test32",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      32,         132,        "Test33",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      33,         133,        "Test34",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      34,         134,        "Test35",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      35,         138,        "Test36",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      36,         140,        "Test37",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      37,         141,        "Test38",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      38,         142,        "Test39",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      39,         143,        "Test40",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      40,         146,        "Test41",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      41,         147,        "Test42",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      42,         148,        "Test43",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      43,         149,        "Test44",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      44,         150,        "Test45",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      45,         151,        "Test46",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      46,         152,        "Test47",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      47,         153,        "Test48",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      48,         154,        "Test49",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      49,         155,        "Test50",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      50,         156,        "Test51",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      51,         157,        "Test52",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      52,         158,        "Test53",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      53,         162,        "Test54",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      54,         163,        "Test55",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      55,         164,        "Test56",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      56,         165,        "Test57",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      57,         166,        "Test58",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      58,         167,        "Test59",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    }
+};
+
+keyboard_keymap_overlay_values g733zm_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        aura_core_laptop_17_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
    }
 };

@@ -179,38 +352,38 @@ keyboard_keymap_overlay_values g814jv_keyboard_layout
        }
    },
    {
-     /*---------------------------------------------------------------------------------------------------------*\
-    | Edit Keys                                                                                                 |
-    |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-    \*---------------------------------------------------------------------------------------------------------*/
-     {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
-     {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
-     {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
-     {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
-     {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
-     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-     {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
-     {   0,      6,      11,         136,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_SWAP_ONLY,          },  // Replace Right Fuction with PrtSc
-     {   0,      6,      12,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
-     {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      1,      14,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Insert a Delete key
-     {   0,      1,      16,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
-     {   0,      1,      17,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  }, // Numpad gap
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     /*------------------------------------------------------------------------------------------------------------------------------------*\
+    | Edit Keys                                                                                                                             |
+    |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+    \*-------------------------------------------------------------------------------------------------------------------------------------*/
+     {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+     {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+     {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+     {   0,      0,       5,           5,        "Key: Fan",                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+     {   0,      0,       6,           6,        "Key: ROG",                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+     {   0,      6,      10,         136,        KEY_EN_PRINT_SCREEN,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Replace Right Fuction with PrtSc
+     {   0,      6,      11,           0,        KEY_EN_RIGHT_WINDOWS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+     {   0,      1,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      1,      14,          38,        KEY_EN_DELETE,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Insert a Delete key
+     {   0,      1,      16,          40,        KEY_EN_PRINT_SCREEN,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+     {   0,      1,      17,          41,        KEY_EN_HOME,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  }, // Numpad gap
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      12,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      13,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      6,      15,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
     }
 };

@@ -224,14 +397,14 @@ keyboard_keymap_overlay_values g814jv_lightbar_layout
        }
    },
    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         173,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         172,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-        {   0,      0,       3,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         173,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         172,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       3,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
    }
 };

@@ -241,7 +414,7 @@ keyboard_keymap_overlay_values g814jv_lightbar_layout
 \*-------------------------------------------------------------------------*/

 /*-------------------------------------------------------------*\
-|  ASUS ROG Strix SCAR 15                                       |
+|  ASUS ROG Strix SCAR 15 G533ZM                                |
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
@@ -266,6 +439,44 @@ static const aura_core_laptop_device g533zm_device =
    }
 };

+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix SCAR 15 G533ZW                                |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_zone g533zw_lid_zone =
+{
+    "Lid",
+    &g533zw_lid_layout
+};
+
+static const aura_core_laptop_zone g533zw_kb_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g533zw_layout
+};
+
+static const aura_core_laptop_zone g533zw_lightbar_zone =
+{
+    "Lightbar",
+    &g533zw_lightbar_layout
+};
+
+static const aura_core_laptop_device g533zw_device =
+{
+    "G533ZW",
+    {
+        &g533zw_kb_zone,
+        &g533zw_lid_zone,
+        &g533zw_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
 /*-------------------------------------------------------------*\
 |  ASUS ROG Strix SCAR G713RW                                   |
 |                                                               |
@@ -339,6 +550,7 @@ const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
    &g533zm_device,
+    &g533zw_device,
    &g713rw_device,
    &g814jv_device,
 };
@@ -41,7 +41,7 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL

    name                                    = aura_dev->dmi_name;
    vendor                                  = "Asus";
-    type                                    = DEVICE_TYPE_KEYBOARD;
+    type                                    = DEVICE_TYPE_LAPTOP;
    description                             = controller->GetDeviceDescription();
    serial                                  = controller->GetSerial();
    location                                = controller->GetLocation();
@@ -49,7 +49,10 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
    mode Direct;
    Direct.name                 = "Direct";
    Direct.value                = ASUSAURACORELAPTOP_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Direct.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Direct.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

@@ -355,7 +358,7 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                    |   Place keys in the layout to populate the matrix         |
                    \*---------------------------------------------------------*/
                    new_zone.leds_count             = new_kb.GetKeyCount();
-                    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+                    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                    {
                        led new_led;

@@ -13,12 +13,11 @@
 #include "AsusAuraGPUController.h"
 #include "pci_ids.h"

-AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
+AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev, std::string dev_name)
 {
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "ASUS Aura GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
 }

 AuraGPUController::~AuraGPUController()
@@ -28,7 +27,7 @@ AuraGPUController::~AuraGPUController()

 std::string AuraGPUController::GetDeviceName()
 {
-    return(device_name);
+    return(name);
 }

 std::string AuraGPUController::GetDeviceLocation()
@@ -43,7 +43,7 @@ enum
 class AuraGPUController
 {
 public:
-    AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id);
+    AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id, std::string dev_name);
    ~AuraGPUController();

    std::string   GetDeviceName();
@@ -62,7 +62,7 @@ public:
    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode

 private:
-    char                    device_name[16];
    i2c_smbus_interface *   bus;
    aura_gpu_dev_id         dev;
+    std::string             name;
 };
@@ -9,13 +9,9 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
-#include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
@@ -60,85 +56,93 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 {
    if(TestForAsusAuraGPUController(bus, i2c_addr))
    {
-        AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr);
+        AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr, name);
        RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
-        rgb_controller->name                  = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 } /* DetectAsusAuraGPUControllers() */

 /*-----------------------------------------*\
-|  NVidia GPUs                              |
+|  Nvidia GPUs                              |
 \*-----------------------------------------*/

-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti 4G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER A4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_A4G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 Ti OC 6G"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G EVO Gaming" , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G White"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1060_6G_GAMING,           0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1060,                     0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1060_865B,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_8G_GAMING,           0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 OC",                    DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_OC,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 A8G Ti Gaming",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 A8G Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC 11Gbps",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Poseidon GeForce GTX 1080 Ti",                 DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_POSEIDON_GTX1080TI,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1650 SUPER A4G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_A4G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1650 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_6G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO V2 Gaming",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_06G_EVO_V2_GAMING,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO Gaming OC",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G EVO Gaming",  DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING_8702,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING_86FD,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 A8G Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 V2 Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER White OC",        DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti A11G Gaming",        DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC,                 0x2A);

 /*-----------------------------------------*\
 |  AMD GPUs                                 |
 \*-----------------------------------------*/

-REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING_05C3,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING_04BE,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O4G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O8G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 590 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX590_STRIX_GAMING,                    0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS AREZ STRIX Radeon RX Vega 56 Gaming OC",           DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon Vega 64",                         DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 470 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 480 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING,                    0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 480 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 560 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 560 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING_04BE,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 570 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 570 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 580 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 580 Gaming TOP",               DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 590 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX590_STRIX_GAMING,                    0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5600 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 Gaming OC",               DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700_STRIX_GAMING_OC,                0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING_05C3,        0x2A);
@@ -13,10 +13,11 @@
 #include "AsusAuraHeadsetStandController.h"
 #include "StringUtils.h"

-AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
+AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AuraHeadsetStandController::~AuraHeadsetStandController()
@@ -29,6 +30,11 @@ std::string AuraHeadsetStandController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AuraHeadsetStandController::GetName()
+{
+    return(name);
+}
+
 std::string AuraHeadsetStandController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -33,31 +33,33 @@ enum
 class AuraHeadsetStandController
 {
 public:
-    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
+    AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name);
    virtual ~AuraHeadsetStandController();

    std::string GetDeviceLocation();
+    std::string GetName();
    std::string GetSerialString();
    std::string GetVersion();

-    void UpdateLeds
-        (
-        std::vector<RGBColor>    colors
-        );
+    void        UpdateLeds
+                    (
+                    std::vector<RGBColor>    colors
+                    );

-    void UpdateDevice
-        (
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        unsigned char   speed,
-        unsigned char   brightness
-        );
+    void        UpdateDevice
+                    (
+                    unsigned char   mode,
+                    unsigned char   red,
+                    unsigned char   grn,
+                    unsigned char   blu,
+                    unsigned char   speed,
+                    unsigned char   brightness
+                    );

-    void SaveMode();
+    void        SaveMode();

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -24,88 +24,88 @@

 RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                      = controller_ptr;

-    name        = "ASUS Aura Headset Stand";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_HEADSET_STAND;
-    description = "ASUS Aura Headset Stand Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                            = controller->GetName();
+    vendor                          = "ASUS";
+    type                            = DEVICE_TYPE_HEADSET_STAND;
+    description                     = "ASUS Aura Headset Stand Device";
+    version                         = controller->GetVersion();
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();

    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_HEADSET_STAND_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                     = "Direct";
+    Direct.value                    = AURA_HEADSET_STAND_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          = AURA_HEADSET_STAND_MODE_STATIC;
-    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Static.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min     = 1;
-    Static.colors_max     = 1;
+    Static.name                     = "Static";
+    Static.value                    = AURA_HEADSET_STAND_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.brightness_min           = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Static.brightness_max           = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Static.brightness               = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
    Static.colors.resize(1);
    modes.push_back(Static);

    mode Breathing;
-    Breathing.name           = "Breathing";
-    Breathing.value          = AURA_HEADSET_STAND_MODE_BREATHING;
-    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    Breathing.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    Breathing.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Breathing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Breathing.colors_min     = 1;
-    Breathing.colors_max     = 1;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = AURA_HEADSET_STAND_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min             = AURA_HEADSETSTAND_SPEED_MIN;
+    Breathing.speed_max             = AURA_HEADSETSTAND_SPEED_MAX;
+    Breathing.speed                 = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Breathing.brightness_min        = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Breathing.brightness_max        = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Breathing.brightness            = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
    Breathing.colors.resize(1);
    modes.push_back(Breathing);

    mode Strobing;
-    Strobing.name           = "Flashing";
-    Strobing.value          = AURA_HEADSET_STAND_MODE_STROBING;
-    Strobing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Strobing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Strobing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Strobing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Strobing.colors_min     = 1;
-    Strobing.colors_max     = 1;
+    Strobing.name                   = "Flashing";
+    Strobing.value                  = AURA_HEADSET_STAND_MODE_STROBING;
+    Strobing.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Strobing.brightness_min         = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Strobing.brightness_max         = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Strobing.brightness             = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Strobing.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min             = 1;
+    Strobing.colors_max             = 1;
    Strobing.colors.resize(1);
    modes.push_back(Strobing);

    mode SpectrumCycle;
-    SpectrumCycle.name           = "Spectrum Cycle";
-    SpectrumCycle.value          = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    SpectrumCycle.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    SpectrumCycle.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    SpectrumCycle.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    SpectrumCycle.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    SpectrumCycle.color_mode     = MODE_COLORS_NONE;
+    SpectrumCycle.name              = "Spectrum Cycle";
+    SpectrumCycle.value             = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    SpectrumCycle.speed_min         = AURA_HEADSETSTAND_SPEED_MIN;
+    SpectrumCycle.speed_max         = AURA_HEADSETSTAND_SPEED_MAX;
+    SpectrumCycle.speed             = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    SpectrumCycle.brightness_min    = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    SpectrumCycle.brightness_max    = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    SpectrumCycle.brightness        = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    SpectrumCycle.color_mode        = MODE_COLORS_NONE;
    modes.push_back(SpectrumCycle);

    mode Rainbow;
-    Rainbow.name           = "Rainbow Wave";
-    Rainbow.value          = AURA_HEADSET_STAND_MODE_RAINBOW;
-    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Rainbow.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    Rainbow.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    Rainbow.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Rainbow.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Rainbow.name                    = "Rainbow Wave";
+    Rainbow.value                   = AURA_HEADSET_STAND_MODE_RAINBOW;
+    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.speed_min               = AURA_HEADSETSTAND_SPEED_MIN;
+    Rainbow.speed_max               = AURA_HEADSETSTAND_SPEED_MAX;
+    Rainbow.speed                   = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Rainbow.brightness_min          = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Rainbow.brightness_max          = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Rainbow.brightness              = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
    modes.push_back(Rainbow);
    SetupZones();
 }
@@ -13,10 +13,11 @@
 #include "AsusAuraKeyboardController.h"
 #include "StringUtils.h"

-AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
+AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AuraKeyboardController::~AuraKeyboardController()
@@ -29,6 +30,11 @@ std::string AuraKeyboardController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AuraKeyboardController::GetNameString()
+{
+    return(name);
+}
+
 std::string AuraKeyboardController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -19,19 +19,21 @@
 class AuraKeyboardController
 {
 public:
-    AuraKeyboardController(hid_device* dev_handle, const char* path);
+    AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
    virtual ~AuraKeyboardController();

    std::string GetDeviceLocation();
+    std::string GetNameString();
    std::string GetSerialString();

-    void SendDirect
-        (
-        unsigned char       frame_count,
-        unsigned char *     frame_data
-        );
+    void        SendDirect
+                    (
+                    unsigned char       frame_count,
+                    unsigned char *     frame_data
+                    );

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -358,21 +358,21 @@ static const std::vector<aura_keyboard_led> default_65pct_led_names =

 RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
 {
-    controller  = controller_ptr;
-    layout      = keyboard_layout;
+    controller          = controller_ptr;
+    layout              = keyboard_layout;

-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                = controller->GetNameString();
+    vendor              = "ASUS";
+    type                = DEVICE_TYPE_KEYBOARD;
+    description         = "ASUS Aura Keyboard Device";
+    location            = controller->GetDeviceLocation();
+    serial              = controller->GetSerialString();

    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name         = "Direct";
+    Direct.value        = 0;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    SetupZones();
@@ -14,11 +14,12 @@
 #include "LogManager.h"
 #include "StringUtils.h"

-AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
+AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
    device_pid  = pid;
+    name        = dev_name;
 }

 AuraMonitorController::~AuraMonitorController()
@@ -31,6 +32,11 @@ std::string AuraMonitorController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AuraMonitorController::GetNameString()
+{
+    return(name);
+}
+
 std::string AuraMonitorController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -27,19 +27,21 @@ enum
 class AuraMonitorController
 {
 public:
-    AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid);
+    AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
    virtual ~AuraMonitorController();

    std::string GetDeviceLocation();
+    std::string GetNameString();
    std::string GetSerialString();

-    void BeginUpdate();
-    void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
-    void ApplyChanges();
+    void        BeginUpdate();
+    void        UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
+    void        ApplyChanges();

-    uint16_t                    device_pid;
+    uint16_t    device_pid;

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -24,20 +24,20 @@

 RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller          = controller_ptr;

-    name        = "ASUS Aura Monitor";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_ACCESSORY;
-    description = "ASUS Aura Monitor Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                = controller->GetNameString();
+    vendor              = "ASUS";
+    type                = DEVICE_TYPE_MONITOR;
+    description         = "ASUS Aura Monitor Device";
+    location            = controller->GetDeviceLocation();
+    serial              = controller->GetSerialString();

    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name         = "Direct";
+    Direct.value        = 0;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    SetupZones();
@@ -13,11 +13,14 @@
 #include "AsusAuraMouseController.h"
 #include "StringUtils.h"

-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
+#define HID_MAX_STR 255
+
+AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
    device_pid  = pid;
+    name        = dev_name;
 }

 AuraMouseController::~AuraMouseController()
@@ -30,30 +33,9 @@ std::string AuraMouseController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+std::string AuraMouseController::GetName()
 {
-    /*---------------------------------------------------------------*\
-    | Cleans garbage at the end of serial numbers                     |
-    | (apparently 2 characters too much, but maybe variable)          |
-    | Limited to new devices, old ones don't even have serial numbers |
-    \*---------------------------------------------------------------*/
-    std::string result;
-    for(wchar_t c : wstr)
-    {
-        /*-----------------------------------------------------*\
-        | Forbid anything besides digits and upper case letters |
-        \*-----------------------------------------------------*/
-        bool isUpperCaseLetter = (c >= 64 && c <= 90);
-        bool isDigit           = (c >= 48 && c <= 57);
-        if(!isUpperCaseLetter && !isDigit)
-        {
-            break;
-        }
-
-        result += (char)c;
-    }
-
-    return(result);
+    return(name);
 }

 std::string AuraMouseController::GetSerialString()
@@ -123,6 +105,32 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
    return str;
 }

+std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+{
+    /*---------------------------------------------------------------*\
+    | Cleans garbage at the end of serial numbers                     |
+    | (apparently 2 characters too much, but maybe variable)          |
+    | Limited to new devices, old ones don't even have serial numbers |
+    \*---------------------------------------------------------------*/
+    std::string result;
+    for(wchar_t c : wstr)
+    {
+        /*-----------------------------------------------------*\
+        | Forbid anything besides digits and upper case letters |
+        \*-----------------------------------------------------*/
+        bool isUpperCaseLetter = (c >= 64 && c <= 90);
+        bool isDigit           = (c >= 48 && c <= 57);
+        if(!isUpperCaseLetter && !isDigit)
+        {
+            break;
+        }
+
+        result += (char)c;
+    }
+
+    return(result);
+}
+
 void AuraMouseController::SaveMode()
 {
    unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
@@ -17,40 +17,42 @@
 #include "AsusAuraMouseDevices.h"

 #define ASUS_AURA_MOUSE_PACKET_SIZE 65
-#define HID_MAX_STR 255

 class AuraMouseController
 {
 public:
-    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
+    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
    virtual ~AuraMouseController();

    std::string GetDeviceLocation();
-    std::string CleanSerial(const std::wstring& wstr);
+    std::string GetName();
    std::string GetSerialString();
    std::string GetVersion(bool wireless, int protocol);

-    void SaveMode();
-    void SendUpdate
-        (
-        unsigned char   zone,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        unsigned char   dir,
-        bool            random,
-        unsigned char   speed,
-        unsigned char   brightness
-        );
-    void SendDirect
-        (
-        std::vector<RGBColor>   zone_colors
-        );
+    std::string CleanSerial(const std::wstring& wstr);

-    uint16_t                    device_pid;
+    void        SaveMode();
+    void        SendUpdate
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned char   red,
+                    unsigned char   grn,
+                    unsigned char   blu,
+                    unsigned char   dir,
+                    bool            random,
+                    unsigned char   speed,
+                    unsigned char   brightness
+                    );
+    void        SendDirect
+                    (
+                    std::vector<RGBColor>   zone_colors
+                    );
+
+    uint16_t    device_pid;

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -33,19 +33,19 @@ static std::string aura_mouse_zone_names[5]

 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller                      = controller_ptr;

-    pid = controller->device_pid;
+    pid                             = controller->device_pid;

-    name                    = "ASUS Aura Mouse";
-    vendor                  = "ASUS";
-    type                    = DEVICE_TYPE_MOUSE;
-    description             = "ASUS Aura Mouse Device";
-    version                 = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
-    location                = controller->GetDeviceLocation();
-    serial                  = controller->GetSerialString();
+    name                            = controller->GetName();
+    vendor                          = "ASUS";
+    type                            = DEVICE_TYPE_MOUSE;
+    description                     = "ASUS Aura Mouse Device";
+    version                         = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();

-    std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
+    std::vector<uint8_t> mm         = aura_mouse_devices[pid].mouse_modes;

    if(aura_mouse_devices[pid].direct)
    {
@@ -57,7 +57,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
        modes.push_back(Direct);
    }

-    int mode_value          = 0;
+    int mode_value                  = 0;

    for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
    {
@@ -15,11 +15,12 @@
 #include "AsusAuraMouseGen1Controller.h"
 #include "StringUtils.h"

-AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
+AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
    device_pid  = pid;
+    name        = dev_name;
 }

 AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
@@ -32,6 +33,11 @@ std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AsusAuraMouseGen1Controller::GetName()
+{
+    return(name);
+}
+
 std::string AsusAuraMouseGen1Controller::GetSerialString()
 {
    wchar_t serial_string[HID_MAX_STR];
@@ -21,33 +21,37 @@
 class AsusAuraMouseGen1Controller
 {
 public:
-    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
+    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
    virtual ~AsusAuraMouseGen1Controller();

    std::string GetDeviceLocation();
+    std::string GetName();
    std::string GetSerialString();
    std::string GetVersion();
-    int GetActiveProfile();

-    void SendUpdate
-        (
-        unsigned char   key,
-        unsigned char   value
-        );
+    int         GetActiveProfile();

-    void UpdateProfile
-        (
-        unsigned char   key,
-        unsigned char   profile,
-        unsigned char   value
-        );
-    void SendDirectSpatha(std::vector<RGBColor> colors);
+    void        SendUpdate
+                    (
+                    unsigned char   key,
+                    unsigned char   value
+                    );

-    void ResetToSavedLighting();
+    void        UpdateProfile
+                    (
+                    unsigned char   key,
+                    unsigned char   profile,
+                    unsigned char   value
+                    );

-    uint16_t                    device_pid;
+    void        SendDirectSpatha(std::vector<RGBColor> colors);
+
+    void        ResetToSavedLighting();
+
+    uint16_t    device_pid;

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -30,7 +30,7 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 {
    controller                  = controller_ptr;

-    name                        = "ASUS ROG Spatha";
+    name                        = controller->GetName();
    vendor                      = "ASUS";
    type                        = DEVICE_TYPE_MOUSE;
    description                 = "ASUS Aura Mouse Device";
@@ -26,7 +26,7 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 {
    controller                  = controller_ptr;

-    name                        = "ASUS ROG Strix Evolve";
+    name                        = controller->GetName();
    vendor                      = "ASUS";
    type                        = DEVICE_TYPE_MOUSE;
    description                 = "ASUS Aura Mouse Device";
@@ -13,10 +13,11 @@
 #include "AsusAuraMousematController.h"
 #include "StringUtils.h"

-AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
+AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
 }

 AuraMousematController::~AuraMousematController()
@@ -29,6 +30,11 @@ std::string AuraMousematController::GetDeviceLocation()
    return("HID: " + location);
 }

+std::string AuraMousematController::GetName()
+{
+    return(name);
+}
+
 std::string AuraMousematController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -31,30 +31,32 @@ enum
 class AuraMousematController
 {
 public:
-    AuraMousematController(hid_device* dev_handle, const char* path);
+    AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
    virtual ~AuraMousematController();

    std::string GetDeviceLocation();
+    std::string GetName();
    std::string GetSerialString();
    std::string GetVersion();

-    void UpdateLeds
-        (
-        std::vector<RGBColor>    colors
-        );
+    void        UpdateLeds
+                    (
+                    std::vector<RGBColor>    colors
+                    );

-    void UpdateDevice
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           speed,
-        unsigned char           brightness,
-        unsigned char           pattern
-        );
+    void        UpdateDevice
+                    (
+                    unsigned char           mode,
+                    std::vector<RGBColor>   colors,
+                    unsigned char           speed,
+                    unsigned char           brightness,
+                    unsigned char           pattern
+                    );

-    void SaveMode();
+    void        SaveMode();

 private:
-    hid_device*                 dev;
-    std::string                 location;
+    hid_device* dev;
+    std::string location;
+    std::string name;
 };
@@ -26,7 +26,7 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 {
    controller                  = controller_ptr;

-    name                        = "ASUS Aura Mousemat";
+    name                        = controller->GetName();
    vendor                      = "ASUS";
    type                        = DEVICE_TYPE_MOUSEMAT;
    description                 = "ASUS Aura Mousemat Device";
@@ -12,7 +12,7 @@

 #include "AsusAuraRyuoAIOController.h"

-AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
 {
    /*-----------------------------------------------------*\
    | Add addressable devices                               |
@@ -60,7 +60,7 @@ public:
        SPEED_FASTEST     = 0x00, // Fastest speed
    };

-    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
+    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AsusAuraRyuoAIOController();

    std::string             GetLocation();
@@ -29,7 +29,7 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
    controller                  = controller_ptr;
    uint8_t speed               = controller->SPEED_NORMAL;

-    name                        = "ROG Ryuo AIO";
+    name                        = controller->GetDeviceName();
    vendor                      = "ASUS";
    type                        = DEVICE_TYPE_COOLER;
    description                 = "ASUS Liquid Cooler with 120mm and 240mm radiators.";
@@ -19,10 +19,13 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "StringUtils.h"

-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
+#define HID_MAX_STR 128
+
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;
    device_pid  = pid;
    rev_version = version;

@@ -39,36 +42,34 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string clean_serial(const std::wstring& wstr)
+std::string AuraTUFKeyboardController::GetName()
 {
+    return(name);
+}
+
+std::string AuraTUFKeyboardController::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    memset(serial_string, 0, sizeof(serial_string));
+
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+    if(ret != 0)
+    {
+        return("");
+    }
+
    /*-------------------------------------------------------------------------*\
    | Skip non-ASCII, trailing garbage in serial numbers. Required by the       |
    | Scope II 96, whose original firmware outputs garbage, which even differs  |
    | after computer reboots and therefore breaks OpenRGB profile matching.     |
    \*-------------------------------------------------------------------------*/
-    std::string result;
-    for(wchar_t c : wstr)
+    switch(device_pid)
    {
-        // Forbid control chars and anything above final printable low-ASCII.
-        if(c < 32 || c > 126)
-        {
+        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
+            serial_string[12] = L'\0';
+            break;
+        default:
            break;
-        }
-
-        result += (char)c;
-    }
-
-    return(result);
-}
-
-std::string AuraTUFKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
    }

    return(StringUtils::wstring_to_string(serial_string));
@@ -46,6 +46,7 @@ enum
    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 = 0x19FC,
    AURA_ROG_STRIX_SCOPE_PID                            = 0x18F8,
    AURA_ROG_STRIX_SCOPE_RX_PID                         = 0x1951,
+    AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID                  = 0x1B12,
    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     = 0x19F6,
    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     = 0x19F8,
    AURA_ROG_STRIX_SCOPE_II_PID                         = 0x1AB3,
@@ -66,77 +67,81 @@ struct led_color
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name);
    ~AuraTUFKeyboardController();

    std::string GetDeviceLocation();
+    std::string GetName();
    std::string GetSerialString();
    std::string GetVersion();
+
    int         GetLayout();
    int         GetNumpadLocation();
    void        SaveMode();
    void        AllowRemoteControl(unsigned char type);

-    void UpdateSingleLed
-        (
-        int             led,
-        unsigned char   red,
-        unsigned char   green,
-        unsigned char   blue
-        );
+    void        UpdateSingleLed
+                    (
+                    int             led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );

-    void UpdateLeds
-        (
-        std::vector<led_color>    colors
-        );
+    void        UpdateLeds
+                    (
+                    std::vector<led_color>    colors
+                    );

-    void UpdateK1Wave
-        (
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
+    void        UpdateK1Wave
+                    (
+                    std::vector<RGBColor>   colors,
+                    unsigned char           direction,
+                    unsigned char           speed,
+                    unsigned char           brightness
+                    );

-    void UpdateScopeIIRainbowRipple
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
+    void        UpdateScopeIIRainbowRipple
+                    (
+                    unsigned char           mode,
+                    std::vector<RGBColor>   colors,
+                    unsigned char           direction,
+                    unsigned char           color_mode,
+                    unsigned char           speed,
+                    unsigned char           brightness
+                    );

-    void UpdateScopeIIQuicksand
-        (
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
+    void        UpdateScopeIIQuicksand
+                    (
+                    std::vector<RGBColor>   colors,
+                    unsigned char           direction,
+                    unsigned char           color_mode,
+                    unsigned char           speed,
+                    unsigned char           brightness
+                    );

-    void UpdateDevice
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
-    void UpdateQuicksandColors(std::vector<RGBColor> colors);
-    void UpdateMode(unsigned char mode);
-    void AwaitResponse(int ms);
-    void ClearResponses();
+    void        UpdateDevice
+                    (
+                    unsigned char           mode,
+                    std::vector<RGBColor>   colors,
+                    unsigned char           direction,
+                    unsigned char           color_mode,
+                    unsigned char           speed,
+                    unsigned char           brightness
+                    );

-    uint16_t                    device_pid;
-    bool                        is_per_led_keyboard;
+    void        UpdateQuicksandColors(std::vector<RGBColor> colors);
+    void        UpdateMode(unsigned char mode);
+    void        AwaitResponse(int ms);
+    void        ClearResponses();
+
+    uint16_t    device_pid;
+    bool        is_per_led_keyboard;

 private:
-    hid_device*                 dev;
-    std::string                 location;
-    unsigned short              rev_version;
+    hid_device*     dev;
+    std::string     location;
+    std::string     name;
+    unsigned short  rev_version;
 };

@@ -26,19 +26,19 @@

 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller                          = controller_ptr;

-    pid = controller->device_pid;
+    pid                                 = controller->device_pid;

    if(pid != AURA_ROG_CLAYMORE_PID)
    {
-        name        = "ASUS Aura Keyboard";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
+        name                            = controller->GetName();
+        vendor                          = "ASUS";
+        type                            = DEVICE_TYPE_KEYBOARD;
+        description                     = "ASUS Aura Keyboard Device";
+        version                         = controller->GetVersion();
+        location                        = controller->GetDeviceLocation();
+        serial                          = controller->GetSerialString();

        unsigned char AURA_KEYBOARD_SPEED_MIN     = 0;
        unsigned char AURA_KEYBOARD_SPEED_MAX     = 0;
@@ -51,6 +51,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                AURA_KEYBOARD_SPEED_MAX          = 2;
                AURA_KEYBOARD_SPEED_DEFAULT      = 1;
                break;
+
            case AURA_ROG_STRIX_FLARE_PID:
            case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
            case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
@@ -60,6 +61,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                AURA_KEYBOARD_SPEED_MAX          = 0;
                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                break;
+
            case AURA_ROG_AZOTH_USB_PID:
            case AURA_ROG_AZOTH_2_4_PID:
            case AURA_ROG_FALCHION_WIRED_PID:
@@ -67,6 +69,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
            case AURA_ROG_STRIX_FLARE_II_PID:
            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
            case AURA_ROG_STRIX_SCOPE_RX_PID:
+            case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
            case AURA_ROG_STRIX_SCOPE_PID:
            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
@@ -78,77 +81,83 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                AURA_KEYBOARD_SPEED_MAX          = 0;
                AURA_KEYBOARD_SPEED_DEFAULT      = 30;
                break;
+
            default:
                AURA_KEYBOARD_SPEED_MIN          = 15;
                AURA_KEYBOARD_SPEED_MAX          = 0;
                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
+                break;
        }

        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
+        Direct.name                     = "Direct";
+        Direct.value                    = AURA_KEYBOARD_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                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
+        Static.name                     = "Static";
+        Static.value                    = AURA_KEYBOARD_MODE_STATIC;
+        Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.brightness_min           = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Static.brightness_max           = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Static.brightness               = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+        Static.colors_min               = 1;
+        Static.colors_max               = 1;
        Static.colors.resize(1);
        modes.push_back(Static);

        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
-
-        Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
+        Breathing.name                  = "Breathing";
+        Breathing.value                 = AURA_KEYBOARD_MODE_BREATHING;
+        Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        if(controller->is_per_led_keyboard)
+        {
+            Breathing.flags            |= MODE_FLAG_HAS_RANDOM_COLOR;
+        }
+        Breathing.speed_min             = AURA_KEYBOARD_SPEED_MIN;
+        Breathing.speed_max             = AURA_KEYBOARD_SPEED_MAX;
+        Breathing.speed                 = AURA_KEYBOARD_SPEED_DEFAULT;
+        Breathing.brightness_min        = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Breathing.brightness_max        = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Breathing.brightness            = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.colors_min            = 1;
+        Breathing.colors_max            = 2;
        Breathing.colors.resize(1);
        modes.push_back(Breathing);

        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
+        Color_Cycle.name                = "Spectrum Cycle";
+        Color_Cycle.value               = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+        Color_Cycle.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Color_Cycle.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+        Color_Cycle.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+        Color_Cycle.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+        Color_Cycle.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Color_Cycle.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Color_Cycle.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Color_Cycle.color_mode          = MODE_COLORS_NONE;
        modes.push_back(Color_Cycle);

        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
-
-        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+        Wave.name                       = "Rainbow Wave";
+        Wave.value                      = AURA_KEYBOARD_MODE_WAVE;
+        Wave.flags                      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        if(controller->is_per_led_keyboard)
+        {
+            Wave.flags                 |= MODE_FLAG_HAS_DIRECTION_UD;
+        }
+        Wave.speed_min                  = AURA_KEYBOARD_SPEED_MIN;
+        Wave.speed_max                  = AURA_KEYBOARD_SPEED_MAX;
+        Wave.speed                      = AURA_KEYBOARD_SPEED_DEFAULT;
+        Wave.brightness_min             = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Wave.brightness_max             = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Wave.brightness                 = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Wave.direction                  = MODE_DIRECTION_LEFT;
+        Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;

        if(!controller->is_per_led_keyboard)
        {
@@ -267,129 +276,129 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
    else
    {

-        name        = "ASUS ROG Claymore";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
+        name                            = controller->GetName();
+        vendor                          = "ASUS";
+        type                            = DEVICE_TYPE_KEYBOARD;
+        description                     = "ASUS Aura Keyboard Device";
+        version                         = controller->GetVersion();
+        location                        = controller->GetDeviceLocation();
+        serial                          = controller->GetSerialString();

        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
+        Direct.name                     = "Direct";
+        Direct.value                    = AURA_KEYBOARD_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                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
+        Static.name                     = "Static";
+        Static.value                    = AURA_KEYBOARD_MODE_STATIC;
+        Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+        Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+        Static.colors_min               = 1;
+        Static.colors_max               = 1;
        Static.colors.resize(1);
        modes.push_back(Static);

        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Breathing.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Breathing.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Breathing.speed             = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
+        Breathing.name                  = "Breathing";
+        Breathing.value                 = AURA_KEYBOARD_MODE_BREATHING;
+        Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Breathing.speed_min             = AURA_CLAYMORE_SPEED_MIN;
+        Breathing.speed_max             = AURA_CLAYMORE_SPEED_MAX;
+        Breathing.speed                 = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
+        Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.colors_min            = 1;
+        Breathing.colors_max            = 2;
        Breathing.colors.resize(2);
        modes.push_back(Breathing);

        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Cycle.speed_min       = AURA_CLAYMORE_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_CLAYMORE_SPEED_MAX;
-        Color_Cycle.speed           = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
+        Color_Cycle.name                = "Spectrum Cycle";
+        Color_Cycle.value               = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+        Color_Cycle.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Color_Cycle.speed_min           = AURA_CLAYMORE_SPEED_MIN;
+        Color_Cycle.speed_max           = AURA_CLAYMORE_SPEED_MAX;
+        Color_Cycle.speed               = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
+        Color_Cycle.color_mode          = MODE_COLORS_NONE;
        modes.push_back(Color_Cycle);

        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Reactive.speed_min          = AURA_CLAYMORE_SPEED_MIN;
-        Reactive.speed_max          = AURA_CLAYMORE_SPEED_MAX;
-        Reactive.speed              = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
+        Reactive.name                   = "Reactive";
+        Reactive.value                  = AURA_KEYBOARD_MODE_REACTIVE;
+        Reactive.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Reactive.speed_min              = AURA_CLAYMORE_SPEED_MIN;
+        Reactive.speed_max              = AURA_CLAYMORE_SPEED_MAX;
+        Reactive.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
+        Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+        Reactive.colors_min             = 1;
+        Reactive.colors_max             = 2;
        Reactive.colors.resize(2);
        modes.push_back(Reactive);

        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Wave.speed_min              = AURA_CLAYMORE_SPEED_MIN;
-        Wave.speed_max              = AURA_CLAYMORE_SPEED_MAX;
-        Wave.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_NONE;
+        Wave.name                       = "Rainbow Wave";
+        Wave.value                      = AURA_KEYBOARD_MODE_WAVE;
+        Wave.flags                      = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+        Wave.speed_min                  = AURA_CLAYMORE_SPEED_MIN;
+        Wave.speed_max                  = AURA_CLAYMORE_SPEED_MAX;
+        Wave.speed                      = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
+        Wave.direction                  = MODE_DIRECTION_LEFT;
+        Wave.color_mode                 = MODE_COLORS_NONE;
        modes.push_back(Wave);

        mode Color_Wave;
-        Color_Wave.name             = "Color Wave";
-        Color_Wave.value            = AURA_KEYBOARD_MODE_WAVE;
-        Color_Wave.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Wave.speed_min        = AURA_CLAYMORE_SPEED_MIN;
-        Color_Wave.speed_max        = AURA_CLAYMORE_SPEED_MAX;
-        Color_Wave.speed            = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Color_Wave.direction        = MODE_DIRECTION_LEFT;
-        Color_Wave.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Color_Wave.colors_min       = 1;
-        Color_Wave.colors_max       = 2;
+        Color_Wave.name                 = "Color Wave";
+        Color_Wave.value                = AURA_KEYBOARD_MODE_WAVE;
+        Color_Wave.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+        Color_Wave.speed_min            = AURA_CLAYMORE_SPEED_MIN;
+        Color_Wave.speed_max            = AURA_CLAYMORE_SPEED_MAX;
+        Color_Wave.speed                = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
+        Color_Wave.direction            = MODE_DIRECTION_LEFT;
+        Color_Wave.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Color_Wave.colors_min           = 1;
+        Color_Wave.colors_max           = 2;
        Color_Wave.colors.resize(2);
        modes.push_back(Color_Wave);

        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Ripple.speed_min            = AURA_CLAYMORE_SPEED_MIN;
-        Ripple.speed_max            = AURA_CLAYMORE_SPEED_MAX;
-        Ripple.speed                = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 2;
+        Ripple.name                     = "Ripple";
+        Ripple.value                    = AURA_KEYBOARD_MODE_RIPPLE;
+        Ripple.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Ripple.speed_min                = AURA_CLAYMORE_SPEED_MIN;
+        Ripple.speed_max                = AURA_CLAYMORE_SPEED_MAX;
+        Ripple.speed                    = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
+        Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+        Ripple.colors_min               = 1;
+        Ripple.colors_max               = 2;
        Ripple.colors.resize(2);
        modes.push_back(Ripple);

        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Starry_Night.speed_min      = AURA_CLAYMORE_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_CLAYMORE_SPEED_MAX;
-        Starry_Night.speed          = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 2;
+        Starry_Night.name               = "Starry Night";
+        Starry_Night.value              = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+        Starry_Night.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Starry_Night.speed_min          = AURA_CLAYMORE_SPEED_MIN;
+        Starry_Night.speed_max          = AURA_CLAYMORE_SPEED_MAX;
+        Starry_Night.speed              = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
+        Starry_Night.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+        Starry_Night.colors_min         = 1;
+        Starry_Night.colors_max         = 2;
        Starry_Night.colors.resize(2);
        modes.push_back(Starry_Night);

        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Quicksand.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Quicksand.speed             = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
+        Quicksand.name                  = "Quicksand";
+        Quicksand.value                 = AURA_KEYBOARD_MODE_QUICKSAND;
+        Quicksand.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Quicksand.direction             = MODE_DIRECTION_DOWN;
+        Quicksand.speed_min             = AURA_CLAYMORE_SPEED_MIN;
+        Quicksand.speed_max             = AURA_CLAYMORE_SPEED_MAX;
+        Quicksand.speed                 = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
+        Quicksand.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Quicksand.colors_min            = 6;
+        Quicksand.colors_max            = 6;
        Quicksand.colors.resize(6);
        modes.push_back(Quicksand);
    }
@@ -419,6 +428,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
            break;
        case AURA_ROG_STRIX_SCOPE_PID:
        case AURA_ROG_STRIX_SCOPE_RX_PID:
+        case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
            keyboard_ptr = &AsusROGStrixScopeLayouts;
@@ -12,7 +12,7 @@
 #include <cstring>
 #include "AsusAuraAddressableController.h"

-AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
 {
    /*-----------------------------------------------------*\
    | Add addressable devices                               |
@@ -24,7 +24,7 @@ enum
 class AuraAddressableController : public AuraUSBController
 {
 public:
-    AuraAddressableController(hid_device* dev_handle, const char* path);
+    AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AuraAddressableController();

    void SetChannelLEDs
@@ -12,7 +12,7 @@
 #include <cstring>
 #include "AsusAuraMainboardController.h"

-AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
+AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name), mode(AURA_MODE_DIRECT)
 {
    unsigned char num_total_mainboard_leds  = config_table[0x1B];
    unsigned char num_rgb_headers           = config_table[0x1D];
@@ -26,7 +26,7 @@ enum
 class AuraMainboardController : public AuraUSBController
 {
 public:
-    AuraMainboardController(hid_device* dev_handle, const char* path);
+    AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name);
    ~AuraMainboardController();

    void SetChannelLEDs
@@ -14,10 +14,11 @@
 #include "LogManager.h"
 #include "StringUtils.h"

-AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
+AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
    dev         = dev_handle;
    location    = path;
+    name        = dev_name;

    GetFirmwareVersion();
    GetConfigTable();
@@ -40,7 +41,7 @@ std::string AuraUSBController::GetDeviceLocation()

 std::string AuraUSBController::GetDeviceName()
 {
-    return(device_name);
+    return(name);
 }

 std::string AuraUSBController::GetSerialString()
@@ -56,6 +57,11 @@ std::string AuraUSBController::GetSerialString()
    return(StringUtils::wstring_to_string(serial_string));
 }

+std::string AuraUSBController::GetDeviceVersion()
+{
+    return(std::string(version));
+}
+
 const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
 {
    return(device_info);
@@ -89,11 +95,11 @@ void AuraUSBController::GetConfigTable()
    {
        memcpy(config_table, &usb_buf[4], 60);

-        LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name);
+        LOG_DEBUG("[%s] ASUS Aura USB config table:", version);

        for(int i = 0; i < 60; i+=6)
        {
-            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name,
+            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", version,
                                                            config_table[i + 0],
                                                            config_table[i + 1],
                                                            config_table[i + 2],
@@ -104,7 +110,7 @@ void AuraUSBController::GetConfigTable()
    }
    else
    {
-        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
+        LOG_INFO("[%s] Could not read config table, can not add device", version);
        delete this;
    }
 }
@@ -135,7 +141,7 @@ void AuraUSBController::GetFirmwareVersion()
    \*-----------------------------------------------------*/
    if(usb_buf[1] == 0x02)
    {
-        memcpy(device_name, &usb_buf[2], 16);
+        memcpy(version, &usb_buf[2], 16);
    }
 }

@@ -54,17 +54,17 @@ enum class AuraDeviceType

 struct AuraDeviceInfo
 {
-    unsigned char effect_channel;
-    unsigned char direct_channel;
-    unsigned char num_leds;
-    unsigned char num_headers;
-    AuraDeviceType device_type;
+    unsigned char   effect_channel;
+    unsigned char   direct_channel;
+    unsigned char   num_leds;
+    unsigned char   num_headers;
+    AuraDeviceType  device_type;
 };

 class AuraUSBController
 {
 public:
-    AuraUSBController(hid_device* dev_handle, const char* path);
+    AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name);
    virtual ~AuraUSBController();

    unsigned int GetChannelCount();
@@ -72,6 +72,7 @@ public:
    std::string GetDeviceLocation();
    std::string GetDeviceName();
    std::string GetSerialString();
+    std::string GetDeviceVersion();

    const std::vector<AuraDeviceInfo>& GetAuraDevices() const;

@@ -96,6 +97,8 @@ protected:
    unsigned char               config_table[60];
    std::vector<AuraDeviceInfo> device_info;
    std::string                 location;
+    std::string                 name;
+    char                        version[16];

    void SendDirect
        (
@@ -103,10 +106,8 @@ protected:
        unsigned char   led_count,
        RGBColor *      colors
        );
+
 private:
-    char                        device_name[16];
-
    void GetConfigTable();
-
    void GetFirmwareVersion();
 };
@@ -26,7 +26,6 @@
 RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
    RGBController_AuraUSB(controller_ptr)
 {
-    name        = "ASUS Aura USB Mainboard";
    description = "ASUS Aura USB Mainboard Device";

    /*-------------------------------------------------------*\
@@ -26,91 +26,91 @@
 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
    initializedMode(false)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;

-    name        = "ASUS Aura USB";
-    vendor      = "ASUS";
-    version     = controller->GetDeviceName();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASUS Aura USB Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                        = controller->GetDeviceName();
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    description                 = "ASUS Aura USB Device";
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+    version                     = controller->GetDeviceVersion();

    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
+    Off.name                    = "Off";
+    Off.value                   = AURA_MODE_OFF;
+    Off.flags                   = 0;
+    Off.color_mode              = MODE_COLORS_NONE;
    modes.push_back(Off);

    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.name                 = "Static";
+    Static.value                = AURA_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
    Static.colors.resize(1);
    modes.push_back(Static);

    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
    Breathing.colors.resize(1);
    modes.push_back(Breathing);

    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flashing.colors_min = 1;
-    Flashing.colors_max = 1;
-    Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.name               = "Flashing";
+    Flashing.value              = AURA_MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
    Flashing.colors.resize(1);
    modes.push_back(Flashing);

    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = 0;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
    modes.push_back(SpectrumCycle);

    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = AURA_MODE_RAINBOW;
+    Rainbow.flags               = 0;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
    modes.push_back(Rainbow);

    mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    ChaseFade.colors_min = 1;
-    ChaseFade.colors_max = 1;
-    ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ChaseFade.name              = "Chase Fade";
+    ChaseFade.value             = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    ChaseFade.colors_min        = 1;
+    ChaseFade.colors_max        = 1;
+    ChaseFade.color_mode        = MODE_COLORS_MODE_SPECIFIC;
    ChaseFade.colors.resize(1);
    modes.push_back(ChaseFade);

    mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AURA_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Chase.colors_min = 1;
-    Chase.colors_max = 1;
-    Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Chase.name                  = "Chase";
+    Chase.value                 = AURA_MODE_CHASE;
+    Chase.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Chase.colors_min            = 1;
+    Chase.colors_max            = 1;
+    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
    Chase.colors.resize(1);
    modes.push_back(Chase);

--- a/Show More
+++ b/Show More