Cleanup

Update Spanish translation

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: https://www.paypal.com/donate/?hosted_button_id=4HMSHS4EBQWTA

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: |
+          7.0.x
+    - name: Build
+      run: |
+        dotnet build app/GHelper.sln

.github/workflows/codeql.yml

@@ -0,0 +1,28 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  schedule:
+  - cron: '34 18 * * 3'
+
+permissions:
+  actions: read
+  contents: read
+  security-events: write
+
+jobs:
+  codeql:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: c#
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+    - name: Analyze
+      uses: github/codeql-action/analyze@v2

.github/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Release
+
+on:
+  release:
+    types: [ published ]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: |
+          7.0.x
+    - name: Publish
+      run: |
+        dotnet publish app/GHelper.sln --configuration Release --runtime win-x64 -p:PublishSingleFile=true --no-self-contained
+        powershell Compress-Archive app/bin/x64/Release/net7.0-windows8.0/win-x64/publish/* GHelper.zip
+    - name: Upload
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        gh release upload ${{ github.ref_name }} GHelper.zip

app/AnimeMatrix/AniMatrix.cs

@@ -0,0 +1,312 @@
+using NAudio.CoreAudioApi;
+using NAudio.Wave;
+using Starlight.AnimeMatrix;
+using System.Diagnostics;
+using System.Drawing.Imaging;
+using System.Timers;
+
+namespace GHelper.AnimeMatrix
+{
+
+    public class AniMatrix
+    {
+        System.Timers.Timer matrixTimer = default!;
+        AnimeMatrixDevice mat;
+
+        double[] AudioValues;
+        WasapiCapture AudioDevice;
+
+        public bool IsValid => mat != null;
+
+        private long lastPresent;
+        private List<double> maxes = new List<double>();
+
+        public AniMatrix()
+        {
+            try
+            {
+                mat = new AnimeMatrixDevice();
+                Task.Run(mat.WakeUp);
+                matrixTimer = new System.Timers.Timer(100);
+                matrixTimer.Elapsed += MatrixTimer_Elapsed;
+            }
+            catch
+            {
+                mat = null;
+            }
+
+        }
+
+        public void SetMatrix()
+        {
+
+            if (!IsValid) return;
+
+            int brightness = AppConfig.Get("matrix_brightness");
+            int running = AppConfig.Get("matrix_running");
+
+            bool auto = AppConfig.Is("matrix_auto");
+
+            if (brightness < 0) brightness = 0;
+            if (running < 0) running = 0;
+
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                BuiltInAnimation.Sleeping.Starfield,
+                BuiltInAnimation.Shutdown.SeeYa,
+                BuiltInAnimation.Startup.StaticEmergence
+            );
+
+            StopMatrixTimer();
+            StopMatrixAudio();
+
+            mat.SetProvider();
+
+            if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
+            {
+                mat.SetDisplayState(false);
+                Logger.WriteLine("Matrix Off");
+            }
+            else
+            {
+                mat.SetDisplayState(true);
+                mat.SetBrightness((BrightnessMode)brightness);
+
+                switch (running)
+                {
+                    case 2:
+                        SetMatrixPicture(AppConfig.GetString("matrix_picture"));
+                        break;
+                    case 3:
+                        SetMatrixClock();
+                        break;
+                    case 4:
+                        SetMatrixAudio();
+                        break;
+                    default:
+                        mat.SetBuiltInAnimation(true, animation);
+                        Logger.WriteLine("Matrix builtin " + animation.AsByte);
+                        break;
+
+                }
+
+                //mat.SetBrightness((BrightnessMode)brightness);
+            }
+
+        }
+        private void StartMatrixTimer(int interval = 100)
+        {
+            matrixTimer.Interval = interval;
+            matrixTimer.Start();
+        }
+
+        private void StopMatrixTimer()
+        {
+            matrixTimer.Stop();
+        }
+
+
+        private void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
+        {
+            //if (!IsValid) return;
+
+            switch (AppConfig.Get("matrix_running"))
+            {
+                case 2:
+                    mat.PresentNextFrame();
+                    break;
+                case 3:
+                    mat.PresentClock();
+                    break;
+            }
+
+        }
+
+
+        public void SetMatrixClock()
+        {
+            mat.SetBuiltInAnimation(false);
+            StartMatrixTimer(1000);
+            Logger.WriteLine("Matrix Clock");
+        }
+
+        public void Dispose()
+        {
+            StopMatrixAudio();
+        }
+
+        void StopMatrixAudio()
+        {
+            if (AudioDevice is not null)
+            {
+                try
+                {
+                    AudioDevice.StopRecording();
+                    AudioDevice.Dispose();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+            }
+        }
+
+        void SetMatrixAudio()
+        {
+            if (!IsValid) return;
+
+            mat.SetBuiltInAnimation(false);
+            StopMatrixTimer();
+            StopMatrixAudio();
+
+            try
+            {
+                using (var enumerator = new MMDeviceEnumerator())
+                using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
+                {
+                    AudioDevice = new WasapiLoopbackCapture(device);
+                    WaveFormat fmt = AudioDevice.WaveFormat;
+
+                    AudioValues = new double[fmt.SampleRate / 1000];
+                    AudioDevice.DataAvailable += WaveIn_DataAvailable;
+                    AudioDevice.StartRecording();
+                    Logger.WriteLine("Matrix Audio");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+
+        }
+
+        private void WaveIn_DataAvailable(object? sender, WaveInEventArgs e)
+        {
+            int bytesPerSamplePerChannel = AudioDevice.WaveFormat.BitsPerSample / 8;
+            int bytesPerSample = bytesPerSamplePerChannel * AudioDevice.WaveFormat.Channels;
+            int bufferSampleCount = e.Buffer.Length / bytesPerSample;
+
+            if (bufferSampleCount >= AudioValues.Length)
+            {
+                bufferSampleCount = AudioValues.Length;
+            }
+
+            if (bytesPerSamplePerChannel == 2 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToInt16(e.Buffer, i * bytesPerSample);
+            }
+            else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToInt32(e.Buffer, i * bytesPerSample);
+            }
+            else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToSingle(e.Buffer, i * bytesPerSample);
+            }
+
+            double[] paddedAudio = FftSharp.Pad.ZeroPad(AudioValues);
+            double[] fftMag = FftSharp.Transform.FFTmagnitude(paddedAudio);
+
+            PresentAudio(fftMag);
+        }
+
+        private void DrawBar(int pos, double h)
+        {
+            int dx = pos * 2;
+            int dy = 20;
+
+            byte color;
+
+            for (int y = 0; y < h - (h % 2); y++)
+                for (int x = 0; x < 2 - (y % 2); x++)
+                {
+                    //color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
+                    mat.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
+                    mat.SetLedPlanar(x + dx, dy - y, 255);
+                }
+        }
+
+        void PresentAudio(double[] audio)
+        {
+
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
+            lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
+            mat.Clear();
+
+            int size = 20;
+            double[] bars = new double[size];
+            double max = 2, maxAverage;
+
+            for (int i = 0; i < size; i++)
+            {
+                bars[i] = Math.Sqrt(audio[i] * 10000);
+                if (bars[i] > max) max = bars[i];
+            }
+
+            maxes.Add(max);
+            if (maxes.Count > 20) maxes.RemoveAt(0);
+            maxAverage = maxes.Average();
+
+            for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i]*20/maxAverage);
+
+            mat.Present();
+        }
+
+
+        public void SetMatrixPicture(string fileName)
+        {
+
+            if (!IsValid) return;
+            StopMatrixTimer();
+
+            Image image;
+
+            try
+            {
+                using (var fs = new FileStream(fileName, FileMode.Open))
+                {
+                    var ms = new MemoryStream();
+                    fs.CopyTo(ms);
+                    ms.Position = 0;
+                    image = Image.FromStream(ms);
+                }
+            }
+            catch
+            {
+                Debug.WriteLine("Error loading picture");
+                return;
+            }
+
+            mat.SetBuiltInAnimation(false);
+            mat.ClearFrames();
+
+            FrameDimension dimension = new FrameDimension(image.FrameDimensionsList[0]);
+            int frameCount = image.GetFrameCount(dimension);
+
+            if (frameCount > 1)
+            {
+                for (int i = 0; i < frameCount; i++)
+                {
+                    image.SelectActiveFrame(dimension, i);
+                    mat.GenerateFrame(image);
+                    mat.AddFrame();
+                }
+
+                StartMatrixTimer();
+                Logger.WriteLine("Matrix GIF " + fileName);
+            }
+            else
+            {
+                mat.GenerateFrame(image);
+                mat.Present();
+                Logger.WriteLine("Matrix " + fileName);
+            }
+        }
+
+
+    }
+}

app/AnimeMatrix/AnimeMatrixDevice.cs

@@ -1,11 +1,11 @@
 // Source thanks to https://github.com/vddCore/Starlight with some adjustments from me
 
 using Starlight.Communication;
-using System.Management;
 using System.Drawing.Drawing2D;
-using System.Text;
+using System.Drawing.Text;
 using System.Globalization;
-using System;
+using System.Management;
+using System.Text;
 
 namespace Starlight.AnimeMatrix
 {
@@ -62,7 +62,8 @@ namespace Starlight.AnimeMatrix
     public enum AnimeType
     {
         GA401,
-        GA402
+        GA402,
+        GU604
     }
 
 
@@ -89,12 +90,15 @@ namespace Starlight.AnimeMatrix
         //public int FullEvenRows = -1;
 
         public int dx = 0;
+        //Shifts the whole frame to the left or right to align with the diagonal cut
+        public int frameShiftX = 0;
         public int MaxColumns = 34;
 
         private int frameIndex = 0;
 
         private static AnimeType _model = AnimeType.GA402;
 
+
         public AnimeMatrixDevice()
             : base(0x0B05, 0x193B, 640)
         {
@@ -107,15 +111,22 @@ namespace Starlight.AnimeMatrix
                 MaxColumns = 33;
                 dx = 1;
 
-                //FullRows = 7;
-                //FullEvenRows = 3;
-
                 MaxRows = 55;
                 LedCount = 1245;
 
                 UpdatePageLength = 410;
             }
 
+            if (model.Contains("GU604"))
+            {
+                _model = AnimeType.GU604;
+
+                MaxColumns = 39;
+                MaxRows = 92;
+                LedCount = 1711;
+                frameShiftX = -5;
+                UpdatePageLength = 630;
+            }
 
             _displayBuffer = new byte[LedCount];
 
@@ -177,17 +188,11 @@ namespace Starlight.AnimeMatrix
                     {
                         return (y + 1) / 2 - 3;
                     }
-                case AnimeType.GA402:
-                    if (y < 11)
-                    {
-                        return 0;
-                    }
-                    else
-                    {
-                        return (y) / 2 - 5;
-                    }
+                case AnimeType.GU604:
+                    return (int)Math.Ceiling(Math.Max(0, y - 9) / 2F);
+
                 default:
-                    throw new ArgumentException("Invalid anime type", nameof(_model));
+                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
             }
         }
 
@@ -197,10 +202,10 @@ namespace Starlight.AnimeMatrix
             {
                 case AnimeType.GA401:
                     return 33;
-                case AnimeType.GA402:
-                    return 34;
+                case AnimeType.GU604:
+                    return 39;
                 default:
-                    throw new ArgumentException("Invalid anime type", nameof(_model));
+                    return 34;
             }
         }
 
@@ -221,36 +226,15 @@ namespace Starlight.AnimeMatrix
                         default:
                             return 36 - y / 2;
                     }
-                case AnimeType.GA402:
-                    return Width(y) - FirstX(y);
                 default:
-                    throw new ArgumentException("Invalid anime type", nameof(_model));
+                    return Width(y) - FirstX(y);
             }
         }
 
-        /*
-        public int XStart(int row)
-        {
-            return (int)Math.Ceiling(Math.Max(0, row - FullRows) / 2.0);
-        }
-
-        public int XEnd(int row)
-        {
-            if (row <= FullEvenRows)
-            {
-                if (row % 2 == 1) return MaxColumns + 2;
-                else return MaxColumns;
-            }
-            return MaxColumns;
-        }
-        */
 
         public int RowToLinearAddress(int y)
         {
-            EnsureRowInRange(y);
-
             int ret = 0;
-
             for (var i = 0; i < y; i++)
                 ret += Pitch(i);
 
@@ -259,13 +243,10 @@ namespace Starlight.AnimeMatrix
 
         public void SetLedPlanar(int x, int y, byte value)
         {
-            EnsureRowInRange(y);
+            if (!IsRowInRange(y)) return;
 
             if (x >= FirstX(y) && x < Width(y))
-            {
-                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x + dx, value);
-                //Debug.Write((RowToLinearAddress(y) - FirstX(y) + x + dx).ToString() + " ");
-            }
+                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x + dx + frameShiftX, value);
         }
 
         public void WakeUp()
@@ -364,13 +345,21 @@ namespace Starlight.AnimeMatrix
         public void PresentClock()
         {
             int second = DateTime.Now.Second;
+            string time;
 
             if (CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern.Contains("H"))
-                PresentText(DateTime.Now.ToString("H" + ((second % 2 == 0)?":":" ") + "mm"));
+                time = DateTime.Now.ToString("H" + ((second % 2 == 0) ? ":" : " ") + "mm");
             else
-                PresentText(DateTime.Now.ToString("h" + ((second % 2 == 0) ? ":" : " ") + "mm"), DateTime.Now.ToString("tt"));
+                time = DateTime.Now.ToString("h" + ((second % 2 == 0) ? ":" : " ") + "mmtt");
+
+            if (_model == AnimeType.GA401)
+                PresentText(time);
+            else
+                PresentTextDiagonal(time);
         }
 
+
+
         public void PresentText(string text1, string text2 = "")
         {
             using (Bitmap bmp = new Bitmap(MaxColumns * 3, MaxRows))
@@ -380,17 +369,17 @@ namespace Starlight.AnimeMatrix
                     g.CompositingQuality = CompositingQuality.HighQuality;
                     g.SmoothingMode = SmoothingMode.AntiAlias;
 
-                    using (Font font = new Font("Arial", 24F, GraphicsUnit.Pixel))
+                    using (Font font = new Font("Consolas", 21F, FontStyle.Regular, GraphicsUnit.Pixel))
                     {
                         SizeF textSize = g.MeasureString(text1, font);
-                        g.DrawString(text1, font, Brushes.White, (MaxColumns*3 - textSize.Width)+3, -3);
+                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
                     }
 
                     if (text2.Length > 0)
-                        using (Font font = new Font("Arial", 18F, GraphicsUnit.Pixel))
+                        using (Font font = new Font("Consolas", 18F, GraphicsUnit.Pixel))
                         {
                             SizeF textSize = g.MeasureString(text2, font);
-                            g.DrawString(text2, font, Brushes.White, (MaxColumns * 3 - textSize.Width)+1, 25);
+                            g.DrawString(text2, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 1, 25);
                         }
 
                 }
@@ -404,7 +393,7 @@ namespace Starlight.AnimeMatrix
         public void GenerateFrame(Image image, InterpolationMode interpolation = InterpolationMode.High)
         {
 
-            int width = MaxColumns/2 * 6;
+            int width = MaxColumns / 2 * 6;
             int height = MaxRows;
 
             int targetWidth = MaxColumns * 2;
@@ -431,7 +420,7 @@ namespace Starlight.AnimeMatrix
                 for (int y = 0; y < bmp.Height; y++)
                 {
                     for (int x = 0; x < bmp.Width; x++)
-                        if (x % 2 == (y+dx) % 2)
+                        if (x % 2 == (y + dx) % 2)
                         {
                             var pixel = bmp.GetPixel(x, y);
                             var color = (pixel.R + pixel.G + pixel.B) / 3;
@@ -442,12 +431,73 @@ namespace Starlight.AnimeMatrix
             }
         }
 
-        private void EnsureRowInRange(int row)
+
+        public void SetLedDiagonal(int x, int y, byte color, int delta = 10)
         {
-            if (row < 0 || row >= MaxRows)
+            //x+=delta;
+            y -= delta;
+
+            int dx = (x - y) / 2;
+            int dy = x + y;
+            SetLedPlanar(dx, dy, color);
+        }
+
+        public void PresentTextDiagonal(string text)
+        {
+
+            Clear();
+
+
+            InstalledFontCollection installedFontCollection = new InstalledFontCollection();
+
+
+            string familyName;
+            string familyList = "";
+            FontFamily[] fontFamilies;
+            // Get the array of FontFamily objects.
+            fontFamilies = installedFontCollection.Families;
+
+            int count = fontFamilies.Length;
+            for (int j = 0; j < count; ++j)
             {
-                throw new IndexOutOfRangeException($"Y-coordinate should fall in range of [0, {MaxRows - 1}].");
+                familyName = fontFamilies[j].Name;
+                familyList = familyList + familyName;
+                familyList = familyList + ",  ";
             }
+
+            int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
+
+            using (Bitmap bmp = new Bitmap(maxX, MaxRows))
+            {
+                using (Graphics g = Graphics.FromImage(bmp))
+                {
+                    g.CompositingQuality = CompositingQuality.HighQuality;
+                    g.SmoothingMode = SmoothingMode.AntiAlias;
+
+                    using (Font font = new Font("Consolas", 13F, FontStyle.Regular, GraphicsUnit.Pixel))
+                    {
+                        SizeF textSize = g.MeasureString(text, font);
+                        g.DrawString(text, font, Brushes.White, 4, 1);
+                    }
+                }
+
+                for (int y = 0; y < bmp.Height; y++)
+                {
+                    for (int x = 0; x < bmp.Width; x++)
+                    {
+                        var pixel = bmp.GetPixel(x, y);
+                        var color = (pixel.R + pixel.G + pixel.B) / 3;
+                        SetLedDiagonal(x, y, (byte)color);
+                    }
+                }
+            }
+
+            Present();
+        }
+
+        private bool IsRowInRange(int row)
+        {
+            return (row >= 0 && row < MaxRows);
         }
 
         private bool IsAddressableLed(int address)

app/AppConfig.cs

@@ -1,22 +1,31 @@
-using System.Diagnostics;
+using GHelper.Mode;
+using System.Diagnostics;
 using System.Management;
 using System.Text.Json;
 
-public class AppConfig
+public static class AppConfig
 {
 
-    public string appPath;
-    string configFile;
+    private static string configFile;
+    private static string? _model;
 
-    string _model;
+    private static Dictionary<string, object> config = new Dictionary<string, object>();
 
-    public Dictionary<string, object> config = new Dictionary<string, object>();
-
-    public AppConfig()
+    static AppConfig()
     {
 
-        appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
-        configFile = appPath + "\\config.json";
+        string startupPath = Application.StartupPath.Trim('\\');
+        string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        string configName = "\\config.json";
+
+        if (File.Exists(startupPath + configName))
+        {
+            configFile = startupPath + configName;
+        } else
+        {
+            configFile = appPath + configName;
+        }
+
 
         if (!System.IO.Directory.Exists(appPath))
             System.IO.Directory.CreateDirectory(appPath);
@@ -30,18 +39,19 @@ public class AppConfig
             }
             catch
             {
-                initConfig();
+                Logger.WriteLine("Broken config: " + text);
+                Init();
             }
         }
         else
         {
-            initConfig();
+            Init();
         }
 
     }
 
 
-    public string GetModel()
+    public static string GetModel()
     {
         if (_model is null)
         {
@@ -58,14 +68,15 @@ public class AppConfig
 
         return _model;
     }
-    public bool ContainsModel(string contains)
+    public static bool ContainsModel(string contains)
     {
 
         GetModel();
-        return (_model is not null && _model.Contains(contains));
-
+        return (_model is not null && _model.ToLower().Contains(contains.ToLower()));
     }
-    private void initConfig()
+
+
+    private static void Init()
     {
         config = new Dictionary<string, object>();
         config["performance_mode"] = 0;
@@ -73,37 +84,27 @@ public class AppConfig
         File.WriteAllText(configFile, jsonString);
     }
 
-    public int getConfig(string name, bool performance = false)
+    public static int Get(string name, int empty = -1)
     {
-
         if (config.ContainsKey(name))
             return int.Parse(config[name].ToString());
-        else return -1;
+        else return empty;
     }
 
-    public string getConfigString(string name)
+    public static bool Is(string name)
+    {
+        return Get(name) == 1;
+    }
+
+    public static string GetString(string name, string empty = null)
     {
         if (config.ContainsKey(name))
             return config[name].ToString();
-        else return null;
+        else return empty;
     }
 
-    public void setConfig(string name, int value)
+    private static void Write()
     {
-        config[name] = value;
-        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
-        try
-        {
-            File.WriteAllText(configFile, jsonString);
-        } catch (Exception e)
-        {
-            Debug.Write(e.ToString());
-        }
-    }
-
-    public void setConfig(string name, string value)
-    {
-        config[name] = value;
         string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
         try
         {
@@ -115,24 +116,51 @@ public class AppConfig
         }
     }
 
-    public string getParamName(int device, string paramName = "fan_profile")
+    public static void Set(string name, int value)
     {
-        int mode = getConfig("performance_mode");
+        config[name] = value;
+        Write();
+    }
+
+    public static void Set(string name, string value)
+    {
+        config[name] = value;
+        Write();
+    }
+    public static void Remove(string name)
+    {
+        config.Remove(name);
+        Write();
+    }
+
+    public static string GgetParamName(AsusFan device, string paramName = "fan_profile")
+    {
+        int mode = Modes.GetCurrent();
         string name;
 
-        if (device == 1)
-            name = "gpu";
-        else if (device == 2)
-            name = "mid";
-        else
-            name = "cpu";
+        switch (device)
+        {
+            case AsusFan.GPU:
+                name = "gpu";
+                break;
+            case AsusFan.Mid:
+                name = "mid";
+                break;
+            case AsusFan.XGM:
+                name = "xgm";
+                break;
+            default:
+                name = "cpu";
+                break;
+
+        }
 
         return paramName + "_" + name + "_" + mode;
     }
 
-    public byte[] getFanConfig(int device)
+    public static byte[] GetFanConfig(AsusFan device)
     {
-        string curveString = getConfigString(getParamName(device));
+        string curveString = GetString(GgetParamName(device));
         byte[] curve = { };
 
         if (curveString is not null)
@@ -141,10 +169,10 @@ public class AppConfig
         return curve;
     }
 
-    public void setFanConfig(int device, byte[] curve)
+    public static void SetFanConfig(AsusFan device, byte[] curve)
     {
         string bitCurve = BitConverter.ToString(curve);
-        setConfig(getParamName(device), bitCurve);
+        Set(GgetParamName(device), bitCurve);
     }
 
 
@@ -156,27 +184,27 @@ public class AppConfig
         return array;
     }
 
-    public byte[] getDefaultCurve(int device)
+    public static byte[] GetDefaultCurve(AsusFan device)
     {
-        int mode = getConfig("performance_mode");
+        int mode = Modes.GetCurrentBase();
         byte[] curve;
 
         switch (mode)
         {
             case 1:
-                if (device == 1)
+                if (device == AsusFan.GPU)
                     curve = StringToBytes("14-3F-44-48-4C-50-54-62-16-1F-26-2D-39-47-55-5F");
                 else
                     curve = StringToBytes("14-3F-44-48-4C-50-54-62-11-1A-22-29-34-43-51-5A");
                 break;
             case 2:
-                if (device == 1)
+                if (device == AsusFan.GPU)
                     curve = StringToBytes("3C-41-42-46-47-4B-4C-62-08-11-11-1D-1D-26-26-2D");
                 else
                     curve = StringToBytes("3C-41-42-46-47-4B-4C-62-03-0C-0C-16-16-22-22-29");
                 break;
             default:
-                if (device == 1)
+                if (device == AsusFan.GPU)
                     curve = StringToBytes("3A-3D-40-44-48-4D-51-62-0C-16-1D-1F-26-2D-34-4A");
                 else
                     curve = StringToBytes("3A-3D-40-44-48-4D-51-62-08-11-16-1A-22-29-30-45");
@@ -186,23 +214,29 @@ public class AppConfig
         return curve;
     }
 
-    public string getConfigPerfString(string name)
+    public static string GetModeString(string name)
     {
-        int mode = getConfig("performance_mode");
-        return getConfigString(name + "_" + mode);
+        return GetString(name + "_" + Modes.GetCurrent());
     }
 
-    public int getConfigPerf(string name)
+    public static int GetMode(string name, int empty = -1)
     {
-        int mode = getConfig("performance_mode");
-        return getConfig(name + "_" + mode);
+        return Get(name + "_" + Modes.GetCurrent(), empty);
     }
 
-    public void setConfigPerf(string name, int value)
+    public static bool IsMode(string name)
     {
-        int mode = getConfig("performance_mode");
-        setConfig(name + "_" + mode, value);
+        return Get(name + "_" + Modes.GetCurrent()) == 1;
     }
 
+    public static void SetMode(string name, int value)
+    {
+        Set(name + "_" + Modes.GetCurrent(), value);
+    }
+
+    public static void SetMode(string name, string value)
+    {
+        Set(name + "_" + Modes.GetCurrent(), value);
+    }
 
 }

app/AsusACPI.cs

@@ -1,7 +1,29 @@
 using System.Management;
 using System.Runtime.InteropServices;
 
-public class ASUSWmi
+public enum AsusFan
+{
+    CPU = 0,
+    GPU = 1,
+    Mid = 2,
+    XGM = 3
+}
+
+public enum AsusMode
+{
+    Balanced = 0,
+    Turbo = 1,
+    Silent = 2
+}
+
+public enum AsusGPU
+{
+    Eco = 0,
+    Standard = 1,
+    Ultimate = 2
+}
+
+public class AsusACPI
 {
 
     const string FILE_NAME = @"\\.\\ATKACPI";
@@ -9,10 +31,25 @@ public class ASUSWmi
 
     const uint DSTS = 0x53545344;
     const uint DEVS = 0x53564544;
+    const uint INIT = 0x54494E49;
 
     public const uint UniversalControl = 0x00100021;
+    
     public const int KB_Light_Up = 0xc4;
     public const int KB_Light_Down = 0xc5;
+    public const int Brightness_Down = 0x10;
+    public const int Brightness_Up = 0x20;
+    public const int KB_Sleep = 0x6c;
+    public const int KB_DUO_PgUpDn = 0x4B;
+    public const int KB_DUO_SecondDisplay = 0x6A;
+
+
+    public const int Touchpad_Toggle = 0x6B;
+
+    public const int ChargerMode = 0x0012006C;
+
+    public const int ChargerUSB = 2;
+    public const int ChargerBarrel = 1;
 
     public const uint CPU_Fan = 0x00110013;
     public const uint GPU_Fan = 0x00110014;
@@ -36,38 +73,53 @@ public class ASUSWmi
     public const int Temp_CPU = 0x00120094;
     public const int Temp_GPU = 0x00120097;
 
-    public const int PPT_TotalA0 = 0x001200A0;  // Total PPT on 2022 (PPT_LIMIT_SLOW ) and CPU PPT on 2021
+    public const int PPT_TotalA0 = 0x001200A0;  // SPL (Total limit for all-AMD models) / PL1
     public const int PPT_EDCA1 = 0x001200A1;  // CPU EDC
     public const int PPT_TDCA2 = 0x001200A2;  // CPU TDC
-    public const int PPT_APUA3 = 0x001200A3;  // APU PPT ON 2021, doesn't work on 2022
+    public const int PPT_APUA3 = 0x001200A3;  // sPPT (long boost limit) / PL2
 
     public const int PPT_CPUB0 = 0x001200B0;  // CPU PPT on 2022 (PPT_LIMIT_APU)
     public const int PPT_CPUB1 = 0x001200B1;  // Total PPT on 2022 (PPT_LIMIT_SLOW)
 
-    public const int PPT_APUC0 = 0x001200C0;  // does nothing on G14 2022
-    public const int PPT_APUC1 = 0x001200C1;  // Actual Power Limit (PPT_LIMIT_FAST) AND Sustained Power Limit (STAPM_LIMIT)
-    public const int PPT_APUC2 = 0x001200C2;  // does nothing on G14 2022
+    public const int PPT_GPUC0 = 0x001200C0;  // NVIDIA GPU Boost
+    public const int PPT_APUC1 = 0x001200C1;  // fPPT (fast boost limit)
+    public const int PPT_GPUC2 = 0x001200C2;  // NVIDIA GPU Temp Target (75.. 87 C) 
 
+    public const int TUF_KB_BRIGHTNESS = 0x00050021;
     public const int TUF_KB = 0x00100056;
     public const int TUF_KB_STATE = 0x00100057;
 
+    public const int TabletState = 0x00060077;
+    public const int FnLock = 0x00100023;
+
+    public const int Tablet_Notebook = 0;
+    public const int Tablet_Tablet = 1;
+    public const int Tablet_Tent = 2;
+    public const int Tablet_Rotated = 3;
+
     public const int PerformanceBalanced = 0;
     public const int PerformanceTurbo = 1;
     public const int PerformanceSilent = 2;
+    public const int PerformanceManual = 4;
 
     public const int GPUModeEco = 0;
     public const int GPUModeStandard = 1;
     public const int GPUModeUltimate = 2;
 
-
-    public const int MaxTotal = 250;
+    public static int MaxTotal => AppConfig.ContainsModel("G513QY") ? 250 : 150;
     public const int MinTotal = 5;
     public const int DefaultTotal = 125;
 
-    public const int MaxCPU = 130;
+    public const int MaxCPU = 100;
     public const int MinCPU = 5;
     public const int DefaultCPU = 80;
 
+    public const int MinGPUBoost = 5;
+    public const int MaxGPUBoost = 25;
+
+    public const int MinGPUTemp = 75;
+    public const int MaxGPUTemp = 87;
+
 
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     private static extern IntPtr CreateFile(
@@ -104,7 +156,43 @@ public class ASUSWmi
 
     private IntPtr handle;
 
-    public ASUSWmi()
+    // Event handling attempt
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
+
+    private IntPtr eventHandle;
+
+    // still works only with asus optimization service on , if someone knows how to get ACPI events from asus without that - let me know
+    public void RunListener()
+    {
+
+        eventHandle = CreateEvent(IntPtr.Zero, false, false, "ATK4001");
+
+        byte[] outBuffer = new byte[16];
+        byte[] data = new byte[8];
+        bool result;
+
+        data[0] = BitConverter.GetBytes(eventHandle.ToInt32())[0];
+        data[1] = BitConverter.GetBytes(eventHandle.ToInt32())[1];
+
+        Control(0x222400, data, outBuffer);
+        Logger.WriteLine("ACPI :" + BitConverter.ToString(data) + "|" + BitConverter.ToString(outBuffer));
+
+        while (true)
+        {
+            WaitForSingleObject(eventHandle, Timeout.Infinite);
+            Control(0x222408, new byte[0], outBuffer);
+            int code = BitConverter.ToInt32(outBuffer);
+            Logger.WriteLine("ACPI Code: " + code);
+        }
+    }
+
+
+    public AsusACPI()
     {
         handle = CreateFile(
             FILE_NAME,
@@ -115,16 +203,19 @@ public class ASUSWmi
             FILE_ATTRIBUTE_NORMAL,
             IntPtr.Zero
         );
+
         if (handle == new IntPtr(-1))
         {
             throw new Exception("Can't connect to ACPI");
         }
+
     }
 
     public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
     {
+
         uint lpBytesReturned = 0;
-        bool result = DeviceIoControl(
+        DeviceIoControl(
             handle,
             dwIoControlCode,
             lpInBuffer,
@@ -159,6 +250,13 @@ public class ASUSWmi
 
     }
 
+    public byte[] DeviceInit()
+    {
+        byte[] args = new byte[8];
+        return CallMethod(INIT, args);
+
+    }
+
     public int DeviceSet(uint DeviceID, int Status, string logName)
     {
         byte[] args = new byte[8];
@@ -192,7 +290,7 @@ public class ASUSWmi
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
         byte[] status = CallMethod(DSTS, args);
-        
+
         return BitConverter.ToInt32(status, 0) - 65536;
 
     }
@@ -202,12 +300,26 @@ public class ASUSWmi
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
         BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
-        
+
         return CallMethod(DSTS, args);
     }
 
+    public int SetGPUEco(int eco)
+    {
+        int ecoFlag = DeviceGet(GPUEco);
+        if (ecoFlag < 0) return -1;
 
-    public int SetFanCurve(int device, byte[] curve)
+        if (ecoFlag == 1 && eco == 0)
+            return DeviceSet(GPUEco, eco, "GPUEco");
+
+        if (ecoFlag == 0 && eco == 1)
+            return DeviceSet(GPUEco, eco, "GPUEco");
+
+        return -1;
+    }
+
+
+    public int SetFanCurve(AsusFan device, byte[] curve)
     {
 
         if (curve.Length != 16) return -1;
@@ -216,16 +328,14 @@ public class ASUSWmi
         int result;
 
         for (int i = 8; i < curve.Length; i++)
-        {
             curve[i] = Math.Max((byte)0, Math.Min((byte)99, curve[i])); // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
-        }
 
         switch (device)
         {
-            case 1:
+            case AsusFan.GPU:
                 result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
                 break;
-            case 2:
+            case AsusFan.Mid:
                 result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
                 break;
             default:
@@ -236,7 +346,7 @@ public class ASUSWmi
         return result;
     }
 
-    public byte[] GetFanCurve(int device, int mode = 0)
+    public byte[] GetFanCurve(AsusFan device, int mode = 0)
     {
         uint fan_mode;
 
@@ -250,9 +360,9 @@ public class ASUSWmi
 
         switch (device)
         {
-            case 1:
+            case AsusFan.GPU:
                 return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
-            case 2:
+            case AsusFan.Mid:
                 return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
             default:
                 return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
@@ -260,6 +370,88 @@ public class ASUSWmi
 
     }
 
+    public static bool IsInvalidCurve(byte[] curve)
+    {
+        return curve.Length != 16 || IsEmptyCurve(curve);
+    }
+
+    public static bool IsEmptyCurve(byte[] curve)
+    {
+        return curve.All(singleByte => singleByte == 0);
+    }
+
+    public static byte[] FixFanCurve(byte[] curve)
+    {
+        if (curve.Length != 16) throw new Exception("Incorrect curve");
+
+        var points = new Dictionary<byte, byte>();
+        for (int i = 0; i < 8; i++) points[curve[i]] = curve[i + 8];
+
+        var pointsFixed = new Dictionary<byte, byte>();
+        bool fix = false;
+
+        int count = 0;
+        foreach (var pair in points.OrderBy(x => x.Key))
+        {
+            if (count == 0 && pair.Key >= 40)
+            {
+                fix = true;
+                pointsFixed.Add(20, 0);
+            }
+
+            if (count != 3 || !fix)
+                pointsFixed.Add(pair.Key, pair.Value);
+            count++;
+        }
+
+        count = 0;
+        foreach (var pair in pointsFixed.OrderBy(x => x.Key))
+        {
+            curve[count] = pair.Key;
+            curve[count + 8] = pair.Value;
+            count++;
+        }
+
+        return curve;
+
+    }
+
+    public bool IsXGConnected()
+    {
+        //return true;
+        return DeviceGet(GPUXGConnected) == 1;
+    }
+
+    public bool IsAllAmdPPT()
+    {
+        return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
+    }
+
+
+    public void ScanRange()
+    {
+        int value;
+        string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        string logFile = appPath + "\\scan.txt";
+        for (uint i = 0x00000000; i <= 0x00160000; i++)
+        {
+            value = DeviceGet(i);
+            if (value >= 0)
+                using (StreamWriter w = File.AppendText(logFile))
+                {
+                    w.WriteLine(i.ToString("X8") + ": " + value.ToString("X4") + " (" + value + ")");
+                    w.Close();
+                }
+        }
+
+    }
+
+    public void TUFKeyboardBrightness(int brightness)
+    {
+        int param = 0x80 | (brightness & 0x7F);
+        DeviceSet(TUF_KB_BRIGHTNESS, param, "TUF Brightness");
+    }
+
     public void TUFKeyboardRGB(int mode, Color color, int speed)
     {
 
@@ -303,10 +495,12 @@ public class ASUSWmi
             watcher.Scope = new ManagementScope("root\\wmi");
             watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
             watcher.Start();
-        } catch
+        }
+        catch
         {
             Logger.WriteLine("Can't connect to ASUS WMI events");
         }
     }
 
+
 }

app/AsusUSB.cs

@@ -0,0 +1,422 @@
+using HidLibrary;
+using System.Text;
+
+namespace GHelper
+{
+
+    [Flags]
+    public enum AuraDev19b6 : uint
+    {
+        BootLogo = 1,
+        BootKeyb = 1 << 1,
+        AwakeLogo = 1 << 2,
+        AwakeKeyb = 1 << 3,
+        SleepLogo = 1 << 4,
+        SleepKeyb = 1 << 5,
+        ShutdownLogo = 1 << 6,
+        ShutdownKeyb = 1 << 7,
+        BootBar = 1u << (7 + 2),
+        AwakeBar = 1u << (7 + 3),
+        SleepBar = 1u << (7 + 4),
+        ShutdownBar = 1u << (7 + 5),
+        BootLid = 1u << (15 + 1),
+        AwakeLid = 1u << (15 + 2),
+        SleepLid = 1u << (15 + 3),
+        ShutdownLid = 1u << (15 + 4)
+    }
+
+    public static class AuraDev19b6Extensions
+    {
+        public static byte[] ToBytes(this AuraDev19b6[] controls)
+        {
+            uint a = 0;
+            foreach (var n in controls)
+            {
+                a |= (uint)n;
+            }
+            return new byte[] { 0x5d, 0xbd, 0x01, (byte)(a & 0xff), (byte)((a & 0xff00) >> 8), (byte)((a & 0xff0000) >> 16) };
+        }
+
+        public static ushort BitOr(this AuraDev19b6 self, AuraDev19b6 rhs)
+        {
+            return (ushort)(self | rhs);
+        }
+
+        public static ushort BitAnd(this AuraDev19b6 self, AuraDev19b6 rhs)
+        {
+            return (ushort)(self & rhs);
+        }
+    }
+
+
+    public static class AsusUSB
+    {
+
+        public const int ASUS_ID = 0x0b05;
+
+        public const byte INPUT_HID_ID = 0x5a;
+        public const byte AURA_HID_ID = 0x5d;
+
+        public static readonly byte[] LED_INIT1 = new byte[] { AURA_HID_ID, 0xb9 };
+        public static readonly byte[] LED_INIT2 = Encoding.ASCII.GetBytes("]ASUS Tech.Inc.");
+        public static readonly byte[] LED_INIT3 = new byte[] { AURA_HID_ID, 0x05, 0x20, 0x31, 0, 0x08 };
+        public static readonly byte[] LED_INIT4 = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
+        public static readonly byte[] LED_INIT5 = new byte[] { 0x5e, 0x05, 0x20, 0x31, 0, 0x08 };
+
+        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
+        static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
+
+        static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6, 0x1abe };
+
+        private static int mode = 0;
+        private static int speed = 1;
+        public static Color Color1 = Color.White;
+        public static Color Color2 = Color.Black;
+
+
+        public static Dictionary<int, string> GetSpeeds()
+        {
+            return new Dictionary<int, string>
+            {
+                { 0, Properties.Strings.AuraSlow },
+                { 1, Properties.Strings.AuraNormal },
+                { 2, Properties.Strings.AuraFast }
+            };
+        }
+
+
+        static Dictionary<int, string> _modes = new Dictionary<int, string>
+            {
+                { 0, Properties.Strings.AuraStatic },
+                { 1, Properties.Strings.AuraBreathe },
+                { 2, Properties.Strings.AuraColorCycle },
+                { 3, Properties.Strings.AuraRainbow },
+                { 10, Properties.Strings.AuraStrobe },
+            };
+
+        static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
+            {
+                { 0, Properties.Strings.AuraStatic },
+                { 1, Properties.Strings.AuraBreathe },
+                { 2, Properties.Strings.AuraColorCycle },
+                { 3, Properties.Strings.AuraRainbow },
+                { 4, "Star" },
+                { 5, "Rain" },
+                { 6, "Highlight" },
+                { 7, "Laser" },
+                { 8, "Ripple" },
+                { 10, Properties.Strings.AuraStrobe},
+                { 11, "Comet" },
+                { 12, "Flash" },
+            };
+
+
+        public static Dictionary<int, string> GetModes()
+        {
+            if (AppConfig.ContainsModel("TUF"))
+            {
+                _modes.Remove(3);
+            }
+
+            if (AppConfig.ContainsModel("401"))
+            {
+                _modes.Remove(2);
+                _modes.Remove(3);
+            }
+
+            if (AppConfig.ContainsModel("G513QY"))
+            {
+                return _modes;
+            }
+
+            if (AppConfig.ContainsModel("Strix") || AppConfig.ContainsModel("Scar"))
+            {
+                return _modesStrix;
+            }
+
+            return _modes;
+        }
+
+
+        public static int Mode
+        {
+            get { return mode; }
+            set
+            {
+                if (GetModes().ContainsKey(value))
+                    mode = value;
+                else
+                    mode = 0;
+            }
+        }
+
+        public static bool HasSecondColor()
+        {
+            return (mode == 1 && !AppConfig.ContainsModel("TUF"));
+        }
+
+        public static int Speed
+        {
+            get { return speed; }
+            set
+            {
+                if (GetSpeeds().ContainsKey(value))
+                    speed = value;
+                else
+                    speed = 1;
+            }
+
+        }
+
+        public static void SetColor(int colorCode)
+        {
+            Color1 = Color.FromArgb(colorCode);
+        }
+
+        public static void SetColor2(int colorCode)
+        {
+            Color2 = Color.FromArgb(colorCode);
+        }
+
+
+        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minFeatures = 1)
+        {
+            HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
+            foreach (HidDevice device in HidDeviceList)
+                if (device.IsConnected && device.Capabilities.FeatureReportByteLength >= minFeatures)
+                    yield return device;
+        }
+
+        public static HidDevice? GetDevice(byte reportID = INPUT_HID_ID)
+        {
+            HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
+            HidDevice input = null;
+
+            foreach (HidDevice device in HidDeviceList)
+                if (device.ReadFeatureData(out byte[] data, reportID))
+                {
+                    input = device;
+                    //Logger.WriteLine("HID Device("+ reportID + ")" +  + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.DevicePath);
+                }
+
+            return input;
+        }
+
+        public static bool TouchpadToggle()
+        {
+            HidDevice? input = GetDevice();
+            if (input != null) return input.WriteFeatureData(new byte[] { INPUT_HID_ID, 0xf4, 0x6b });
+            return false;
+        }
+
+
+        public static byte[] AuraMessage(int mode, Color color, Color color2, int speed)
+        {
+
+            byte[] msg = new byte[17];
+            msg[0] = AURA_HID_ID;
+            msg[1] = 0xb3;
+            msg[2] = 0x00; // Zone 
+            msg[3] = (byte)mode; // Aura Mode
+            msg[4] = (byte)(color.R); // R
+            msg[5] = (byte)(color.G); // G
+            msg[6] = (byte)(color.B); // B
+            msg[7] = (byte)speed; // aura.speed as u8;
+            msg[8] = 0; // aura.direction as u8;
+            msg[10] = (byte)(color2.R); // R
+            msg[11] = (byte)(color2.G); // G
+            msg[12] = (byte)(color2.B); // B
+            return msg;
+        }
+
+        public static void Init()
+        {
+            Task.Run(async () =>
+            {
+                var devices = GetHidDevices(deviceIds);
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+                    device.WriteFeatureData(LED_INIT1);
+                    device.WriteFeatureData(LED_INIT2);
+                    device.WriteFeatureData(LED_INIT3);
+                    device.WriteFeatureData(LED_INIT4);
+                    device.WriteFeatureData(LED_INIT5);
+                    device.CloseDevice();
+                }
+            });
+        }
+
+
+        public static void ApplyBrightness(int brightness, string log = "Backlight")
+        {
+
+            if (AppConfig.ContainsModel("TUF"))
+                Program.acpi.TUFKeyboardBrightness(brightness);
+
+
+            Task.Run(async () =>
+            {
+
+                byte[] msg = { AURA_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+                byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+
+                var devices = GetHidDevices(deviceIds);
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+
+                    if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                    {
+                        device.WriteFeatureData(msg);
+                        Logger.WriteLine(log + ":" + BitConverter.ToString(msg));
+                    }
+
+                    if (AppConfig.ContainsModel("GA503") && device.ReadFeatureData(out byte[] dataBackkup, INPUT_HID_ID))
+                    {
+                        device.WriteFeatureData(msgBackup);
+                        Logger.WriteLine(log + ":" + BitConverter.ToString(msgBackup));
+                    }
+
+                    device.CloseDevice();
+                }
+
+                // Backup payload for old models
+                /*
+                if (AppConfig.ContainsModel("GA503RW"))
+                {
+                    byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+
+                    var devicesBackup = GetHidDevices(deviceIds);
+                    foreach (HidDevice device in devicesBackup)
+                    {
+                        device.OpenDevice();
+                        device.WriteFeatureData(msgBackup);
+                        device.CloseDevice();
+                    }
+                }
+                */
+
+            });
+
+
+        }
+
+
+        public static void ApplyAuraPower(List<AuraDev19b6> flags)
+        {
+
+            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
+
+
+            var devices = GetHidDevices(deviceIds);
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    device.WriteFeatureData(msg);
+                    Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                }
+                device.CloseDevice();
+            }
+
+            if (AppConfig.ContainsModel("TUF"))
+                Program.acpi.TUFKeyboardPower(
+                    flags.Contains(AuraDev19b6.AwakeKeyb),
+                    flags.Contains(AuraDev19b6.BootKeyb),
+                    flags.Contains(AuraDev19b6.SleepKeyb),
+                    flags.Contains(AuraDev19b6.ShutdownKeyb));
+
+        }
+
+
+        public static void ApplyAura()
+        {
+
+            int _speed;
+
+            switch (Speed)
+            {
+                case 1:
+                    _speed = 0xeb;
+                    break;
+                case 2:
+                    _speed = 0xf5;
+                    break;
+                default:
+                    _speed = 0xe1;
+                    break;
+            }
+
+            byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
+            var devices = GetHidDevices(deviceIds);
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    device.WriteFeatureData(msg);
+                    device.WriteFeatureData(MESSAGE_SET);
+                    device.WriteFeatureData(MESSAGE_APPLY);
+                    Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+                }
+                device.CloseDevice();
+            }
+
+            if (AppConfig.ContainsModel("TUF"))
+                Program.acpi.TUFKeyboardRGB(Mode, Color1, _speed);
+
+        }
+
+
+        // Reference : thanks to https://github.com/RomanYazvinsky/ for initial discovery of XGM payloads
+        public static int SetXGM(byte[] msg)
+        {
+
+            //Logger.WriteLine("XGM Payload :" + BitConverter.ToString(msg));
+
+            var payload = new byte[300];
+            Array.Copy(msg, payload, msg.Length);
+
+            foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }, 300))
+            {
+                device.OpenDevice();
+                Logger.WriteLine("XGM " + device.Attributes.ProductHexId + "|" + device.Capabilities.FeatureReportByteLength + ":" + BitConverter.ToString(msg));
+                device.WriteFeatureData(payload);
+                device.CloseDevice();
+                //return 1;
+            }
+
+            return 0;
+        }
+
+        public static void ApplyXGMLight(bool status)
+        {
+            SetXGM(new byte[] { 0x5e, 0xc5, status ? (byte)0x50 : (byte)0 });
+        }
+
+
+        public static int ResetXGM()
+        {
+            return SetXGM(new byte[] { 0x5e, 0xd1, 0x02 });
+        }
+
+        public static int SetXGMFan(byte[] curve)
+        {
+
+            if (AsusACPI.IsInvalidCurve(curve)) return -1;
+
+            byte[] msg = new byte[19];
+            Array.Copy(new byte[] { 0x5e, 0xd1, 0x01 }, msg, 3);
+            Array.Copy(curve, 0, msg, 3, curve.Length);
+
+            return SetXGM(msg);
+        }
+
+
+    }
+
+}

app/Aura.cs

@@ -1,269 +0,0 @@
-using HidLibrary;
-using System.Diagnostics;
-
-namespace GHelper
-{
-
-    [Flags]
-    public enum AuraDev19b6 : uint
-    {
-        BootLogo = 1,
-        BootKeyb = 1 << 1,
-        AwakeLogo = 1 << 2,
-        AwakeKeyb = 1 << 3,
-        SleepLogo = 1 << 4,
-        SleepKeyb = 1 << 5,
-        ShutdownLogo = 1 << 6,
-        ShutdownKeyb = 1 << 7,
-        BootBar = 1u << (7 + 2),
-        AwakeBar = 1u << (7 + 3),
-        SleepBar = 1u << (7 + 4),
-        ShutdownBar = 1u << (7 + 5),
-        BootLid = 1u << (15 + 1),
-        AwakeLid = 1u << (15 + 2),
-        SleepLid = 1u << (15 + 3),
-        ShutdownLid = 1u << (15 + 4)
-    }
-
-    public static class AuraDev19b6Extensions
-    {
-        public static byte[] ToBytes(this AuraDev19b6[] controls)
-        {
-            uint a = 0;
-            foreach (var n in controls)
-            {
-                a |= (uint)n;
-            }
-            return new byte[] { 0x5d, 0xbd, 0x01, (byte)(a & 0xff), (byte)((a & 0xff00) >> 8), (byte)((a & 0xff0000) >> 16) };
-        }
-
-        public static ushort BitOr(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self | rhs);
-        }
-
-        public static ushort BitAnd(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self & rhs);
-        }
-    }
-
-    public static class Aura
-    {
-
-        static byte[] MESSAGE_SET = { 0x5d, 0xb5, 0, 0, 0 };
-        static byte[] MESSAGE_APPLY = { 0x5d, 0xb4 };
-
-        static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0 };
-
-        private static int mode = 0;
-        private static int speed = 1;
-        public static Color Color1 = Color.White;
-        public static Color Color2 = Color.Black;
-
-
-        public static Dictionary<int, string> GetSpeeds()
-        {
-            return new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraSlow },
-                { 1, Properties.Strings.AuraNormal },
-                { 2, Properties.Strings.AuraFast }
-            };
-        }
-
-        static Dictionary<int, string> _modes = new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraStatic },
-                { 1, Properties.Strings.AuraBreathe },
-                { 2, Properties.Strings.AuraColorCycle },
-                { 3, Properties.Strings.AuraRainbow },
-                { 10, Properties.Strings.AuraStrobe },
-            };
-
-        static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraStatic },
-                { 1, Properties.Strings.AuraBreathe },
-                { 2, Properties.Strings.AuraColorCycle },
-                { 3, Properties.Strings.AuraRainbow },
-                { 4, "Star" },
-                { 5, "Rain" },
-                { 6, "Highlight" },
-                { 7, "Laser" },
-                { 8, "Ripple" },
-                { 10, Properties.Strings.AuraStrobe},
-                { 11, "Comet" },
-                { 12, "Flash" },
-            };
-
-
-        public static Dictionary<int, string> GetModes()
-        {
-            if (Program.config.ContainsModel("TUF"))
-            {
-                _modes.Remove(3);
-            }
-
-            if (Program.config.ContainsModel("401"))
-            {
-                _modes.Remove(2);
-                _modes.Remove(3);
-            }
-
-            if (Program.config.ContainsModel("Strix") || Program.config.ContainsModel("Scar"))
-            {
-                return _modesStrix;
-            }
-
-            return _modes;
-        }
-
-
-        public static int Mode
-        {
-            get { return mode; }
-            set
-            {
-                if (GetModes().ContainsKey(value))
-                    mode = value;
-                else
-                    mode = 0;
-            }
-        }
-
-        public static bool HasSecondColor()
-        {
-            return (mode == 1 && !Program.config.ContainsModel("TUF"));
-        }
-
-        public static int Speed
-        {
-            get { return speed; }
-            set
-            {
-                if (GetSpeeds().ContainsKey(value))
-                    speed = value;
-                else
-                    speed = 1;
-            }
-
-        }
-
-        public static void SetColor(int colorCode)
-        {
-            Color1 = Color.FromArgb(colorCode);
-        }
-
-        public static void SetColor2(int colorCode)
-        {
-            Color2 = Color.FromArgb(colorCode);
-        }
-
-        public static byte[] AuraMessage(int mode, Color color, Color color2, int speed)
-        {
-
-            byte[] msg = new byte[17];
-            msg[0] = 0x5d;
-            msg[1] = 0xb3;
-            msg[2] = 0x00; // Zone 
-            msg[3] = (byte)mode; // Aura Mode
-            msg[4] = (byte)(color.R); // R
-            msg[5] = (byte)(color.G); // G
-            msg[6] = (byte)(color.B); // B
-            msg[7] = (byte)speed; // aura.speed as u8;
-            msg[8] = 0; // aura.direction as u8;
-            msg[10] = (byte)(color2.R); // R
-            msg[11] = (byte)(color2.G); // G
-            msg[12] = (byte)(color2.B); // B
-            return msg;
-        }
-
-
-        public static void ApplyBrightness(int brightness)
-        {
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
-
-            byte[] msg = { 0x5d, 0xba, 0xc5, 0xc4, (byte)brightness };
-
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.CloseDevice();
-                }
-
-            Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
-        }
-
-
-        public static void ApplyAuraPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
-        {
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, 0x19b6).ToArray();
-
-            List<AuraDev19b6> flags = new List<AuraDev19b6>();
-
-            if (awake) flags.Add(AuraDev19b6.AwakeKeyb);
-            if (boot) flags.Add(AuraDev19b6.BootKeyb);
-            if (sleep) flags.Add(AuraDev19b6.SleepKeyb);
-            if (shutdown) flags.Add(AuraDev19b6.ShutdownKeyb);
-
-            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
-
-            Debug.WriteLine(BitConverter.ToString(msg));
-
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.CloseDevice();
-                }
-
-            Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
-
-            if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardPower(awake, boot, sleep, shutdown);
-
-        }
-
-        public static void ApplyAura()
-        {
-
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
-
-            int _speed;
-
-            switch (Speed)
-            {
-                case 1:
-                    _speed = 0xeb;
-                    break;
-                case 2:
-                    _speed = 0xf5;
-                    break;
-                default:
-                    _speed = 0xe1;
-                    break;
-            }
-
-
-            byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.Write(MESSAGE_SET);
-                    device.Write(MESSAGE_APPLY);
-                    device.CloseDevice();
-                }
-
-            if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardRGB(Mode, Color1, _speed);
-
-        }
-    }
-
-}

app/Display/ScreenControl.cs

@@ -0,0 +1,99 @@
+using System.Diagnostics;
+
+namespace GHelper.Display
+{
+    public class ScreenControl
+    {
+        public void AutoScreen(bool force = false)
+        {
+            if (force || AppConfig.Is("screen_auto"))
+            {
+                if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
+                    SetScreen(1000, 1);
+                else
+                    SetScreen(60, 0);
+            }
+            else
+            {
+                SetScreen(overdrive: AppConfig.Get("overdrive"));
+            }
+        }
+
+        public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
+        {
+
+            if (NativeMethods.GetRefreshRate() < 0) // Laptop screen not detected or has unknown refresh rate
+            {
+                InitScreen();
+                return;
+            }
+
+            if (frequency >= 1000)
+            {
+                frequency = NativeMethods.GetRefreshRate(true);
+            }
+
+            if (frequency > 0)
+            {
+                NativeMethods.SetRefreshRate(frequency);
+            }
+
+            if (overdrive >= 0)
+            {
+                if (AppConfig.Get("no_overdrive") == 1) overdrive = 0;
+                Program.acpi.DeviceSet(AsusACPI.ScreenOverdrive, overdrive, "ScreenOverdrive");
+
+            }
+
+            if (miniled >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.ScreenMiniled, miniled, "Miniled");
+                Debug.WriteLine("Miniled " + miniled);
+            }
+
+            InitScreen();
+        }
+
+
+        public void ToogleMiniled()
+        {
+            int miniled = (AppConfig.Get("miniled") == 1) ? 0 : 1;
+            AppConfig.Set("miniled", miniled);
+            SetScreen(-1, -1, miniled);
+        }
+
+        public void InitScreen()
+        {
+            int frequency = NativeMethods.GetRefreshRate();
+            int maxFrequency = NativeMethods.GetRefreshRate(true);
+
+            bool screenAuto = AppConfig.Is("screen_auto");
+            bool overdriveSetting = !AppConfig.Is("no_overdrive");
+
+            int overdrive = Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
+            int miniled = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled);
+
+            if (miniled >= 0)
+                AppConfig.Set("miniled", miniled);
+
+            bool screenEnabled = (frequency >= 0);
+
+            AppConfig.Set("frequency", frequency);
+            AppConfig.Set("overdrive", overdrive);
+
+            Program.settingsForm.Invoke(delegate
+            {
+                Program.settingsForm.VisualiseScreen(
+                    screenEnabled: screenEnabled,
+                    screenAuto: screenAuto,
+                    frequency: frequency,
+                    maxFrequency: maxFrequency,
+                    overdrive: overdrive,
+                    overdriveSetting: overdriveSetting,
+                    miniled: miniled
+                );
+            });
+
+        }
+    }
+}

app/Extra.cs

@@ -0,0 +1,461 @@
+using GHelper.Display;
+using GHelper.Gpu.AMD;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.UI;
+using System.Diagnostics;
+
+namespace GHelper
+{
+    public partial class Extra : RForm
+    {
+
+        ScreenControl screenControl = new ScreenControl();
+
+        Dictionary<string, string> customActions = new Dictionary<string, string>
+        {
+          {"","--------------" },
+          {"mute", Properties.Strings.VolumeMute},
+          {"screenshot", Properties.Strings.PrintScreen},
+          {"play", Properties.Strings.PlayPause},
+          {"aura", Properties.Strings.ToggleAura},
+          {"performance", Properties.Strings.PerformanceMode},
+          {"screen", Properties.Strings.ToggleScreen},
+          {"miniled", Properties.Strings.ToggleMiniled},
+          {"fnlock", Properties.Strings.ToggleFnLock},
+          {"brightness_down", Properties.Strings.BrightnessDown},
+          {"brightness_up", Properties.Strings.BrightnessUp},
+          {"custom", Properties.Strings.Custom}
+        };
+
+        private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
+        {
+
+            switch (name)
+            {
+                case "m1":
+                    customActions[""] = Properties.Strings.VolumeDown;
+                    break;
+                case "m2":
+                    customActions[""] = Properties.Strings.VolumeUp;
+                    break;
+                case "m3":
+                    customActions[""] = Properties.Strings.MuteMic;
+                    break;
+                case "m4":
+                    customActions[""] = Properties.Strings.OpenGHelper;
+                    break;
+                case "fnf4":
+                    customActions[""] = Properties.Strings.ToggleAura;
+                    customActions.Remove("aura");
+                    break;
+                case "fnc":
+                    customActions[""] = Properties.Strings.ToggleFnLock;
+                    customActions.Remove("fnlock");
+                    break;
+            }
+
+            combo.DropDownStyle = ComboBoxStyle.DropDownList;
+            combo.DataSource = new BindingSource(customActions, null);
+            combo.DisplayMember = "Value";
+            combo.ValueMember = "Key";
+
+            string action = AppConfig.GetString(name);
+
+            combo.SelectedValue = (action is not null) ? action : "";
+            if (combo.SelectedValue is null) combo.SelectedValue = "";
+
+            combo.SelectedValueChanged += delegate
+            {
+                if (combo.SelectedValue is not null)
+                    AppConfig.Set(name, combo.SelectedValue.ToString());
+
+                if (name == "m1" || name == "m2")
+                    Program.inputDispatcher.RegisterKeys();
+
+            };
+
+            txbox.Text = AppConfig.GetString(name + "_custom");
+            txbox.TextChanged += delegate
+            {
+                AppConfig.Set(name + "_custom", txbox.Text);
+            };
+        }
+
+        public Extra()
+        {
+            InitializeComponent();
+
+            groupBindings.Text = Properties.Strings.KeyBindings;
+            groupLight.Text = " " + Properties.Strings.LaptopBacklight;
+            groupOther.Text = Properties.Strings.Other;
+
+            checkAwake.Text = Properties.Strings.Awake;
+            checkSleep.Text = Properties.Strings.Sleep;
+            checkBoot.Text = Properties.Strings.Boot;
+            checkShutdown.Text = Properties.Strings.Shutdown;
+
+            labelSpeed.Text = Properties.Strings.AnimationSpeed;
+            labelBrightness.Text = Properties.Strings.Brightness;
+
+            labelBacklightTimeout.Text = Properties.Strings.BacklightTimeout;
+            labelBacklightTimeoutPlugged.Text = Properties.Strings.BacklightTimeoutPlugged;
+
+            checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
+            checkTopmost.Text = Properties.Strings.WindowTop;
+            checkUSBC.Text = Properties.Strings.OptimizedUSBC;
+            checkAutoApplyWindowsPowerMode.Text = Properties.Strings.ApplyWindowsPowerPlan;
+            checkFnLock.Text = Properties.Strings.FnLock;
+
+            labelBacklight.Text = Properties.Strings.Keyboard;
+            labelBacklightBar.Text = Properties.Strings.Lightbar;
+            labelBacklightLid.Text = Properties.Strings.Lid;
+            labelBacklightLogo.Text = Properties.Strings.Logo;
+
+            checkGpuApps.Text = Properties.Strings.KillGpuApps;
+
+            Text = Properties.Strings.ExtraSettings;
+
+            InitTheme();
+
+            SetKeyCombo(comboM1, textM1, "m1");
+            SetKeyCombo(comboM2, textM2, "m2");
+            SetKeyCombo(comboM3, textM3, "m3");
+            SetKeyCombo(comboM4, textM4, "m4");
+            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
+            SetKeyCombo(comboFNC, textFNC, "fnc");
+
+            Shown += Keyboard_Shown;
+
+            comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboKeyboardSpeed.DataSource = new BindingSource(AsusUSB.GetSpeeds(), null);
+            comboKeyboardSpeed.DisplayMember = "Value";
+            comboKeyboardSpeed.ValueMember = "Key";
+            comboKeyboardSpeed.SelectedValue = AsusUSB.Speed;
+            comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
+
+            // Keyboard
+            checkAwake.Checked = !(AppConfig.Get("keyboard_awake") == 0);
+            checkBoot.Checked = !(AppConfig.Get("keyboard_boot") == 0);
+            checkSleep.Checked = !(AppConfig.Get("keyboard_sleep") == 0);
+            checkShutdown.Checked = !(AppConfig.Get("keyboard_shutdown") == 0);
+
+            // Lightbar
+            checkAwakeBar.Checked = !(AppConfig.Get("keyboard_awake_bar") == 0);
+            checkBootBar.Checked = !(AppConfig.Get("keyboard_boot_bar") == 0);
+            checkSleepBar.Checked = !(AppConfig.Get("keyboard_sleep_bar") == 0);
+            checkShutdownBar.Checked = !(AppConfig.Get("keyboard_shutdown_bar") == 0);
+
+            // Lid
+            checkAwakeLid.Checked = !(AppConfig.Get("keyboard_awake_lid") == 0);
+            checkBootLid.Checked = !(AppConfig.Get("keyboard_boot_lid") == 0);
+            checkSleepLid.Checked = !(AppConfig.Get("keyboard_sleep_lid") == 0);
+            checkShutdownLid.Checked = !(AppConfig.Get("keyboard_shutdown_lid") == 0);
+
+            // Logo
+            checkAwakeLogo.Checked = !(AppConfig.Get("keyboard_awake_logo") == 0);
+            checkBootLogo.Checked = !(AppConfig.Get("keyboard_boot_logo") == 0);
+            checkSleepLogo.Checked = !(AppConfig.Get("keyboard_sleep_logo") == 0);
+            checkShutdownLogo.Checked = !(AppConfig.Get("keyboard_shutdown_logo") == 0);
+
+            checkAwake.CheckedChanged += CheckPower_CheckedChanged;
+            checkBoot.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleep.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdown.CheckedChanged += CheckPower_CheckedChanged;
+
+            checkAwakeBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownBar.CheckedChanged += CheckPower_CheckedChanged;
+
+            checkAwakeLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownLid.CheckedChanged += CheckPower_CheckedChanged;
+
+            checkAwakeLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownLogo.CheckedChanged += CheckPower_CheckedChanged;
+
+            if (!AppConfig.ContainsModel("Strix"))
+            {
+                labelBacklightBar.Visible = false;
+                checkAwakeBar.Visible = false;
+                checkBootBar.Visible = false;
+                checkSleepBar.Visible = false;
+                checkShutdownBar.Visible = false;
+
+                if (!AppConfig.ContainsModel("Z13"))
+                {
+                    labelBacklightLid.Visible = false;
+                    checkAwakeLid.Visible = false;
+                    checkBootLid.Visible = false;
+                    checkSleepLid.Visible = false;
+                    checkShutdownLid.Visible = false;
+
+                    labelBacklightLogo.Visible = false;
+                    checkAwakeLogo.Visible = false;
+                    checkBootLogo.Visible = false;
+                    checkSleepLogo.Visible = false;
+                    checkShutdownLogo.Visible = false;
+                }
+            }
+
+            checkTopmost.Checked = AppConfig.Is("topmost");
+            checkTopmost.CheckedChanged += CheckTopmost_CheckedChanged; ;
+
+            checkNoOverdrive.Checked = AppConfig.Is("no_overdrive");
+            checkNoOverdrive.CheckedChanged += CheckNoOverdrive_CheckedChanged;
+
+            checkUSBC.Checked = AppConfig.Is("optimized_usbc");
+            checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
+
+            checkAutoApplyWindowsPowerMode.Checked = (AppConfig.Get("auto_apply_power_plan") != 0);
+            checkAutoApplyWindowsPowerMode.CheckedChanged += checkAutoApplyWindowsPowerMode_CheckedChanged;
+
+            trackBrightness.Value = InputDispatcher.GetBacklight();
+            trackBrightness.Scroll += TrackBrightness_Scroll;
+
+            panelXMG.Visible = (Program.acpi.DeviceGet(AsusACPI.GPUXGConnected) == 1);
+            checkXMG.Checked = !(AppConfig.Get("xmg_light") == 0);
+            checkXMG.CheckedChanged += CheckXMG_CheckedChanged;
+
+            numericBacklightTime.Value = AppConfig.Get("keyboard_timeout", 60);
+            numericBacklightPluggedTime.Value = AppConfig.Get("keyboard_ac_timeout", 0);
+
+            numericBacklightTime.ValueChanged += NumericBacklightTime_ValueChanged;
+            numericBacklightPluggedTime.ValueChanged += NumericBacklightTime_ValueChanged;
+
+            checkGpuApps.Checked = AppConfig.Is("kill_gpu_apps");
+            checkGpuApps.CheckedChanged += CheckGpuApps_CheckedChanged;
+
+            checkFnLock.Checked = AppConfig.Is("fn_lock");
+            checkFnLock.CheckedChanged += CheckFnLock_CheckedChanged; ;
+
+            pictureHelp.Click += PictureHelp_Click;
+
+            buttonServices.Click += ButtonServices_Click;
+
+            InitVariBright();
+            InitServices();
+        }
+
+
+        private void InitServices()
+        {
+            if (OptimizationService.IsRunning()) buttonServices.Text = Properties.Strings.Stop;
+            else buttonServices.Text = Properties.Strings.Start;
+
+            labelServices.Text = Properties.Strings.AsusServicesRunning + ":  " + OptimizationService.GetRunningCount();
+            buttonServices.Enabled = true;
+
+        }
+
+        public void ServiesToggle()
+        {
+            buttonServices.Enabled = false;
+
+            if (OptimizationService.IsRunning())
+            {
+                labelServices.Text = Properties.Strings.StoppingServices + " ...";
+                Task.Run(() =>
+                {
+                    OptimizationService.StopAsusServices();
+                    BeginInvoke(delegate
+                    {
+                        InitServices();
+                    });
+                    Program.inputDispatcher.Init();
+                });
+            }
+            else
+            {
+                labelServices.Text = Properties.Strings.StartingServices + " ...";
+                Task.Run(() =>
+                {
+                    OptimizationService.StartAsusServices();
+                    BeginInvoke(delegate
+                    {
+                        InitServices();
+                    });
+                });
+            }
+        }
+
+        private void ButtonServices_Click(object? sender, EventArgs e)
+        {
+            if (ProcessHelper.IsUserAdministrator())
+                ServiesToggle();
+            else
+                ProcessHelper.RunAsAdmin("services");
+        }
+
+        private void InitVariBright()
+        {
+            try
+            {
+                using (var amdControl = new AmdGpuControl())
+                {
+                    int variBrightSupported = 0, VariBrightEnabled;
+                    if (amdControl.GetVariBright(out variBrightSupported, out VariBrightEnabled))
+                    {
+                        Logger.WriteLine("Varibright: " + variBrightSupported + "," + VariBrightEnabled);
+                        checkVariBright.Checked = (VariBrightEnabled == 3);
+                    }
+
+                    checkVariBright.Visible = (variBrightSupported > 0);
+                    checkVariBright.CheckedChanged += CheckVariBright_CheckedChanged;
+                }
+
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.ToString());
+                checkVariBright.Visible = false;
+            }
+
+
+        }
+
+        private void CheckVariBright_CheckedChanged(object? sender, EventArgs e)
+        {
+            using (var amdControl = new AmdGpuControl())
+            {
+                amdControl.SetVariBright(checkVariBright.Checked ? 1 : 0);
+                ProcessHelper.KillByName("RadeonSoftware");
+            }
+        }
+
+        private void CheckFnLock_CheckedChanged(object? sender, EventArgs e)
+        {
+            int fnLock = checkFnLock.Checked ? 1 : 0;
+            AppConfig.Set("fn_lock", fnLock);
+            Program.acpi.DeviceSet(AsusACPI.FnLock, (fnLock == 1) ? 0 : 1, "FnLock");
+
+            Program.inputDispatcher.RegisterKeys();
+        }
+
+        private void CheckGpuApps_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("kill_gpu_apps", (checkGpuApps.Checked ? 1 : 0));
+        }
+
+        private void NumericBacklightTime_ValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("keyboard_timeout", (int)numericBacklightTime.Value);
+            AppConfig.Set("keyboard_ac_timeout", (int)numericBacklightPluggedTime.Value);
+            Program.inputDispatcher.InitBacklightTimer();
+        }
+
+        private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("xmg_light", (checkXMG.Checked ? 1 : 0));
+            AsusUSB.ApplyXGMLight(checkXMG.Checked);
+        }
+
+        private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
+        }
+
+        private void TrackBrightness_Scroll(object? sender, EventArgs e)
+        {
+            AppConfig.Set("keyboard_brightness", trackBrightness.Value);
+            AppConfig.Set("keyboard_brightness_ac", trackBrightness.Value);
+            AsusUSB.ApplyBrightness(trackBrightness.Value, "Slider");
+        }
+
+        private void PictureHelp_Click(object? sender, EventArgs e)
+        {
+            Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper#custom-hotkey-actions") { UseShellExecute = true });
+        }
+
+        private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
+            screenControl.AutoScreen(true);
+        }
+
+
+        private void CheckTopmost_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("topmost", (checkTopmost.Checked ? 1 : 0));
+            Program.settingsForm.TopMost = checkTopmost.Checked;
+        }
+
+        private void CheckPower_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("keyboard_awake", (checkAwake.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot", (checkBoot.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep", (checkSleep.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown", (checkShutdown.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_bar", (checkAwakeBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_bar", (checkBootBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_bar", (checkSleepBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_bar", (checkShutdownBar.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_lid", (checkAwakeLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_lid", (checkBootLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_lid", (checkSleepLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_lid", (checkShutdownLid.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_logo", (checkAwakeLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_logo", (checkBootLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_logo", (checkShutdownLogo.Checked ? 1 : 0));
+
+            List<AuraDev19b6> flags = new List<AuraDev19b6>();
+
+            if (checkAwake.Checked) flags.Add(AuraDev19b6.AwakeKeyb);
+            if (checkBoot.Checked) flags.Add(AuraDev19b6.BootKeyb);
+            if (checkSleep.Checked) flags.Add(AuraDev19b6.SleepKeyb);
+            if (checkShutdown.Checked) flags.Add(AuraDev19b6.ShutdownKeyb);
+
+            if (checkAwakeBar.Checked) flags.Add(AuraDev19b6.AwakeBar);
+            if (checkBootBar.Checked) flags.Add(AuraDev19b6.BootBar);
+            if (checkSleepBar.Checked) flags.Add(AuraDev19b6.SleepBar);
+            if (checkShutdownBar.Checked) flags.Add(AuraDev19b6.ShutdownBar);
+
+            if (checkAwakeLid.Checked) flags.Add(AuraDev19b6.AwakeLid);
+            if (checkBootLid.Checked) flags.Add(AuraDev19b6.BootLid);
+            if (checkSleepLid.Checked) flags.Add(AuraDev19b6.SleepLid);
+            if (checkShutdownLid.Checked) flags.Add(AuraDev19b6.ShutdownLid);
+
+            if (checkAwakeLogo.Checked) flags.Add(AuraDev19b6.AwakeLogo);
+            if (checkBootLogo.Checked) flags.Add(AuraDev19b6.BootLogo);
+            if (checkSleepLogo.Checked) flags.Add(AuraDev19b6.SleepLogo);
+            if (checkShutdownLogo.Checked) flags.Add(AuraDev19b6.ShutdownLogo);
+
+            AsusUSB.ApplyAuraPower(flags);
+
+        }
+
+        private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
+            Program.settingsForm.SetAura();
+        }
+
+
+        private void Keyboard_Shown(object? sender, EventArgs e)
+        {
+            if (Height > Program.settingsForm.Height)
+            {
+                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+            }
+            else
+            {
+                Top = Program.settingsForm.Top;
+            }
+
+            Left = Program.settingsForm.Left - Width - 5;
+        }
+
+        private void checkAutoApplyWindowsPowerMode_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("auto_apply_power_plan", checkAutoApplyWindowsPowerMode.Checked ? 1 : 0);
+        }
+    }
+}

app/Extra.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

app/Fans.resx

@@ -1,4 +1,64 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -57,4 +117,7 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="labelRisky.Text" xml:space="preserve">
+    <value>Undervolting is experimental and risky feature. If applied values are too low for your hardware, it can become unstable or shut down. Try small negative values first, click Apply and test what works for you.</value>
+  </data>
 </root>

app/GHelper.csproj

@@ -13,26 +13,26 @@
     <Platforms>AnyCPU;x64</Platforms>
     <SupportedOSPlatformVersion>8.0</SupportedOSPlatformVersion>
     <AssemblyName>GHelper</AssemblyName>
-    <PlatformTarget>x64</PlatformTarget>
+    <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.54</AssemblyVersion>
+    <AssemblyVersion>0.92</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DebugType>none</DebugType>
+    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <DebugType>none</DebugType>
+    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <DebugType>none</DebugType>
+    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <DebugType>none</DebugType>
+    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <ItemGroup>
@@ -59,8 +59,10 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="FftSharp" Version="2.0.0" />
     <PackageReference Include="hidlibrary" Version="3.3.40" />
     <PackageReference Include="HidSharpCore" Version="1.2.1.1" />
+    <PackageReference Include="NAudio" Version="2.1.0" />
     <PackageReference Include="NvAPIWrapper.Net" Version="0.8.1.101" />
     <PackageReference Include="System.Management" Version="7.0.1" />
     <PackageReference Include="TaskScheduler" Version="2.10.1" />
@@ -132,6 +134,12 @@
       <Generator>SettingsSingleFileGenerator</Generator>
       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
     </None>
+    <None Update="WinRing0x64.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="WinRing0x64.sys">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
 </Project>

app/GHelper.sln

@@ -20,8 +20,8 @@ Global
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.Build.0 = Debug|x64
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.ActiveCfg = Debug|x64
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Debug|x64
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Debug|Any CPU
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.ActiveCfg = Release|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.Build.0 = Release|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|x64.ActiveCfg = Release|x64

app/Gpu/AMD/AmdAdl2.cs

@@ -1,18 +1,47 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
 
-namespace AmdAdl2;
+namespace GHelper.Gpu.AMD;
 
 #region Export Struct
 
+[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+public struct ADLSGApplicationInfo
+{
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strFileName;
+
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strFilePath;
+
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strVersion;
+
+    public long timeStamp;
+    public uint iProfileExists;
+    public uint iGPUAffinity;
+    public ADLBdf GPUBdf;
+}
+
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLSingleSensorData {
+public struct ADLBdf
+{
+    public int iBus;
+    public int iDevice;
+    public int iFunction;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLSingleSensorData
+{
     public int Supported;
     public int Value;
 }
 
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLPMLogDataOutput {
+public struct ADLPMLogDataOutput
+{
     int Size;
 
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_PMLOG_MAX_SENSORS)]
@@ -30,7 +59,8 @@ public struct ADLGcnInfo
 }
 
 [Flags]
-public enum ADLAsicFamilyType {
+public enum ADLAsicFamilyType
+{
     Undefined = 0,
     Discrete = 1 << 0,
     Integrated = 1 << 1,
@@ -42,7 +72,8 @@ public enum ADLAsicFamilyType {
     Embedded = 1 << 7,
 }
 
-public enum ADLSensorType {
+public enum ADLSensorType
+{
     SENSOR_MAXTYPES = 0,
     PMLOG_CLK_GFXCLK = 1, // Current graphic clock value in MHz
     PMLOG_CLK_MEMCLK = 2, // Current memory clock value in MHz
@@ -122,13 +153,15 @@ public enum ADLSensorType {
 
 //Throttle Status
 [Flags]
-public enum ADL_THROTTLE_NOTIFICATION {
+public enum ADL_THROTTLE_NOTIFICATION
+{
     ADL_PMLOG_THROTTLE_POWER = 1 << 0,
     ADL_PMLOG_THROTTLE_THERMAL = 1 << 1,
     ADL_PMLOG_THROTTLE_CURRENT = 1 << 2,
 };
 
-public enum ADL_PMLOG_SENSORS {
+public enum ADL_PMLOG_SENSORS
+{
     ADL_SENSOR_MAXTYPES = 0,
     ADL_PMLOG_CLK_GFXCLK = 1,
     ADL_PMLOG_CLK_MEMCLK = 2,
@@ -210,7 +243,8 @@ public enum ADL_PMLOG_SENSORS {
 
 /// <summary> ADLAdapterInfo Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLAdapterInfo {
+public struct ADLAdapterInfo
+{
     /// <summary>The size of the structure</summary>
     int Size;
 
@@ -265,7 +299,8 @@ public struct ADLAdapterInfo {
 
 /// <summary> ADLAdapterInfo Array</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLAdapterInfoArray {
+public struct ADLAdapterInfoArray
+{
     /// <summary> ADLAdapterInfo Array </summary>
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_MAX_ADAPTERS)]
     public ADLAdapterInfo[] ADLAdapterInfo;
@@ -277,7 +312,8 @@ public struct ADLAdapterInfoArray {
 
 /// <summary> ADLDisplayID Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLDisplayID {
+public struct ADLDisplayID
+{
     /// <summary> Display Logical Index </summary>
     public int DisplayLogicalIndex;
 
@@ -293,7 +329,8 @@ public struct ADLDisplayID {
 
 /// <summary> ADLDisplayInfo Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLDisplayInfo {
+public struct ADLDisplayInfo
+{
     /// <summary> Display Index </summary>
     public ADLDisplayID DisplayID;
 
@@ -328,7 +365,8 @@ public struct ADLDisplayInfo {
 
 #endregion Export Struct
 
-public class Adl2 {
+public class Adl2
+{
     public const string Atiadlxx_FileName = "atiadlxx.dll";
 
     #region Internal Constant
@@ -371,24 +409,30 @@ public class Adl2 {
     // ///// <summary> ADL Create Function to create ADL Data</summary>
     /// <param name="enumConnectedAdapters">If it is 1, then ADL will only return the physical exist adapters </param>
     ///// <returns> retrun ADL Error Code</returns>
-    public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out IntPtr adlContextHandle) {
+    public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out nint adlContextHandle)
+    {
         return NativeMethods.ADL2_Main_Control_Create(ADL_Main_Memory_Alloc_Impl_Reference, enumConnectedAdapters, out adlContextHandle);
     }
 
-    public static void FreeMemory(IntPtr buffer) {
+    public static void FreeMemory(nint buffer)
+    {
         Memory_Free_Impl(buffer);
     }
 
     private static bool? isDllLoaded;
 
-    public static bool Load() {
+    public static bool Load()
+    {
         if (isDllLoaded != null)
             return isDllLoaded.Value;
 
-        try {
+        try
+        {
             Marshal.PrelinkAll(typeof(Adl2));
             isDllLoaded = true;
-        } catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException) {
+        }
+        catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException)
+        {
             Debug.WriteLine(e);
             isDllLoaded = false;
         }
@@ -396,53 +440,57 @@ public class Adl2 {
         return isDllLoaded.Value;
     }
 
-    private static NativeMethods.ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
+    private static ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
 
     /// <summary> Build in memory allocation function</summary>
     /// <param name="size">input size</param>
     /// <returns>return the memory buffer</returns>
-    private static IntPtr Memory_Alloc_Impl(int size) {
+    private static nint Memory_Alloc_Impl(int size)
+    {
         return Marshal.AllocCoTaskMem(size);
     }
 
     /// <summary> Build in memory free function</summary>
     /// <param name="buffer">input buffer</param>
-    private static void Memory_Free_Impl(IntPtr buffer) {
-        if (IntPtr.Zero != buffer) {
+    private static void Memory_Free_Impl(nint buffer)
+    {
+        if (nint.Zero != buffer)
+        {
             Marshal.FreeCoTaskMem(buffer);
         }
     }
 
-    public static class NativeMethods {
+    public static class NativeMethods
+    {
         /// <summary> ADL Memory allocation function allows ADL to callback for memory allocation</summary>
         /// <param name="size">input size</param>
         /// <returns> retrun ADL Error Code</returns>
-        public delegate IntPtr ADL_Main_Memory_Alloc(int size);
+        public delegate nint ADL_Main_Memory_Alloc(int size);
 
         // ///// <summary> ADL Create Function to create ADL Data</summary>
         /// <param name="callback">Call back functin pointer which is ised to allocate memeory </param>
         /// <param name="enumConnectedAdapters">If it is 1, then ADL will only retuen the physical exist adapters </param>
         ///// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out IntPtr adlContextHandle);
+        public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out nint adlContextHandle);
 
         /// <summary> ADL Destroy Function to free up ADL Data</summary>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Main_Control_Destroy(IntPtr adlContextHandle);
+        public static extern int ADL2_Main_Control_Destroy(nint adlContextHandle);
 
         /// <summary> ADL Function to get the number of adapters</summary>
         /// <param name="numAdapters">return number of adapters</param>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_NumberOfAdapters_Get(IntPtr adlContextHandle, out int numAdapters);
+        public static extern int ADL2_Adapter_NumberOfAdapters_Get(nint adlContextHandle, out int numAdapters);
 
         /// <summary> ADL Function to get the GPU adapter information</summary>
         /// <param name="info">return GPU adapter information</param>
         /// <param name="inputSize">the size of the GPU adapter struct</param>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_AdapterInfo_Get(IntPtr adlContextHandle, IntPtr info, int inputSize);
+        public static extern int ADL2_Adapter_AdapterInfo_Get(nint adlContextHandle, nint info, int inputSize);
 
         /// <summary> Function to determine if the adapter is active or not.</summary>
         /// <remarks>The function is used to check if the adapter associated with iAdapterIndex is active</remarks>  
@@ -450,7 +498,7 @@ public class Adl2 {
         /// <param name="status"> Status of the adapter. True: Active; False: Dsiabled</param>
         /// <returns>Non zero is successfull</returns> 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_Active_Get(IntPtr adlContextHandle, int adapterIndex, out int status);
+        public static extern int ADL2_Adapter_Active_Get(nint adlContextHandle, int adapterIndex, out int status);
 
         /// <summary>Get display information based on adapter index</summary>
         /// <param name="adapterIndex">Adapter Index</param>
@@ -460,16 +508,16 @@ public class Adl2 {
         /// <returns>return ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Display_DisplayInfo_Get(
-            IntPtr adlContextHandle,
+            nint adlContextHandle,
             int adapterIndex,
             out int numDisplays,
-            out IntPtr displayInfoArray,
+            out nint displayInfoArray,
             int forceDetect
         );
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Overdrive_Caps(
-            IntPtr adlContextHandle,
+            nint adlContextHandle,
             int adapterIndex,
             out int supported,
             out int enabled,
@@ -477,9 +525,75 @@ public class Adl2 {
         );
 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_New_QueryPMLogData_Get(IntPtr adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
+        public static extern int ADL2_New_QueryPMLogData_Get(nint adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_ASICFamilyType_Get(IntPtr adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
+        public static extern int ADL2_Adapter_ASICFamilyType_Get(nint adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_SwitchableGraphics_Applications_Get(
+            nint context,
+            int iListType,
+            out int lpNumApps,
+            out nint lppAppList);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_VariBright_Caps(
+            nint context,
+            int iAdapterIndex,
+            out int iSupported,
+            out int iEnabled,
+            out int iVersion);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_VariBrightEnable_Set(
+            nint context,
+            int iAdapterIndex,
+            int iEnabled);
+
+        // Clocks
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLODNPerformanceLevel
+        {
+            public int iClock;
+            public int iVddc;
+            public int iEnabled;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLODNPerformanceLevels
+        {
+            public int iSize;
+            public int iMode;
+            public int iNumberOfPerformanceLevels;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
+            public ADLODNPerformanceLevel[] aLevels;
+        }
+
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_SystemClocks_Get(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_SystemClocks_Set(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_MemoryClocks_Get(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_MemoryClocks_Set(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
     }
 }

app/Gpu/AMD/AmdGpuControl.cs

@@ -0,0 +1,234 @@
+using GHelper.Helpers;
+using System.Runtime.InteropServices;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
+
+namespace GHelper.Gpu.AMD;
+
+// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
+public class AmdGpuControl : IGpuControl
+{
+    private bool _isReady;
+    private nint _adlContextHandle;
+    private readonly ADLAdapterInfo _internalDiscreteAdapter;
+
+    public bool IsNvidia => false;
+
+    public string FullName => _internalDiscreteAdapter!.AdapterName;
+
+    private ADLAdapterInfo? FindByType(ADLAsicFamilyType type = ADLAsicFamilyType.Discrete)
+    {
+        ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
+        if (numberOfAdapters <= 0)
+            return null;
+
+        ADLAdapterInfoArray osAdapterInfoData = new();
+        int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
+        nint AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
+        Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
+        if (ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
+            return null;
+
+        osAdapterInfoData = (ADLAdapterInfoArray)Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
+
+        const int amdVendorId = 1002;
+
+        // Determine which GPU is internal discrete AMD GPU
+        ADLAdapterInfo internalDiscreteAdapter =
+            osAdapterInfoData.ADLAdapterInfo
+                .FirstOrDefault(adapter =>
+                {
+                    if (adapter.Exist == 0 || adapter.Present == 0)
+                        return false;
+
+                    if (adapter.VendorID != amdVendorId)
+                        return false;
+
+                    if (ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
+                        return false;
+
+                    asicFamilyType = (ADLAsicFamilyType)((int)asicFamilyType & asicFamilyTypeValids);
+
+                    return (asicFamilyType & type) != 0;
+                });
+
+        if (internalDiscreteAdapter.Exist == 0)
+            return null;
+
+        return internalDiscreteAdapter;
+
+    }
+
+    public AmdGpuControl()
+    {
+        if (!Adl2.Load())
+            return;
+
+        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
+            return;
+
+        ADLAdapterInfo? internalDiscreteAdapter = FindByType(ADLAsicFamilyType.Discrete);
+
+        if (internalDiscreteAdapter is not null)
+        {
+            _internalDiscreteAdapter = (ADLAdapterInfo)internalDiscreteAdapter;
+            _isReady = true;
+        }
+
+    }
+
+    public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
+
+    public int? GetCurrentTemperature()
+    {
+        if (!IsValid)
+            return null;
+
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
+            return null;
+
+        ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_TEMPERATURE_EDGE];
+        if (temperatureSensor.Supported == 0)
+            return null;
+
+        return temperatureSensor.Value;
+    }
+
+
+    public int? GetGpuUse()
+    {
+        if (!IsValid) return null;
+
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
+            return null;
+
+        ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_INFO_ACTIVITY_GFX];
+        if (gpuUsage.Supported == 0)
+            return null;
+
+        return gpuUsage.Value;
+
+    }
+
+
+    public bool SetVariBright(int enabled)
+    {
+        if (_adlContextHandle == nint.Zero) return false;
+
+        ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
+        if (iGPU is null) return false;
+
+        return ADL2_Adapter_VariBrightEnable_Set(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, enabled) == Adl2.ADL_SUCCESS;
+
+    }
+
+    public bool GetVariBright(out int supported, out int enabled)
+    {
+        supported = enabled = -1;
+
+        if (_adlContextHandle == nint.Zero) return false;
+
+        ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
+        if (iGPU is null) return false;
+
+        if (ADL2_Adapter_VariBright_Caps(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, out int supportedOut, out int enabledOut, out int version) != Adl2.ADL_SUCCESS)
+            return false;
+
+        supported = supportedOut;
+        enabled = enabledOut;
+
+        return true;
+    }
+
+    public ADLODNPerformanceLevels? GetGPUClocks()
+    {
+        if (!IsValid) return null;
+
+        ADLODNPerformanceLevels performanceLevels = new();
+        ADL2_OverdriveN_SystemClocks_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, ref performanceLevels);
+
+        return performanceLevels;
+    }
+
+    public void KillGPUApps()
+    {
+
+        if (!IsValid) return;
+
+        nint appInfoPtr = nint.Zero;
+        int appCount = 0;
+
+        try
+        {
+            // Get switchable graphics applications information
+            var result = ADL2_SwitchableGraphics_Applications_Get(_adlContextHandle, 2, out appCount, out appInfoPtr);
+            if (result != 0)
+            {
+                throw new Exception("Failed to get switchable graphics applications. Error code: " + result);
+            }
+
+            // Convert the application data pointers to an array of structs
+            var appInfoArray = new ADLSGApplicationInfo[appCount];
+            nint currentPtr = appInfoPtr;
+
+            for (int i = 0; i < appCount; i++)
+            {
+                appInfoArray[i] = Marshal.PtrToStructure<ADLSGApplicationInfo>(currentPtr);
+                currentPtr = nint.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
+            }
+
+            var appNames = new List<string>();
+
+            for (int i = 0; i < appCount; i++)
+            {
+                if (appInfoArray[i].iGPUAffinity == 1)
+                {
+                    Logger.WriteLine(appInfoArray[i].strFileName + ":" + appInfoArray[i].iGPUAffinity + "(" + appInfoArray[i].timeStamp + ")");
+                    appNames.Add(Path.GetFileNameWithoutExtension(appInfoArray[i].strFileName));
+                }
+            }
+
+            List<string> immune = new() { "svchost", "system", "ntoskrnl", "csrss", "winlogon", "wininit", "smss" };
+
+            foreach (string kill in appNames)
+                if (!immune.Contains(kill.ToLower()))
+                    ProcessHelper.KillByName(kill);
+
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.Message);
+        }
+        finally
+        {
+            // Clean up resources
+            if (appInfoPtr != nint.Zero)
+            {
+                Marshal.FreeCoTaskMem(appInfoPtr);
+            }
+
+        }
+    }
+
+
+    private void ReleaseUnmanagedResources()
+    {
+        if (_adlContextHandle != nint.Zero)
+        {
+            ADL2_Main_Control_Destroy(_adlContextHandle);
+            _adlContextHandle = nint.Zero;
+            _isReady = false;
+        }
+    }
+
+    public void Dispose()
+    {
+        ReleaseUnmanagedResources();
+        GC.SuppressFinalize(this);
+    }
+
+    ~AmdGpuControl()
+    {
+        ReleaseUnmanagedResources();
+    }
+}

app/Gpu/AmdGpuTemperatureProvider.cs

@@ -1,110 +0,0 @@
-using System.Runtime.InteropServices;
-using AmdAdl2;
-
-namespace GHelper.Gpu;
-
-// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
-public class AmdGpuTemperatureProvider : IGpuTemperatureProvider {
-    private bool _isReady;
-    private IntPtr _adlContextHandle;
-    private readonly ADLAdapterInfo _internalDiscreteAdapter;
-
-    public AmdGpuTemperatureProvider() {
-        if (!Adl2.Load())
-            return;
-
-        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
-            return;
-
-        Adl2.NativeMethods.ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
-        if (numberOfAdapters <= 0)
-            return;
-
-        ADLAdapterInfoArray osAdapterInfoData = new();
-        int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
-        IntPtr AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
-        Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
-        if (Adl2.NativeMethods.ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
-            return;
-
-        osAdapterInfoData = (ADLAdapterInfoArray) Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
-
-        const int amdVendorId = 1002;
-        
-        // Determine which GPU is internal discrete AMD GPU
-        ADLAdapterInfo internalDiscreteAdapter = 
-            osAdapterInfoData.ADLAdapterInfo
-                .FirstOrDefault(adapter => {
-                    if (adapter.Exist == 0 || adapter.Present == 0)
-                        return false;
-                    
-                    if (adapter.VendorID != amdVendorId)
-                        return false;
-
-                    if (Adl2.NativeMethods.ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
-                        return false;
-
-                    asicFamilyType = (ADLAsicFamilyType) ((int) asicFamilyType & asicFamilyTypeValids);
-                    
-                    // FIXME: is this correct for G14 2022?
-                    return (asicFamilyType & ADLAsicFamilyType.Discrete) != 0; 
-                });
-        
-        if (internalDiscreteAdapter.Exist == 0)
-            return;
-
-        _internalDiscreteAdapter = internalDiscreteAdapter;
-        _isReady = true;
-    }
-
-    public bool IsValid => _isReady && _adlContextHandle != IntPtr.Zero;
-
-    public int? GetCurrentTemperature() {
-        if (!IsValid)
-            return null;
-        
-        if (Adl2.NativeMethods.ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
-            return null;
-        
-        ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int) ADLSensorType.PMLOG_TEMPERATURE_EDGE];
-        if (temperatureSensor.Supported == 0)
-            return null;
-
-        return temperatureSensor.Value;
-    }
-
-
-    public int? GetGpuUse()
-    {
-        if (!IsValid)
-            return null;
-
-        if (Adl2.NativeMethods.ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
-            return null;
-
-        ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_INFO_ACTIVITY_GFX];
-        if (gpuUsage.Supported == 0)
-            return null;
-
-        return gpuUsage.Value;
-
-    }
-
-
-    private void ReleaseUnmanagedResources() {
-        if (_adlContextHandle != IntPtr.Zero) {
-            Adl2.NativeMethods.ADL2_Main_Control_Destroy(_adlContextHandle);
-            _adlContextHandle = IntPtr.Zero;
-            _isReady = false;
-        }
-    }
-
-    public void Dispose() {
-        ReleaseUnmanagedResources();
-        GC.SuppressFinalize(this);
-    }
-
-    ~AmdGpuTemperatureProvider() {
-        ReleaseUnmanagedResources();
-    }
-}

app/Gpu/GPUModeControl.cs

@@ -0,0 +1,317 @@
+using GHelper.Display;
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using System.Diagnostics;
+
+namespace GHelper.Gpu
+{
+    public class GPUModeControl
+    {
+        static SettingsForm settings = Program.settingsForm;
+        ScreenControl screenControl = new ScreenControl();
+
+        public void InitGPUMode()
+        {
+            int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+            int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
+
+            Logger.WriteLine("Eco flag : " + eco);
+            Logger.WriteLine("Mux flag : " + mux);
+
+            int GpuMode;
+
+            if (mux == 0)
+            {
+                GpuMode = AsusACPI.GPUModeUltimate;
+            }
+            else
+            {
+                if (eco == 1)
+                    GpuMode = AsusACPI.GPUModeEco;
+                else
+                    GpuMode = AsusACPI.GPUModeStandard;
+
+                // Ultimate mode not suported
+                if (mux != 1) settings.HideUltimateMode();
+                // GPU mode not supported
+                if (eco < 0 && mux < 0) settings.HideGPUModes();
+            }
+
+            AppConfig.Set("gpu_mode", GpuMode);
+
+            InitXGM();
+            settings.VisualiseGPUMode(GpuMode);
+        }
+
+
+        public void SetGPUMode(int GPUMode)
+        {
+
+            int CurrentGPU = AppConfig.Get("gpu_mode");
+            AppConfig.Set("gpu_auto", 0);
+
+            if (CurrentGPU == GPUMode)
+            {
+                settings.VisualiseGPUMode();
+                return;
+            }
+
+            var restart = false;
+            var changed = false;
+
+            if (CurrentGPU == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+            }
+            else if (GPUMode == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+
+            }
+            else if (GPUMode == AsusACPI.GPUModeEco)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(1, true);
+                changed = true;
+            }
+            else if (GPUMode == AsusACPI.GPUModeStandard)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(0);
+                changed = true;
+            }
+
+            if (changed)
+            {
+                AppConfig.Set("gpu_mode", GPUMode);
+            }
+
+            if (restart)
+            {
+                settings.VisualiseGPUMode();
+                Process.Start("shutdown", "/r /t 1");
+            }
+
+        }
+
+
+
+        public void SetGPUEco(int eco, bool hardWay = false)
+        {
+
+            settings.LockGPUModes();
+
+            Task.Run(async () =>
+            {
+
+                int status = 1;
+
+                if (eco == 1)
+                {
+                    if (NvidiaSmi.GetDisplayActiveStatus())
+                    {
+                        DialogResult dialogResult = MessageBox.Show(Properties.Strings.EnableOptimusText, Properties.Strings.EnableOptimusTitle, MessageBoxButtons.YesNo);
+                        if (dialogResult == DialogResult.No)
+                        {
+                            InitGPUMode();
+                            return;
+                        }
+                    }
+
+                    HardwareControl.KillGPUApps();
+                }
+
+                Logger.WriteLine($"Running eco command {eco}");
+
+                status = Program.acpi.SetGPUEco(eco);
+
+                if (status == 0 && eco == 1 && hardWay) RestartGPU();
+
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
+                
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                    screenControl.AutoScreen();
+                });
+
+                if (eco == 0)
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    HardwareControl.RecreateGpuControl();
+                    Program.modeControl.SetGPUClocks(false);
+                }
+
+            });
+
+
+        }
+
+        public static bool IsPlugged()
+        {
+            bool optimizedUSBC = AppConfig.Get("optimized_usbc") != 1;
+
+            return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online &&
+                   (optimizedUSBC || Program.acpi.DeviceGet(AsusACPI.ChargerMode) < AsusACPI.ChargerUSB);
+
+        }
+
+        public bool AutoGPUMode()
+        {
+
+            bool GpuAuto = AppConfig.Is("gpu_auto");
+            bool ForceGPU = AppConfig.ContainsModel("503");
+
+            int GpuMode = AppConfig.Get("gpu_mode");
+
+            if (!GpuAuto && !ForceGPU) return false;
+
+            int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+            int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
+
+            if (mux == 0) // GPU in Ultimate, ignore
+                return false;
+            else
+            {
+
+                if (ReEnableGPU()) return true;
+
+                if (eco == 1)
+                    if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
+                    {
+                        SetGPUEco(0);
+                        return true;
+                    }
+                if (eco == 0)
+                    if ((GpuAuto && !IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeEco))
+                    {
+
+                        if (HardwareControl.IsUsedGPU())
+                        {
+                            DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertDGPU, Properties.Strings.AlertDGPUTitle, MessageBoxButtons.YesNo);
+                            if (dialogResult == DialogResult.No) return false;
+                        }
+
+                        SetGPUEco(1);
+                        return true;
+                    }
+            }
+
+            return false;
+
+        }
+
+
+        public void RestartGPU(bool confirm = true)
+        {
+            if (HardwareControl.GpuControl is null) return;
+            if (!HardwareControl.GpuControl!.IsNvidia) return;
+
+            if (confirm)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.RestartGPU, Properties.Strings.EcoMode, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.No) return;
+            }
+
+            ProcessHelper.RunAsAdmin("gpurestart");
+
+            if (!ProcessHelper.IsUserAdministrator()) return;
+
+            Logger.WriteLine("Trying to restart dGPU");
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes("Restarting GPU ...");
+
+                var nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+                bool status = nvControl.RestartGPU();
+
+                settings.Invoke(delegate
+                {
+                    //labelTipGPU.Text = status ? "GPU Restarted, you can try Eco mode again" : "Failed to restart GPU"; TODO
+                    InitGPUMode();
+                });
+            });
+
+        }
+
+
+        public bool ReEnableGPU()
+        {
+
+            if (AppConfig.Get("gpu_reenable") != 1) return false;
+            if (Screen.AllScreens.Length <= 1) return false;
+
+            Logger.WriteLine("Re-enabling gpu for 503 model");
+
+            Thread.Sleep(1000);
+            SetGPUEco(1);
+            Thread.Sleep(1000);
+            SetGPUEco(0);
+            return true;
+        }
+
+        public void InitXGM()
+        {
+            bool connected = Program.acpi.IsXGConnected();
+            int activated = Program.acpi.DeviceGet(AsusACPI.GPUXG);
+            settings.VisualizeXGM(connected, activated == 1);
+        }
+
+        public void ToggleXGM()
+        {
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes();
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
+                {
+                    HardwareControl.KillGPUApps();
+                    DialogResult dialogResult = MessageBox.Show("Did you close all applications running on XG Mobile?", "Disabling XG Mobile", MessageBoxButtons.YesNo);
+                    if (dialogResult == DialogResult.Yes)
+                    {
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 0, "GPU XGM");
+                        await Task.Delay(TimeSpan.FromSeconds(15));
+                    }
+                }
+                else
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
+                    AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
+
+                    await Task.Delay(TimeSpan.FromSeconds(15));
+
+                    if (AppConfig.IsMode("auto_apply"))
+                        AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                }
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                });
+            });
+        }
+
+        public void KillGPUApps()
+        {
+            if (HardwareControl.GpuControl is not null)
+            {
+                HardwareControl.GpuControl.KillGPUApps();
+            }
+        }
+
+    }
+}

app/Gpu/IGpuControl.cs

@@ -0,0 +1,11 @@
+namespace GHelper.Gpu;
+
+public  interface IGpuControl : IDisposable {
+    bool IsNvidia { get; }
+    bool IsValid { get; }
+    public string FullName { get; }
+    int? GetCurrentTemperature();
+    int? GetGpuUse();
+    void KillGPUApps();
+
+}

app/Gpu/IGpuTemperatureProvider.cs

@@ -1,7 +0,0 @@
-namespace GHelper.Gpu;
-
-public interface IGpuTemperatureProvider : IDisposable {
-    bool IsValid { get; }
-    int? GetCurrentTemperature();
-    int? GetGpuUse();
-}

app/Gpu/NVidia/NvidiaGpuControl.cs

@@ -0,0 +1,199 @@
+using GHelper.Helpers;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.GPU;
+using System.Diagnostics;
+using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
+
+namespace GHelper.Gpu.NVidia;
+
+public class NvidiaGpuControl : IGpuControl
+{
+
+    public static int MaxCoreOffset => AppConfig.Get("max_gpu_core", 250);
+    public static int MaxMemoryOffset => AppConfig.Get("max_gpu_memory", 250);
+
+    public const int MinCoreOffset = -250;
+    public const int MinMemoryOffset = -250;
+
+    private static PhysicalGPU? _internalGpu;
+
+    public NvidiaGpuControl()
+    {
+        _internalGpu = GetInternalDiscreteGpu();
+    }
+
+    public bool IsValid => _internalGpu != null;
+
+    public bool IsNvidia => IsValid;
+
+    public string FullName => _internalGpu!.FullName;
+
+    public int? GetCurrentTemperature()
+    {
+        if (!IsValid) return null;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+        IThermalSensor? gpuSensor =
+            GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
+            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
+
+        return gpuSensor?.CurrentTemperature;
+    }
+
+    public void Dispose()
+    {
+    }
+
+    public void KillGPUApps()
+    {
+
+        if (!IsValid) return;
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        try
+        {
+            Process[] processes = internalGpu.GetActiveApplications();
+            foreach (Process process in processes)
+                try
+                {
+                    Logger.WriteLine("Kill:" + process.ProcessName);
+                    ProcessHelper.KillByProcess(process);
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.Message);
+        }
+
+        //NVIDIA.RestartDisplayDriver();
+    }
+
+
+    public int GetClocks(out int core, out int memory)
+    {
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        //Logger.WriteLine(internalGpu.FullName);
+        //Logger.WriteLine(internalGpu.ArchitectInformation.ToString());
+
+        try
+        {
+            IPerformanceStates20Info states = GPUApi.GetPerformanceStates20(internalGpu.Handle);
+            core = states.Clocks[PerformanceStateId.P0_3DPerformance][0].FrequencyDeltaInkHz.DeltaValue / 1000;
+            memory = states.Clocks[PerformanceStateId.P0_3DPerformance][1].FrequencyDeltaInkHz.DeltaValue / 1000;
+            Logger.WriteLine($"GET GPU CLOCKS: {core}, {memory}");
+
+            foreach (var delta in states.Voltages[PerformanceStateId.P0_3DPerformance])
+            {
+                Logger.WriteLine("GPU VOLT:" + delta.IsEditable + " - " + delta.ValueDeltaInMicroVolt.DeltaValue);
+            }
+
+            return 0;
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("GET GPU CLOCKS:" + ex.Message);
+            core = memory = 0;
+            return -1;
+        }
+
+    }
+
+
+    public bool RestartGPU()
+    {
+        try
+        {
+            string script = @"$device = Get-PnpDevice | Where-Object { $_.FriendlyName -imatch 'NVIDIA' -and $_.Class -eq 'Display' }; Disable-PnpDevice $device.InstanceId -Confirm:$false; Start-Sleep -Seconds 3; Enable-PnpDevice $device.InstanceId -Confirm:$false";
+            Logger.WriteLine(script);
+            ProcessHelper.RunCMD("powershell", script);
+            //Thread.Sleep(2000);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.ToString());
+            return false;
+        }
+    }
+
+    public int SetClocksFromConfig()
+    {
+        int core = AppConfig.Get("gpu_core", 0);
+        int memory = AppConfig.Get("gpu_memory", 0);
+        int status = SetClocks(core, memory);
+        return status;
+    }
+
+    public int SetClocks(int core, int memory, int voltage = 0)
+    {
+
+        if (core < MinCoreOffset || core > MaxCoreOffset) return 0;
+        if (memory < MinMemoryOffset || memory > MaxMemoryOffset) return 0;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        var coreClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Graphics, new PerformanceStates20ParameterDelta(core * 1000));
+        var memoryClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Memory, new PerformanceStates20ParameterDelta(memory * 1000));
+        var voltageEntry = new PerformanceStates20BaseVoltageEntryV1(PerformanceVoltageDomain.Core, new PerformanceStates20ParameterDelta(voltage));
+
+        PerformanceStates20ClockEntryV1[] clocks = { coreClock, memoryClock };
+        PerformanceStates20BaseVoltageEntryV1[] voltages = { };
+
+        PerformanceState20[] performanceStates = { new PerformanceState20(PerformanceStateId.P0_3DPerformance, clocks, voltages) };
+
+        var overclock = new PerformanceStates20InfoV1(performanceStates, 2, 0);
+
+        try
+        {
+            Logger.WriteLine($"SET GPU CLOCKS: {core}, {memory}");
+            GPUApi.SetPerformanceStates20(internalGpu.Handle, overclock);
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("SET GPU CLOCKS: " + ex.Message);
+            return -1;
+        }
+
+
+
+        return 1;
+    }
+
+    private static PhysicalGPU? GetInternalDiscreteGpu()
+    {
+        try
+        {
+            return PhysicalGPU
+                .GetPhysicalGPUs()
+                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.Message);
+            return null;
+        }
+    }
+
+
+    public int? GetGpuUse()
+    {
+        if (!IsValid)
+            return null;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+        IUtilizationDomainInfo? gpuUsage = GPUApi.GetUsages(internalGpu.Handle).GPU;
+
+        return (int?)gpuUsage?.Percentage;
+
+    }
+
+}

app/Gpu/NVidia/NvidiaSmi.cs

@@ -0,0 +1,65 @@
+using Ryzen;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+
+public static class NvidiaSmi
+{
+    public static bool GetDisplayActiveStatus()
+    {
+        // Non AMD devices doesn't seem to be affected
+        if (!RyzenControl.IsAMD()) return false;
+
+        string commandOutput = RunNvidiaSmiCommand();
+
+        Logger.WriteLine(commandOutput);
+
+        if (commandOutput.Length == 0) return false;
+        if (!commandOutput.Contains("RTX 40")) return false;
+
+        // Extract the "Display Active" status using regular expressions
+        string displayActivePattern = @"Display Active\s+:\s+(\w+)";
+
+        Match match = Regex.Match(commandOutput, displayActivePattern, RegexOptions.IgnoreCase);
+
+        if (match.Success)
+        {
+            string status = match.Groups[1].Value.ToLower().Trim(' ');
+            return status == "enabled";
+        }
+
+        return false; // Return false if the "Display Active" status is not found
+    }
+
+    private static string RunNvidiaSmiCommand(string arguments = "-i 0 -q")
+    {
+        ProcessStartInfo startInfo = new ProcessStartInfo
+        {
+            FileName = "nvidia-smi",
+            Arguments = arguments,
+            RedirectStandardOutput = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        Process process = new Process
+        {
+            StartInfo = startInfo
+        };
+
+        try
+        {
+            process.Start();
+            string output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit();
+            return output;
+        }
+        catch (Exception ex)
+        {
+            //return File.ReadAllText(@"smi.txt");
+            Debug.WriteLine(ex.Message);
+        }
+
+        return "";
+
+    }
+}

app/Gpu/NvidiaGpuTemperatureProvider.cs

@@ -1,68 +0,0 @@
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace GHelper.Gpu;
-
-public class NvidiaGpuTemperatureProvider : IGpuTemperatureProvider
-{
-    private readonly PhysicalGPU? _internalGpu;
-
-    public NvidiaGpuTemperatureProvider()
-    {
-        _internalGpu = GetInternalDiscreteGpu();
-    }
-
-    public bool IsValid => _internalGpu != null;
-
-    public int? GetCurrentTemperature()
-    {
-        if (!IsValid)
-            return null;
-
-        PhysicalGPU internalGpu = _internalGpu!;
-        IThermalSensor? gpuSensor =
-            GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
-            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
-
-        return gpuSensor?.CurrentTemperature;
-    }
-
-    public void Dispose()
-    {
-    }
-
-    private static PhysicalGPU? GetInternalDiscreteGpu()
-    {
-        try
-        {
-            return PhysicalGPU
-                .GetPhysicalGPUs()
-                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
-        }
-        catch
-        {
-            return null;
-        }
-    }
-
-
-    public int? GetGpuUse()
-    {
-        if (!IsValid)
-            return null;
-
-        PhysicalGPU internalGpu = _internalGpu!;
-
-        IUtilizationDomainInfo? gpuUsage = GPUApi.GetUsages(internalGpu.Handle).GPU;
-
-        if (gpuUsage == null) 
-            return null;
-
-        return 
-            (int)gpuUsage?.Percentage;
-
-    }
-
-}

app/HardwareControl.cs

@@ -0,0 +1,210 @@
+using GHelper;
+using GHelper.Gpu;
+using GHelper.Gpu.NVidia;
+using GHelper.Gpu.AMD;
+
+using GHelper.Helpers;
+using System.Diagnostics;
+
+public static class HardwareControl
+{
+    public static IGpuControl? GpuControl;
+
+    public static float? cpuTemp = -1;
+    public static float? batteryDischarge = -1;
+    public static int? gpuTemp = null;
+
+    public static string? cpuFan;
+    public static string? gpuFan;
+    public static string? midFan;
+
+    public static int? gpuUse;
+
+    public static int GetFanMax()
+    {
+        int max = 58;
+        int configMax = AppConfig.Get("fan_max");
+        if (configMax > 100) configMax = 0; // skipping inadvequate settings
+
+        if (AppConfig.ContainsModel("401")) max = 72;
+        else if (AppConfig.ContainsModel("503")) max = 68;
+        return Math.Max(max, configMax);
+    }
+
+    public static void SetFanMax(int fan)
+    {
+        AppConfig.Set("fan_max", fan);
+    }
+    public static string FormatFan(int fan)
+    {
+        // fix for old models 
+        if (fan < 0)
+        {
+            fan += 65536;
+            if (fan <= 0 || fan > 100) return null; //nothing reasonable
+        }
+
+        int fanMax = GetFanMax();
+        if (fan > fanMax && fan < 110) SetFanMax(fan);
+
+        if (AppConfig.Is("fan_rpm"))
+            return GHelper.Properties.Strings.FanSpeed + (fan * 100).ToString() + "RPM";
+        else
+            return GHelper.Properties.Strings.FanSpeed + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
+    }
+
+    private static int GetGpuUse()
+    {
+        try
+        {
+            int? gpuUse = GpuControl?.GetGpuUse();
+            Logger.WriteLine("GPU usage: " + GpuControl?.FullName + " " + gpuUse + "%");
+            if (gpuUse is not null) return (int)gpuUse;
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.ToString());
+        }
+
+        return 0;
+    }
+
+
+    public static void ReadSensors()
+    {
+        batteryDischarge = -1;
+        gpuTemp = -1;
+        gpuUse = -1;
+
+        cpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.CPU_Fan));
+        gpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.GPU_Fan));
+        midFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.Mid_Fan));
+
+        cpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_CPU);
+
+        if (cpuTemp < 0) try
+            {
+                using (var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true))
+                {
+                    cpuTemp = ct.NextValue() - 273;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
+            }
+
+        try
+        {
+            gpuTemp = GpuControl?.GetCurrentTemperature();
+
+        }
+        catch (Exception ex)
+        {
+            gpuTemp = -1;
+            Debug.WriteLine("Failed reading GPU temp :" + ex.Message);
+        }
+
+        if (gpuTemp is null || gpuTemp < 0)
+            gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
+
+        try
+        {
+            using (var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true))
+            {
+                batteryDischarge = cb.NextValue() / 1000;
+            }
+        }
+        catch
+        {
+            Debug.WriteLine("Failed reading Battery discharge");
+        }
+    }
+
+    public static bool IsUsedGPU(int threshold = 10)
+    {
+        if (GetGpuUse() > threshold)
+        {
+            Thread.Sleep(1000);
+            return (GetGpuUse() > threshold);
+        }
+        return false;
+    }
+
+
+    public static NvidiaGpuControl? GetNvidiaGpuControl()
+    {
+        if ((bool)GpuControl?.IsNvidia)
+            return (NvidiaGpuControl)GpuControl;
+        else
+            return null;
+    }
+
+    public static void RecreateGpuControlWithDelay(int delay = 5)
+    {
+        // Re-enabling the discrete GPU takes a bit of time,
+        // so a simple workaround is to refresh again after that happens
+        Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromSeconds(delay));
+            RecreateGpuControl();
+        });
+    }
+
+    public static void RecreateGpuControl()
+    {
+        try
+        {
+            GpuControl?.Dispose();
+
+            IGpuControl _gpuControl = new NvidiaGpuControl();
+            
+            if (_gpuControl.IsValid)
+            {
+                GpuControl = _gpuControl;
+                Logger.WriteLine(GpuControl.FullName);
+                return;
+            }
+
+            _gpuControl.Dispose();
+
+            _gpuControl = new AmdGpuControl();
+            if (_gpuControl.IsValid)
+            {
+                GpuControl = _gpuControl;
+                Logger.WriteLine(GpuControl.FullName);
+                return;
+            }
+            _gpuControl.Dispose();
+
+            GpuControl = null;
+
+
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.ToString());
+        }
+    }
+
+
+    public static void KillGPUApps()
+    {
+
+        List<string> tokill = new() { "EADesktop", "RadeonSoftware", "epicgameslauncher", "ASUSSmartDisplayControl" };
+
+        if (AppConfig.Is("kill_gpu_apps"))
+        {
+            tokill.Add("nvdisplay.container");
+            tokill.Add("nvcontainer");
+            tokill.Add("nvcplui");
+        }
+
+        foreach (string kill in tokill) ProcessHelper.KillByName(kill);
+
+        if (AppConfig.Is("kill_gpu_apps") && GpuControl is not null)
+        {
+            GpuControl.KillGPUApps();
+        }
+    }
+}

app/HardwareMonitor.cs

@@ -1,175 +0,0 @@
-using GHelper;
-using GHelper.Gpu;
-using System.Diagnostics;
-using System.Management;
-
-public static class HardwareMonitor
-{
-    private static IGpuTemperatureProvider? GpuTemperatureProvider;
-
-    public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -1;
-    public static int? gpuTemp = null;
-
-    public static string? cpuFan;
-    public static string? gpuFan;
-    public static string? midFan;
-
-    public static int? gpuUse;
-
-    public static int GetFanMax()
-    {
-        int max = 58;
-        if (Program.config.ContainsModel("401")) max = 72;
-        else if (Program.config.ContainsModel("503")) max = 68;
-        return Math.Max(max, Program.config.getConfig("fan_max"));
-    }
-
-    public static void SetFanMax(int fan)
-    {
-        Program.config.setConfig("fan_max", fan);
-    }
-    private static string FormatFan(int fan)
-    {
-        // fix for old models 
-        if (fan < 0)
-        {
-            fan += 65536;
-            if (fan <= 0 || fan > 100) return null; //nothing reasonable
-        }
-
-        int fanMax = GetFanMax();
-        if (fan > fanMax) SetFanMax(fan);
-
-        if (Program.config.getConfig("fan_rpm") == 1)
-            return " Fan: " + (fan * 100).ToString() + "RPM";
-        else
-            return " Fan: " + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
-    }
-
-    private static int GetGpuUse()
-    {
-        try
-        {
-            int? gpuUse = GpuTemperatureProvider?.GetGpuUse();
-            if (gpuUse is not null) return (int)gpuUse;
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine(ex.ToString());
-        }
-
-        return 0;
-    }
-
-
-    public static void ReadSensors()
-    {
-        batteryDischarge = -1;
-        gpuTemp = -1;
-        gpuUse = -1;
-
-        cpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan));
-        gpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan));
-        midFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.Mid_Fan));
-
-        cpuTemp = Program.wmi.DeviceGet(ASUSWmi.Temp_CPU);
-
-        if (cpuTemp < 0) try
-        {
-            using (var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true))
-            {
-                cpuTemp = ct.NextValue() - 273;
-            }
-        }
-        catch
-        {
-            Debug.WriteLine("Failed reading CPU temp");
-        }
-
-        try
-        {
-            gpuTemp = GpuTemperatureProvider?.GetCurrentTemperature();
-
-        }
-        catch (Exception ex)
-        {
-            gpuTemp = -1;
-            Debug.WriteLine("Failed reading GPU temp");
-            Debug.WriteLine(ex.ToString());
-        }
-
-        if (gpuTemp is null || gpuTemp < 0)
-            gpuTemp = Program.wmi.DeviceGet(ASUSWmi.Temp_GPU);
-
-        try
-        {
-            using (var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true))
-            {
-                batteryDischarge = cb.NextValue() / 1000;
-            }
-        }
-        catch
-        {
-            Debug.WriteLine("Failed reading Battery discharge");
-        }
-    }
-
-    public static bool IsUsedGPU(int threshold = 20)
-    {
-        if (GetGpuUse() > threshold)
-        {
-            Thread.Sleep(1000);
-            return (GetGpuUse() > threshold);
-        } 
-        return false;
-    }
-
-    public static void RecreateGpuTemperatureProviderWithDelay()
-    {
-
-        // Re-enabling the discrete GPU takes a bit of time,
-        // so a simple workaround is to refresh again after that happens
-        Task.Run(async () =>
-        {
-            await Task.Delay(TimeSpan.FromSeconds(5));
-            RecreateGpuTemperatureProvider();
-        });
-
-
-
-    }
-
-    public static void RecreateGpuTemperatureProvider()
-    {
-        try
-        {
-            GpuTemperatureProvider?.Dispose();
-
-            // Detect valid GPU temperature provider.
-            // We start with NVIDIA because there's always at least an integrated AMD GPU
-            IGpuTemperatureProvider gpuTemperatureProvider = new NvidiaGpuTemperatureProvider();
-            if (gpuTemperatureProvider.IsValid)
-            {
-                GpuTemperatureProvider = gpuTemperatureProvider;
-                return;
-            }
-
-            gpuTemperatureProvider.Dispose();
-            gpuTemperatureProvider = new AmdGpuTemperatureProvider();
-            if (gpuTemperatureProvider.IsValid)
-            {
-                GpuTemperatureProvider = gpuTemperatureProvider;
-                return;
-            }
-
-            gpuTemperatureProvider.Dispose();
-
-            GpuTemperatureProvider = null;
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine(ex.ToString());
-        }
-    }
-}

app/Helpers/Logger.cs

@@ -30,7 +30,7 @@ public static class Logger
         try
         {
             var file = File.ReadAllLines(logFile);
-            int skip = Math.Max(0, file.Count() - 500);
+            int skip = Math.Max(0, file.Count() - 1000);
             File.WriteAllLines(logFile, file.Skip(skip).ToArray());
         }
         catch { }

app/Helpers/OSDBase.cs

@@ -1,10 +1,10 @@
 using System.Drawing.Imaging;
 using System.Runtime.InteropServices;
 
-namespace OSD
+namespace GHelper.Helpers
 {
 
-    class OSDNativeForm : NativeWindow, IDisposable
+    public class OSDNativeForm : NativeWindow, IDisposable
     {
 
         private bool _disposed = false;
@@ -19,11 +19,11 @@ namespace OSD
 
         protected internal void Invalidate()
         {
-            this.UpdateLayeredWindow();
+            UpdateLayeredWindow();
         }
         private void UpdateLayeredWindow()
         {
-            Bitmap bitmap1 = new Bitmap(this.Size.Width, this.Size.Height, PixelFormat.Format32bppArgb);
+            Bitmap bitmap1 = new Bitmap(Size.Width, Size.Height, PixelFormat.Format32bppArgb);
             using (Graphics graphics1 = Graphics.FromImage(bitmap1))
             {
                 Rectangle rectangle1;
@@ -31,27 +31,27 @@ namespace OSD
                 POINT point1;
                 POINT point2;
                 BLENDFUNCTION blendfunction1;
-                rectangle1 = new Rectangle(0, 0, this.Size.Width, this.Size.Height);
+                rectangle1 = new Rectangle(0, 0, Size.Width, Size.Height);
                 PerformPaint(new PaintEventArgs(graphics1, rectangle1));
-                IntPtr ptr1 = User32.GetDC(IntPtr.Zero);
-                IntPtr ptr2 = Gdi32.CreateCompatibleDC(ptr1);
-                IntPtr ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
-                IntPtr ptr4 = Gdi32.SelectObject(ptr2, ptr3);
-                size1.cx = this.Size.Width;
-                size1.cy = this.Size.Height;
-                point1.x = this.Location.X;
-                point1.x = this.Location.X;
-                point1.y = this.Location.Y;
+                nint ptr1 = User32.GetDC(nint.Zero);
+                nint ptr2 = Gdi32.CreateCompatibleDC(ptr1);
+                nint ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
+                nint ptr4 = Gdi32.SelectObject(ptr2, ptr3);
+                size1.cx = Size.Width;
+                size1.cy = Size.Height;
+                point1.x = Location.X;
+                point1.x = Location.X;
+                point1.y = Location.Y;
                 point2.x = 0;
                 point2.y = 0;
                 blendfunction1 = new BLENDFUNCTION();
                 blendfunction1.BlendOp = 0;
                 blendfunction1.BlendFlags = 0;
-                blendfunction1.SourceConstantAlpha = this._alpha;
+                blendfunction1.SourceConstantAlpha = _alpha;
                 blendfunction1.AlphaFormat = 1;
-                User32.UpdateLayeredWindow(base.Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
+                User32.UpdateLayeredWindow(Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
                 Gdi32.SelectObject(ptr2, ptr4);
-                User32.ReleaseDC(IntPtr.Zero, ptr1);
+                User32.ReleaseDC(nint.Zero, ptr1);
                 Gdi32.DeleteObject(ptr3);
                 Gdi32.DeleteDC(ptr2);
             }
@@ -59,25 +59,25 @@ namespace OSD
 
         public virtual void Show()
         {
-            if (base.Handle == IntPtr.Zero) //if handle don't equal to zero - window was created and just hided
-                this.CreateWindowOnly();
-            User32.ShowWindow(base.Handle, User32.SW_SHOWNOACTIVATE);
+            if (Handle == nint.Zero) //if handle don't equal to zero - window was created and just hided
+                CreateWindowOnly();
+            User32.ShowWindow(Handle, User32.SW_SHOWNOACTIVATE);
         }
 
 
         public virtual void Hide()
         {
-            if (base.Handle == IntPtr.Zero)
+            if (Handle == nint.Zero)
                 return;
-            User32.ShowWindow(base.Handle, User32.SW_HIDE);
-            this.DestroyHandle();
+            User32.ShowWindow(Handle, User32.SW_HIDE);
+            DestroyHandle();
         }
 
 
         public virtual void Close()
         {
-            this.Hide();
-            this.Dispose();
+            Hide();
+            Dispose();
         }
 
         private void CreateWindowOnly()
@@ -85,55 +85,55 @@ namespace OSD
 
             CreateParams params1 = new CreateParams();
             params1.Caption = "FloatingNativeWindow";
-            int nX = this._location.X;
-            int nY = this._location.Y;
-            Screen screen1 = Screen.FromHandle(base.Handle);
-            if ((nX + this._size.Width) > screen1.Bounds.Width)
+            int nX = _location.X;
+            int nY = _location.Y;
+            Screen screen1 = Screen.FromHandle(Handle);
+            if (nX + _size.Width > screen1.Bounds.Width)
             {
-                nX = screen1.Bounds.Width - this._size.Width;
+                nX = screen1.Bounds.Width - _size.Width;
             }
-            if ((nY + this._size.Height) > screen1.Bounds.Height)
+            if (nY + _size.Height > screen1.Bounds.Height)
             {
-                nY = screen1.Bounds.Height - this._size.Height;
+                nY = screen1.Bounds.Height - _size.Height;
             }
-            this._location = new Point(nX, nY);
-            Size size1 = this._size;
-            Point point1 = this._location;
+            _location = new Point(nX, nY);
+            Size size1 = _size;
+            Point point1 = _location;
             params1.X = nX;
             params1.Y = nY;
             params1.Height = size1.Height;
             params1.Width = size1.Width;
-            params1.Parent = IntPtr.Zero;
+            params1.Parent = nint.Zero;
             uint ui = User32.WS_POPUP;
             params1.Style = (int)ui;
             params1.ExStyle = User32.WS_EX_TOPMOST | User32.WS_EX_TOOLWINDOW | User32.WS_EX_LAYERED | User32.WS_EX_NOACTIVATE | User32.WS_EX_TRANSPARENT;
-            this.CreateHandle(params1);
-            this.UpdateLayeredWindow();
+            CreateHandle(params1);
+            UpdateLayeredWindow();
         }
 
 
 
         protected virtual void SetBoundsCore(int x, int y, int width, int height)
         {
-            if (((this.X != x) || (this.Y != y)) || ((this.Width != width) || (this.Height != height)))
+            if (X != x || Y != y || Width != width || Height != height)
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
                     int num1 = 20;
-                    if ((this.X == x) && (this.Y == y))
+                    if (X == x && Y == y)
                     {
                         num1 |= 2;
                     }
-                    if ((this.Width == width) && (this.Height == height))
+                    if (Width == width && Height == height)
                     {
                         num1 |= 1;
                     }
-                    User32.SetWindowPos(base.Handle, IntPtr.Zero, x, y, width, height, (uint)num1);
+                    User32.SetWindowPos(Handle, nint.Zero, x, y, width, height, (uint)num1);
                 }
                 else
                 {
-                    this.Location = new Point(x, y);
-                    this.Size = new Size(width, height);
+                    Location = new Point(x, y);
+                    Size = new Size(width, height);
                 }
             }
         }
@@ -147,20 +147,20 @@ namespace OSD
         /// </summary>
         public virtual Point Location
         {
-            get { return this._location; }
+            get { return _location; }
             set
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
-                    this.SetBoundsCore(value.X, value.Y, this._size.Width, this._size.Height);
+                    SetBoundsCore(value.X, value.Y, _size.Width, _size.Height);
                     RECT rect = new RECT();
-                    User32.GetWindowRect(base.Handle, ref rect);
-                    this._location = new Point(rect.left, rect.top);
-                    this.UpdateLayeredWindow();
+                    User32.GetWindowRect(Handle, ref rect);
+                    _location = new Point(rect.left, rect.top);
+                    UpdateLayeredWindow();
                 }
                 else
                 {
-                    this._location = value;
+                    _location = value;
                 }
             }
         }
@@ -169,20 +169,20 @@ namespace OSD
         /// </summary>
         public virtual Size Size
         {
-            get { return this._size; }
+            get { return _size; }
             set
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
-                    this.SetBoundsCore(this._location.X, this._location.Y, value.Width, value.Height);
+                    SetBoundsCore(_location.X, _location.Y, value.Width, value.Height);
                     RECT rect = new RECT();
-                    User32.GetWindowRect(base.Handle, ref rect);
-                    this._size = new Size(rect.right - rect.left, rect.bottom - rect.top);
-                    this.UpdateLayeredWindow();
+                    User32.GetWindowRect(Handle, ref rect);
+                    _size = new Size(rect.right - rect.left, rect.bottom - rect.top);
+                    UpdateLayeredWindow();
                 }
                 else
                 {
-                    this._size = value;
+                    _size = value;
                 }
             }
         }
@@ -191,10 +191,10 @@ namespace OSD
         /// </summary>
 		public int Height
         {
-            get { return this._size.Height; }
+            get { return _size.Height; }
             set
             {
-                this._size = new Size(this._size.Width, value);
+                _size = new Size(_size.Width, value);
             }
         }
         /// <summary>
@@ -202,10 +202,10 @@ namespace OSD
         /// </summary>
         public int Width
         {
-            get { return this._size.Width; }
+            get { return _size.Width; }
             set
             {
-                this._size = new Size(value, this._size.Height);
+                _size = new Size(value, _size.Height);
             }
         }
         /// <summary>
@@ -213,10 +213,10 @@ namespace OSD
         /// </summary>
 		public int X
         {
-            get { return this._location.X; }
+            get { return _location.X; }
             set
             {
-                this.Location = new Point(value, this.Location.Y);
+                Location = new Point(value, Location.Y);
             }
         }
         /// <summary>
@@ -224,10 +224,10 @@ namespace OSD
         /// </summary>
         public int Y
         {
-            get { return this._location.Y; }
+            get { return _location.Y; }
             set
             {
-                this.Location = new Point(this.Location.X, value);
+                Location = new Point(Location.X, value);
             }
         }
         /// <summary>
@@ -237,7 +237,7 @@ namespace OSD
         {
             get
             {
-                return new Rectangle(new Point(0, 0), this._size);
+                return new Rectangle(new Point(0, 0), _size);
             }
         }
         /// <summary>
@@ -245,12 +245,12 @@ namespace OSD
         /// </summary>
 		public byte Alpha
         {
-            get { return this._alpha; }
+            get { return _alpha; }
             set
             {
-                if (this._alpha == value) return;
-                this._alpha = value;
-                this.UpdateLayeredWindow();
+                if (_alpha == value) return;
+                _alpha = value;
+                UpdateLayeredWindow();
             }
         }
         #endregion
@@ -258,15 +258,15 @@ namespace OSD
         #region IDisposable Members
         public void Dispose()
         {
-            this.Dispose(true);
+            Dispose(true);
             GC.SuppressFinalize(this);
         }
         private void Dispose(bool disposing)
         {
-            if (!this._disposed)
+            if (!_disposed)
             {
-                this.DestroyHandle();
-                this._disposed = true;
+                DestroyHandle();
+                _disposed = true;
             }
         }
         #endregion
@@ -299,16 +299,16 @@ namespace OSD
     {
         public uint cbSize;
         public uint dwFlags;
-        public IntPtr hWnd;
+        public nint hWnd;
         public uint dwHoverTime;
     }
     [StructLayout(LayoutKind.Sequential)]
     internal struct MSG
     {
-        public IntPtr hwnd;
+        public nint hwnd;
         public int message;
-        public IntPtr wParam;
-        public IntPtr lParam;
+        public nint wParam;
+        public nint lParam;
         public int time;
         public int pt_x;
         public int pt_y;
@@ -345,69 +345,69 @@ namespace OSD
         {
         }
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool AnimateWindow(IntPtr hWnd, uint dwTime, uint dwFlags);
+        internal static extern bool AnimateWindow(nint hWnd, uint dwTime, uint dwFlags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT pt);
+        internal static extern bool ClientToScreen(nint hWnd, ref POINT pt);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool DispatchMessage(ref MSG msg);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool DrawFocusRect(IntPtr hWnd, ref RECT rect);
+        internal static extern bool DrawFocusRect(nint hWnd, ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetDC(IntPtr hWnd);
+        internal static extern nint GetDC(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetFocus();
+        internal static extern nint GetFocus();
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern ushort GetKeyState(int virtKey);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool GetMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetParent(IntPtr hWnd);
+        internal static extern nint GetParent(nint hWnd);
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
-        public static extern bool GetClientRect(IntPtr hWnd, [In, Out] ref RECT rect);
+        public static extern bool GetClientRect(nint hWnd, [In, Out] ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+        internal static extern int GetWindowLong(nint hWnd, int nIndex);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetWindow(IntPtr hWnd, int cmd);
+        internal static extern nint GetWindow(nint hWnd, int cmd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
+        internal static extern bool GetWindowRect(nint hWnd, ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool HideCaret(IntPtr hWnd);
+        internal static extern bool HideCaret(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool InvalidateRect(IntPtr hWnd, ref RECT rect, bool erase);
+        internal static extern bool InvalidateRect(nint hWnd, ref RECT rect, bool erase);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr LoadCursor(IntPtr hInstance, uint cursor);
+        internal static extern nint LoadCursor(nint hInstance, uint cursor);
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
-        public static extern int MapWindowPoints(IntPtr hWndFrom, IntPtr hWndTo, [In, Out] ref RECT rect, int cPoints);
+        public static extern int MapWindowPoints(nint hWndFrom, nint hWndTo, [In, Out] ref RECT rect, int cPoints);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint);
+        internal static extern bool MoveWindow(nint hWnd, int x, int y, int width, int height, bool repaint);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool PeekMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax, uint wFlag);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool PostMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        internal static extern bool PostMessage(nint hWnd, int Msg, uint wParam, uint lParam);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool ReleaseCapture();
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
+        internal static extern int ReleaseDC(nint hWnd, nint hDC);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ScreenToClient(IntPtr hWnd, ref POINT pt);
+        internal static extern bool ScreenToClient(nint hWnd, ref POINT pt);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern uint SendMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        internal static extern uint SendMessage(nint hWnd, int Msg, uint wParam, uint lParam);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SetCursor(IntPtr hCursor);
+        internal static extern nint SetCursor(nint hCursor);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SetFocus(IntPtr hWnd);
+        internal static extern nint SetFocus(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int newLong);
+        internal static extern int SetWindowLong(nint hWnd, int nIndex, int newLong);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SetWindowPos(IntPtr hWnd, IntPtr hWndAfter, int X, int Y, int Width, int Height, uint flags);
+        internal static extern int SetWindowPos(nint hWnd, nint hWndAfter, int X, int Y, int Width, int Height, uint flags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw);
+        internal static extern bool SetWindowRgn(nint hWnd, nint hRgn, bool redraw);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ShowCaret(IntPtr hWnd);
+        internal static extern bool ShowCaret(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool SetCapture(IntPtr hWnd);
+        internal static extern bool SetCapture(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int ShowWindow(IntPtr hWnd, short cmdShow);
+        internal static extern int ShowWindow(nint hWnd, short cmdShow);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool SystemParametersInfo(uint uiAction, uint uiParam, ref int bRetValue, uint fWinINI);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
@@ -415,9 +415,9 @@ namespace OSD
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool TranslateMessage(ref MSG msg);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref POINT pptDst, ref SIZE psize, IntPtr hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
+        internal static extern bool UpdateLayeredWindow(nint hwnd, nint hdcDst, ref POINT pptDst, ref SIZE psize, nint hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool UpdateWindow(IntPtr hwnd);
+        internal static extern bool UpdateWindow(nint hwnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool WaitMessage();
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
@@ -431,25 +431,25 @@ namespace OSD
         {
         }
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);
+        internal static extern int CombineRgn(nint dest, nint src1, nint src2, int flags);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateBrushIndirect(ref LOGBRUSH brush);
+        internal static extern nint CreateBrushIndirect(ref LOGBRUSH brush);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateCompatibleDC(IntPtr hDC);
+        internal static extern nint CreateCompatibleDC(nint hDC);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateRectRgnIndirect(ref RECT rect);
+        internal static extern nint CreateRectRgnIndirect(ref RECT rect);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool DeleteDC(IntPtr hDC);
+        internal static extern bool DeleteDC(nint hDC);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr DeleteObject(IntPtr hObject);
+        internal static extern nint DeleteObject(nint hObject);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int GetClipBox(IntPtr hDC, ref RECT rectBox);
+        internal static extern int GetClipBox(nint hDC, ref RECT rectBox);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool PatBlt(IntPtr hDC, int x, int y, int width, int height, uint flags);
+        internal static extern bool PatBlt(nint hDC, int x, int y, int width, int height, uint flags);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
+        internal static extern int SelectClipRgn(nint hDC, nint hRgn);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
+        internal static extern nint SelectObject(nint hDC, nint hObject);
     }
     [StructLayout(LayoutKind.Sequential)]
     public struct LOGBRUSH

app/Helpers/OptimizationService.cs

@@ -0,0 +1,106 @@
+using Microsoft.Win32;
+using System.Diagnostics;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace GHelper.Helpers
+{
+    public static class OptimizationService
+    {
+
+        static List<string> services = new() {
+                "AsusAppService",
+                "ASUSLinkNear",
+                "ASUSLinkRemote",
+                "ASUSSoftwareManager",
+                "ASUSSwitch",
+                "ASUSSystemAnalysis",
+                "ASUSSystemDiagnosis",
+                "ArmouryCrateControlInterface",
+                "AsusCertService",
+                "ASUSOptimization"
+        };
+
+        public static void SetChargeLimit(int newValue)
+        {
+            // Set the path to the .ini file
+            string path = @"C:\ProgramData\ASUS\ASUS System Control Interface\ASUSOptimization\Customization.ini";
+
+
+            // Make a backup copy of the INI file
+            string backupPath = path + ".bak";
+            File.Copy(path, backupPath, true);
+
+            string fileContents = File.ReadAllText(path, Encoding.Unicode);
+
+            // Find the section [BatteryHealthCharging]
+            string sectionPattern = @"\[BatteryHealthCharging\]\s*(version=\d+)?\s+value=(\d+)";
+            Match sectionMatch = Regex.Match(fileContents, sectionPattern);
+            if (sectionMatch.Success)
+            {
+                // Replace the value with the new value
+                string oldValueString = sectionMatch.Groups[2].Value;
+                int oldValue = int.Parse(oldValueString);
+                string newSection = sectionMatch.Value.Replace($"value={oldValue}", $"value={newValue}");
+
+                // Replace the section in the file contents
+                fileContents = fileContents.Replace(sectionMatch.Value, newSection);
+
+                File.WriteAllText(path, fileContents, Encoding.Unicode);
+            }
+        }
+
+        public static bool IsRunning()
+        {
+            return Process.GetProcessesByName("AsusOptimization").Count() > 0;
+        }
+
+        public static int GetRunningCount()
+        {
+            int count = 0;
+            foreach (string service in services)
+            {
+                if (Process.GetProcessesByName(service).Count() > 0) count++;
+            }
+            return count;
+        }
+
+
+        public static void SetBacklightOffDelay(int value = 60)
+        {
+            try
+            {
+                RegistryKey myKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\ASUS\ASUS System Control Interface\AsusOptimization\ASUS Keyboard Hotkeys", true);
+                if (myKey != null)
+                {
+                    myKey.SetValue("TurnOffKeybdLight", value, RegistryValueKind.DWord);
+                    myKey.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
+        }
+
+
+
+        public static void StopAsusServices()
+        {
+            foreach (string service in services)
+            {
+                ProcessHelper.StopDisableService(service);
+            }
+        }
+
+        public static void StartAsusServices()
+        {
+            foreach (string service in services)
+            {
+                ProcessHelper.StartEnableService(service);
+            }
+        }
+
+    }
+
+}

app/Helpers/ProcessHelper.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Principal;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GHelper.Helpers
+{
+    public static class ProcessHelper
+    {
+        private static long lastAdmin;
+
+        public static void CheckAlreadyRunning()
+        {
+            Process currentProcess = Process.GetCurrentProcess();
+            Process[] processes = Process.GetProcessesByName(currentProcess.ProcessName);
+
+            if (processes.Length > 1)
+            {
+                foreach (Process process in processes)
+                    if (process.Id != currentProcess.Id)
+                        try
+                        {
+                            process.Kill();
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.WriteLine(ex.ToString());
+                            MessageBox.Show(Properties.Strings.AppAlreadyRunningText, Properties.Strings.AppAlreadyRunning, MessageBoxButtons.OK);
+                            Application.Exit();
+                            return;
+                        }
+            }
+        }
+
+        public static bool IsUserAdministrator()
+        {
+            WindowsIdentity identity = WindowsIdentity.GetCurrent();
+            WindowsPrincipal principal = new WindowsPrincipal(identity);
+            return principal.IsInRole(WindowsBuiltInRole.Administrator);
+        }
+
+        public static void RunAsAdmin(string? param = null)
+        {
+
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAdmin) < 2000) return;
+            lastAdmin = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
+            // Check if the current user is an administrator
+            if (!IsUserAdministrator())
+            {
+                ProcessStartInfo startInfo = new ProcessStartInfo();
+                startInfo.UseShellExecute = true;
+                startInfo.WorkingDirectory = Environment.CurrentDirectory;
+                startInfo.FileName = Application.ExecutablePath;
+                startInfo.Arguments = param;
+                startInfo.Verb = "runas";
+                try
+                {
+                    Process.Start(startInfo);
+                    Application.Exit();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+            }
+        }
+
+
+        public static void KillByName(string name)
+        {
+            foreach (var process in Process.GetProcessesByName(name))
+            {
+                try
+                {
+                    process.Kill();
+                    Logger.WriteLine($"Stopped: {process.ProcessName}");
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
+                }
+            }
+        }
+
+        public static void KillByProcess(Process process)
+        {
+            try
+            {
+                process.Kill();
+                Logger.WriteLine($"Stopped: {process.ProcessName}");
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
+            }
+        }
+
+        public static void StopDisableService(string serviceName)
+        {
+            try
+            {
+                string script = $"Set-Service -Name \"{serviceName}\" -Status stopped -StartupType disabled";
+                Logger.WriteLine(script);
+                RunCMD("powershell", script);
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        public static void StartEnableService(string serviceName)
+        {
+            try
+            {
+                string script = $"Set-Service -Name \"{serviceName}\" -Status running -StartupType Automatic";
+                Logger.WriteLine(script);
+                RunCMD("powershell", script);
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        public static void RunCMD(string name, string args)
+        {
+            var cmd = new Process();
+            cmd.StartInfo.UseShellExecute = false;
+            cmd.StartInfo.CreateNoWindow = true;
+            cmd.StartInfo.RedirectStandardOutput = true;
+            cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+            cmd.StartInfo.FileName = name;
+            cmd.StartInfo.Arguments = args;
+            cmd.Start();
+            Logger.WriteLine(cmd.StandardOutput.ReadToEnd());
+            cmd.WaitForExit();
+        }
+
+
+    }
+}

app/Helpers/ScreenBrightness.cs

@@ -0,0 +1,47 @@
+namespace GHelper.Helpers
+{
+    using System;
+    using System.Diagnostics;
+    using System.Management;
+
+    public static class ScreenBrightness
+    {
+        public static int Get()
+        {
+            using var mclass = new ManagementClass("WmiMonitorBrightness")
+            {
+                Scope = new ManagementScope(@"\\.\root\wmi")
+            };
+            using var instances = mclass.GetInstances();
+            foreach (ManagementObject instance in instances)
+            {
+                return (byte)instance.GetPropertyValue("CurrentBrightness");
+            }
+            return 0;
+        }
+
+        public static void Set(int brightness)
+        {
+            using var mclass = new ManagementClass("WmiMonitorBrightnessMethods")
+            {
+                Scope = new ManagementScope(@"\\.\root\wmi")
+            };
+            using var instances = mclass.GetInstances();
+            var args = new object[] { 1, brightness };
+            foreach (ManagementObject instance in instances)
+            {
+                instance.InvokeMethod("WmiSetBrightness", args);
+            }
+        }
+
+        public static int Adjust(int delta)
+        {
+            int brightness = Get();
+            Debug.WriteLine(brightness);
+            brightness = Math.Min(100, Math.Max(0, brightness + delta));
+            Set(brightness);
+            return brightness;
+        }
+
+    }
+}

app/Helpers/Startup.cs

@@ -1,4 +1,5 @@
-using Microsoft.Win32.TaskScheduler;
+using GHelper.Helpers;
+using Microsoft.Win32.TaskScheduler;
 using System.Diagnostics;
 using System.Security.Principal;
 
@@ -13,6 +14,15 @@ public class Startup
         return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
     }
 
+    public static void ReScheduleAdmin()
+    {
+        if (ProcessHelper.IsUserAdministrator() && IsScheduled())
+        {
+            UnSchedule();
+            Schedule();
+        }
+    }
+
     public static void Schedule()
     {
 
@@ -28,6 +38,9 @@ public class Startup
             td.Triggers.Add(new LogonTrigger { UserId = userId });
             td.Actions.Add(strExeFilePath);
 
+            if (ProcessHelper.IsUserAdministrator()) 
+                td.Principal.RunLevel = TaskRunLevel.Highest;
+
             td.Settings.StopIfGoingOnBatteries = false;
             td.Settings.DisallowStartIfOnBatteries = false;
             td.Settings.ExecutionTimeLimit = TimeSpan.Zero;
@@ -41,7 +54,10 @@ public class Startup
             }
             catch (Exception e)
             {
-                MessageBox.Show("Can't create a start up task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
+                if (ProcessHelper.IsUserAdministrator())
+                    MessageBox.Show("Can't create a start up task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
+                else
+                    ProcessHelper.RunAsAdmin();
             }
         }
 
@@ -57,7 +73,10 @@ public class Startup
             }
             catch (Exception e)
             {
-                MessageBox.Show("Can't remove task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
+                if (ProcessHelper.IsUserAdministrator())
+                    MessageBox.Show("Can't remove task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
+                else
+                    ProcessHelper.RunAsAdmin();
             }
         }
     }

app/Helpers/ToastForm.cs

@@ -0,0 +1,163 @@
+using System.Drawing.Drawing2D;
+
+namespace GHelper.Helpers
+{
+
+    static class Drawing
+    {
+
+        public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
+        {
+            int diameter = radius * 2;
+            Size size = new Size(diameter, diameter);
+            Rectangle arc = new Rectangle(bounds.Location, size);
+            GraphicsPath path = new GraphicsPath();
+
+            if (radius == 0)
+            {
+                path.AddRectangle(bounds);
+                return path;
+            }
+
+            path.AddArc(arc, 180, 90);
+            arc.X = bounds.Right - diameter;
+            path.AddArc(arc, 270, 90);
+            arc.Y = bounds.Bottom - diameter;
+            path.AddArc(arc, 0, 90);
+            arc.X = bounds.Left;
+            path.AddArc(arc, 90, 90);
+            path.CloseFigure();
+            return path;
+        }
+
+        public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
+        {
+            using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
+            {
+                graphics.FillPath(brush, path);
+            }
+        }
+    }
+
+    public enum ToastIcon
+    {
+        BrightnessUp,
+        BrightnessDown,
+        BacklightUp,
+        BacklightDown,
+        Touchpad,
+        Microphone,
+        MicrophoneMute,
+        FnLock,
+        Battery,
+        Charger
+    }
+
+    public class ToastForm : OSDNativeForm
+    {
+
+        protected static string toastText = "Balanced";
+        protected static ToastIcon? toastIcon = null;
+
+        protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
+
+        public ToastForm()
+        {
+            timer.Tick += timer_Tick;
+            timer.Enabled = false;
+            timer.Interval = 2000;
+        }
+
+        protected override void PerformPaint(PaintEventArgs e)
+        {
+            Brush brush = new SolidBrush(Color.FromArgb(150, Color.Black));
+            e.Graphics.FillRoundedRectangle(brush, Bound, 10);
+
+            StringFormat format = new StringFormat();
+            format.LineAlignment = StringAlignment.Center;
+            format.Alignment = StringAlignment.Center;
+
+            Bitmap? icon = null;
+
+            switch (toastIcon)
+            {
+                case ToastIcon.BrightnessUp:
+                    icon = Properties.Resources.brightness_up;
+                    break;
+                case ToastIcon.BrightnessDown:
+                    icon = Properties.Resources.brightness_down;
+                    break;
+                case ToastIcon.BacklightUp:
+                    icon = Properties.Resources.backlight_up;
+                    break;
+                case ToastIcon.BacklightDown:
+                    icon = Properties.Resources.backlight_down;
+                    break;
+                case ToastIcon.Microphone:
+                    icon = Properties.Resources.icons8_microphone_96;
+                    break;
+                case ToastIcon.MicrophoneMute:
+                    icon = Properties.Resources.icons8_mute_unmute_96;
+                    break;
+                case ToastIcon.Touchpad:
+                    icon = Properties.Resources.icons8_touchpad_96;
+                    break;
+                case ToastIcon.FnLock:
+                    icon = Properties.Resources.icons8_function;
+                    break;
+                case ToastIcon.Battery:
+                    icon = Properties.Resources.icons8_charged_battery_96;
+                    break;
+                case ToastIcon.Charger:
+                    icon = Properties.Resources.icons8_charging_battery_96;
+                    break;
+
+            }
+
+            int shiftX = 0;
+
+            if (icon is not null)
+            {
+                e.Graphics.DrawImage(icon, 18, 18, 64, 64);
+                shiftX = 40;
+            }
+
+            e.Graphics.DrawString(toastText,
+                new Font("Segoe UI", 36f, FontStyle.Bold, GraphicsUnit.Pixel),
+                new SolidBrush(Color.White),
+                new PointF(Bound.Width / 2 + shiftX, Bound.Height / 2),
+            format);
+
+        }
+
+        public void RunToast(string text, ToastIcon? icon = null)
+        {
+            Program.settingsForm.Invoke(delegate
+            {
+                //Hide();
+                timer.Stop();
+
+                toastText = text;
+                toastIcon = icon;
+
+                Screen screen1 = Screen.FromHandle(Handle);
+
+                Width = Math.Max(300, 100 + toastText.Length * 22);
+                Height = 100;
+                X = (screen1.Bounds.Width - Width) / 2;
+                Y = screen1.Bounds.Height - 300 - Height;
+
+                Show();
+                timer.Start();
+            });
+
+        }
+
+        private void timer_Tick(object? sender, EventArgs e)
+        {
+            //Debug.WriteLine("Toast end");
+            Hide();
+            timer.Stop();
+        }
+    }
+}

app/Input/InputDispatcher.cs

@@ -0,0 +1,498 @@
+using GHelper.Display;
+using GHelper.Helpers;
+using GHelper.Mode;
+using Microsoft.Win32;
+using NAudio.CoreAudioApi;
+using System.Diagnostics;
+using System.Management;
+
+namespace GHelper.Input
+{
+
+    public class InputDispatcher
+    {
+        System.Timers.Timer timer = new System.Timers.Timer(1000);
+        public bool backlightActivity = true;
+
+        public static Keys keyProfile = Keys.F5;
+        public static Keys keyApp = Keys.F12;
+
+        static ModeControl modeControl = Program.modeControl;
+        static ScreenControl screenControl = new ScreenControl();
+
+        KeyboardListener listener;
+        KeyboardHook hook = new KeyboardHook();
+
+        public InputDispatcher()
+        {
+
+            byte[] result = Program.acpi.DeviceInit();
+            Debug.WriteLine($"Init: {BitConverter.ToString(result)}");
+
+            Program.acpi.SubscribeToEvents(WatcherEventArrived);
+            //Task.Run(Program.acpi.RunListener);
+
+            hook.KeyPressed += new EventHandler<KeyPressedEventArgs>(KeyPressed);
+
+            RegisterKeys();
+
+            timer.Elapsed += Timer_Elapsed;
+
+        }
+
+        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (GetBacklight() == 0) return;
+
+            TimeSpan iddle = NativeMethods.GetIdleTime();
+            int kb_timeout;
+
+            if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
+                kb_timeout = AppConfig.Get("keyboard_ac_timeout", 0);
+            else
+                kb_timeout = AppConfig.Get("keyboard_timeout", 60);
+
+            if (kb_timeout == 0) return;
+
+            if (backlightActivity && iddle.TotalSeconds > kb_timeout)
+            {
+                backlightActivity = false;
+                AsusUSB.ApplyBrightness(0, "Timeout");
+            }
+
+            if (!backlightActivity && iddle.TotalSeconds < kb_timeout)
+            {
+                backlightActivity = true;
+                SetBacklightAuto();
+            }
+
+            //Debug.WriteLine(iddle.TotalSeconds);
+        }
+
+        public void Init()
+        {
+            if (listener is not null) listener.Dispose();
+
+            Program.acpi.DeviceInit();
+
+            if (!OptimizationService.IsRunning())
+                listener = new KeyboardListener(HandleEvent);
+            else
+                Logger.WriteLine("Optimization service is running");
+
+            InitBacklightTimer();
+        }
+
+        public void InitBacklightTimer()
+        {
+            timer.Enabled = AppConfig.Get("keyboard_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online ||
+                            AppConfig.Get("keyboard_ac_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
+        }
+
+
+
+        public void RegisterKeys()
+        {
+            hook.UnregisterAll();
+
+            // CTRL + SHIFT + F5 to cycle profiles
+            if (AppConfig.Get("keybind_profile") != -1) keyProfile = (Keys)AppConfig.Get("keybind_profile");
+            if (AppConfig.Get("keybind_app") != -1) keyApp = (Keys)AppConfig.Get("keybind_app");
+
+            string actionM1 = AppConfig.GetString("m1");
+            string actionM2 = AppConfig.GetString("m2");
+
+            if (keyProfile != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyProfile);
+            if (keyApp != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyApp);
+
+            if (!AppConfig.ContainsModel("Z13"))
+                if (actionM1 is not null && actionM1.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeDown);
+            if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
+
+            // FN-Lock group
+
+            if (AppConfig.Is("fn_lock") && !AppConfig.ContainsModel("VivoBook"))
+                for (Keys i = Keys.F1; i <= Keys.F11; i++) hook.RegisterHotKey(ModifierKeys.None, i);
+
+        }
+
+        static void CustomKey(string configKey = "m3")
+        {
+            string command = AppConfig.GetString(configKey + "_custom");
+            int intKey;
+
+            try
+            {
+                intKey = Convert.ToInt32(command, 16);
+            }
+            catch
+            {
+                intKey = -1;
+            }
+
+
+            if (intKey > 0)
+                KeyboardHook.KeyPress((Keys)intKey);
+            else
+                LaunchProcess(command);
+
+        }
+
+        public void KeyPressed(object sender, KeyPressedEventArgs e)
+        {
+
+            if (e.Modifier == ModifierKeys.None)
+            {
+                Logger.WriteLine(e.Key.ToString());
+
+                if (AppConfig.ContainsModel("Z13"))
+                {
+                    switch (e.Key)
+                    {
+                        case Keys.F2:
+                            KeyboardHook.KeyPress(Keys.VolumeDown);
+                            return;
+                        case Keys.F3:
+                            KeyboardHook.KeyPress(Keys.VolumeUp);
+                            return;
+                        case Keys.F4:
+                            KeyProcess("m3");
+                            return;
+                        case Keys.F11:
+                            HandleEvent(199);
+                            return;
+                    }
+                }
+
+                if (AppConfig.ContainsModel("GA401I") && !AppConfig.ContainsModel("GA401IHR"))
+                {
+                    switch (e.Key)
+                    {
+                        case Keys.F2:
+                            KeyboardHook.KeyPress(Keys.MediaPreviousTrack);
+                            return;
+                        case Keys.F3:
+                            KeyboardHook.KeyPress(Keys.MediaPlayPause);
+                            return;
+                        case Keys.F4:
+                            KeyboardHook.KeyPress(Keys.MediaNextTrack);
+                            return;
+                    }
+                }
+
+
+                switch (e.Key)
+                {
+                    case Keys.F1:
+                        KeyboardHook.KeyPress(Keys.VolumeMute);
+                        break;
+                    case Keys.F2:
+                        HandleEvent(197);
+                        break;
+                    case Keys.F3:
+                        HandleEvent(196);
+                        break;
+                    case Keys.F4:
+                        KeyProcess("fnf4");
+                        break;
+                    case Keys.F5:
+                        KeyProcess("fnf5");
+                        break;
+                    case Keys.F6:
+                        KeyboardHook.KeyPress(Keys.Snapshot);
+                        break;
+                    case Keys.F7:
+                        if (AppConfig.ContainsModel("TUF"))
+                            Program.toast.RunToast(ScreenBrightness.Adjust(-10) + "%", ToastIcon.BrightnessDown);
+                        HandleOptimizationEvent(16);
+                        break;
+                    case Keys.F8:
+                        if (AppConfig.ContainsModel("TUF"))
+                            Program.toast.RunToast(ScreenBrightness.Adjust(+10) + "%", ToastIcon.BrightnessUp);
+                        HandleOptimizationEvent(32);
+                        break;
+                    case Keys.F9:
+                        KeyboardHook.KeyWinPress(Keys.P);
+                        break;
+                    case Keys.F10:
+                        HandleOptimizationEvent(107);
+                        break;
+                    case Keys.F11:
+                        HandleOptimizationEvent(108);
+                        break;
+                    case Keys.F12:
+                        KeyboardHook.KeyWinPress(Keys.A);
+                        break;
+                    case Keys.VolumeDown:
+                        KeyProcess("m1");
+                        break;
+                    case Keys.VolumeUp:
+                        KeyProcess("m2");
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift))
+            {
+                if (e.Key == keyProfile) modeControl.CyclePerformanceMode();
+                if (e.Key == keyApp) Program.SettingsToggle();
+            }
+
+
+        }
+
+
+        public static void KeyProcess(string name = "m3")
+        {
+            string action = AppConfig.GetString(name);
+
+            if (action is null || action.Length <= 1)
+            {
+                if (name == "m4")
+                    action = "ghelper";
+                if (name == "fnf4")
+                    action = "aura";
+                if (name == "fnf5")
+                    action = "performance";
+                if (name == "m3" && !OptimizationService.IsRunning())
+                    action = "micmute";
+                if (name == "fnc")
+                    action = "fnlock";
+            }
+
+            switch (action)
+            {
+                case "mute":
+                    KeyboardHook.KeyPress(Keys.VolumeMute);
+                    break;
+                case "play":
+                    KeyboardHook.KeyPress(Keys.MediaPlayPause);
+                    break;
+                case "screenshot":
+                    KeyboardHook.KeyPress(Keys.Snapshot);
+                    break;
+                case "screen":
+                    Logger.WriteLine("Screen off toggle");
+                    NativeMethods.TurnOffScreen(Program.settingsForm.Handle);
+                    break;
+                case "miniled":
+                    screenControl.ToogleMiniled();
+                    break;
+                case "aura":
+                    Program.settingsForm.BeginInvoke(Program.settingsForm.CycleAuraMode);
+                    break;
+                case "performance":
+                    modeControl.CyclePerformanceMode();
+                    break;
+                case "ghelper":
+                    Program.settingsForm.BeginInvoke(delegate
+                    {
+                        Program.SettingsToggle();
+                    });
+                    break;
+                case "fnlock":
+                    ToggleFnLock();
+                    break;
+                case "micmute":
+                    using (var enumerator = new MMDeviceEnumerator())
+                    {
+                        var commDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
+                        bool muteStatus = !commDevice.AudioEndpointVolume.Mute;
+                        commDevice.AudioEndpointVolume.Mute = muteStatus;
+                        Program.toast.RunToast(muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
+                    }
+                    break;
+                case "brightness_up":
+                    HandleOptimizationEvent(32);
+                    break;
+                case "brightness_down":
+                    HandleOptimizationEvent(16);
+                    break;
+                case "custom":
+                    CustomKey(name);
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        static bool GetTouchpadState()
+        {
+            using (var key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\PrecisionTouchPad\Status", false))
+            {
+                return key?.GetValue("Enabled")?.ToString() == "1";
+            }
+        }
+
+        static void ToggleFnLock()
+        {
+            int fnLock = AppConfig.Is("fn_lock") ? 0 : 1;
+            AppConfig.Set("fn_lock", fnLock);
+
+            if (AppConfig.ContainsModel("VivoBook"))
+                Program.acpi.DeviceSet(AsusACPI.FnLock, fnLock == 1 ? 0 : 1, "FnLock");
+            else
+                Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
+
+            Program.toast.RunToast("Fn-Lock " + (fnLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
+        }
+
+        public static void TabletMode()
+        {
+            bool touchpadState = GetTouchpadState();
+            bool tabletState = Program.acpi.DeviceGet(AsusACPI.TabletState) > 0;
+
+            Logger.WriteLine("Tablet: " + tabletState + " Touchpad: " + touchpadState);
+
+            if (tabletState && touchpadState || !tabletState && !touchpadState) AsusUSB.TouchpadToggle();
+
+        }
+
+        static void HandleEvent(int EventID)
+        {
+            switch (EventID)
+            {
+                case 124:    // M3
+                    KeyProcess("m3");
+                    return;
+                case 56:    // M4 / Rog button
+                    KeyProcess("m4");
+                    return;
+                case 174:   // FN+F5
+                    modeControl.CyclePerformanceMode();
+                    return;
+                case 179:   // FN+F4
+                case 178:   // FN+F4
+                    KeyProcess("fnf4");
+                    return;
+                case 158:   // Fn + C
+                    KeyProcess("fnc");
+                    return;
+                case 78:    // Fn + ESC
+                    ToggleFnLock();
+                    return;
+                case 189: // Tablet mode 
+                    TabletMode();
+                    return;
+                case 197: // FN+F2
+                    SetBacklight(-1);
+                    return;
+                case 196: // FN+F3
+                    SetBacklight(1);
+                    return;
+                case 199: // ON Z13 - FN+F11 - cycles backlight
+                    SetBacklight(4);
+                    return;
+                case 53:    // FN+F6 on GA-502DU model
+                    NativeMethods.TurnOffScreen(Program.settingsForm.Handle);
+                    return;
+            }
+
+            if (!OptimizationService.IsRunning())
+                HandleOptimizationEvent(EventID);
+
+        }
+
+        // Asus Optimization service Events 
+        static void HandleOptimizationEvent(int EventID)
+        {
+            switch (EventID)
+            {
+                case 16: // FN+F7
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
+                    break;
+                case 32: // FN+F8
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
+                    break;
+                case 107: // FN+F10
+                    bool touchpadState = GetTouchpadState();
+                    AsusUSB.TouchpadToggle();
+                    Program.toast.RunToast(touchpadState ? "Off" : "On", ToastIcon.Touchpad);
+                    break;
+                case 108: // FN+F11
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
+                    break;
+            }
+        }
+
+
+        public static int GetBacklight()
+        {
+            int backlight_power = AppConfig.Get("keyboard_brightness", 1);
+            int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            int backlight;
+
+            //backlight = onBattery ? Math.Min(backlight_battery, backlight_power) : Math.Max(backlight_battery, backlight_power);
+            backlight = onBattery ? backlight_battery : backlight_power;
+
+            return Math.Max(Math.Min(3, backlight), 0);
+        }
+
+        public static void SetBacklightAuto(bool init = false)
+        {
+            if (init) AsusUSB.Init();
+
+            //if (!OptimizationService.IsRunning()) 
+            AsusUSB.ApplyBrightness(GetBacklight(), "Auto");
+        }
+
+        public static void SetBacklight(int delta)
+        {
+            int backlight_power = AppConfig.Get("keyboard_brightness", 1);
+            int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            int backlight = onBattery ? backlight_battery : backlight_power;
+
+            if (delta >= 4)
+                backlight = ++backlight % 4;
+            else
+                backlight = Math.Max(Math.Min(3, backlight + delta), 0);
+
+            if (onBattery)
+                AppConfig.Set("keyboard_brightness_ac", backlight);
+            else
+                AppConfig.Set("keyboard_brightness", backlight);
+
+            if (!OptimizationService.IsRunning())
+            {
+                AsusUSB.ApplyBrightness(backlight, "HotKey");
+                string[] backlightNames = new string[] { "Off", "Low", "Mid", "Max" };
+                Program.toast.RunToast(backlightNames[backlight], delta > 0 ? ToastIcon.BacklightUp : ToastIcon.BacklightDown);
+            }
+
+        }
+
+        static void LaunchProcess(string command = "")
+        {
+
+            try
+            {
+                string executable = command.Split(' ')[0];
+                string arguments = command.Substring(executable.Length).Trim();
+                Process proc = Process.Start(executable, arguments);
+            }
+            catch
+            {
+                Logger.WriteLine("Failed to run  " + command);
+            }
+
+
+        }
+
+
+
+        static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
+        {
+            if (e.NewEvent is null) return;
+            int EventID = int.Parse(e.NewEvent["EventID"].ToString());
+            Logger.WriteLine("WMI event " + EventID);
+            HandleEvent(EventID);
+        }
+    }
+}

app/Input/KeyboardHook.cs

@@ -0,0 +1,173 @@
+using System.Runtime.InteropServices;
+
+public sealed class KeyboardHook : IDisposable
+{
+    // Registers a hot key with Windows.
+    [DllImport("user32.dll")]
+    private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+    // Unregisters the hot key with Windows.
+    [DllImport("user32.dll")]
+    private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+
+    [DllImport("user32.dll")]
+    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
+
+    public const int KEYEVENTF_EXTENDEDKEY = 1;
+    public const int KEYEVENTF_KEYUP = 2;
+    private const byte VK_LWIN = 0x5B;
+
+    public static void KeyPress(Keys key)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+    }
+
+    public static void KeyWinPress(Keys key)
+    {
+        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
+
+
+    /// <summary>
+    /// Represents the window that is used internally to get the messages.
+    /// </summary>
+    private class Window : NativeWindow, IDisposable
+    {
+        private static int WM_HOTKEY = 0x0312;
+        public static Keys? fakeKey;
+
+        public Window()
+        {
+            // create the handle for the window.
+            this.CreateHandle(new CreateParams());
+        }
+
+        /// <summary>
+        /// Overridden to get the notifications.
+        /// </summary>
+        /// <param name="m"></param>
+        protected override void WndProc(ref Message m)
+        {
+            base.WndProc(ref m);
+
+            // check if we got a hot key pressed.
+            if (m.Msg == WM_HOTKEY)
+            {
+                // get the keys.
+                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
+                ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);
+
+                // invoke the event to notify the parent.
+                if (KeyPressed != null)
+                    KeyPressed(this, new KeyPressedEventArgs(modifier, key));
+            }
+        }
+
+        public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            this.DestroyHandle();
+        }
+
+        #endregion
+    }
+
+    private Window _window = new Window();
+    private int _currentId;
+
+    public KeyboardHook()
+    {
+        // register the event of the inner native window.
+        _window.KeyPressed += delegate (object sender, KeyPressedEventArgs args)
+        {
+            if (KeyPressed != null)
+                KeyPressed(this, args);
+        };
+    }
+
+    /// <summary>
+    /// Registers a hot key in the system.
+    /// </summary>
+    /// <param name="modifier">The modifiers that are associated with the hot key.</param>
+    /// <param name="key">The key itself that is associated with the hot key.</param>
+    public void RegisterHotKey(ModifierKeys modifier, Keys key)
+    {
+        // increment the counter.
+        _currentId = _currentId + 1;
+
+        // register the hot key.
+        if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
+            Logger.WriteLine("Couldn’t register " + key);
+    }
+
+    /// <summary>
+    /// A hot key has been pressed.
+    /// </summary>
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    #region IDisposable Members
+
+    public void UnregisterAll()
+    {
+        // unregister all the registered hot keys.
+        for (int i = _currentId; i > 0; i--)
+        {
+            UnregisterHotKey(_window.Handle, i);
+        }
+    }
+
+    public void Dispose()
+    {
+        UnregisterAll();
+        // dispose the inner native window.
+        _window.Dispose();
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Event Args for the event that is fired after the hot key has been pressed.
+/// </summary>
+public class KeyPressedEventArgs : EventArgs
+{
+    private ModifierKeys _modifier;
+    private Keys _key;
+
+    internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
+    {
+        _modifier = modifier;
+        _key = key;
+    }
+
+    public ModifierKeys Modifier
+    {
+        get { return _modifier; }
+    }
+
+    public Keys Key
+    {
+        get { return _key; }
+    }
+}
+
+/// <summary>
+/// The enumeration of possible modifiers.
+/// </summary>
+[Flags]
+public enum ModifierKeys : uint
+{
+    None = 0,
+    Alt = 1,
+    Control = 2,
+    Shift = 4,
+    Win = 8
+}

app/Input/KeyboardListener.cs

@@ -0,0 +1,56 @@
+using HidLibrary;
+
+namespace GHelper.Input
+{
+    public class KeyboardListener
+    {
+
+        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+
+        public KeyboardListener(Action<int> KeyHandler)
+        {
+            HidDevice? input = AsusUSB.GetDevice();
+            if (input == null) return;
+
+            Logger.WriteLine($"Input: {input.DevicePath}");
+
+            var task = Task.Run(() =>
+            {
+                try
+                {
+                    while (!cancellationTokenSource.Token.IsCancellationRequested)
+                    {
+
+                        // Emergency break
+                        if (input == null || !input.IsConnected)
+                        {
+                            Logger.WriteLine("Listener terminated");
+                            break;
+                        }
+
+                        var data = input.Read().Data;
+                        if (data.Length > 1 && data[0] == AsusUSB.INPUT_HID_ID && data[1] > 0 && data[1] != 236)
+                        {
+                            Logger.WriteLine($"Key: {data[1]}");
+                            KeyHandler(data[1]);
+                        }
+                    }
+
+                    Logger.WriteLine("Listener stopped");
+
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+            });
+
+
+        }
+
+        public void Dispose()
+        {
+            cancellationTokenSource?.Cancel();
+        }
+    }
+}

app/Keyboard.Designer.cs

@@ -1,353 +0,0 @@
-using CustomControls;
-
-namespace GHelper
-{
-    partial class Keyboard
-    {
-        /// <summary>
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary>
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing && (components != null))
-            {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Windows Form Designer generated code
-
-        /// <summary>
-        /// Required method for Designer support - do not modify
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent()
-        {
-            groupBox1 = new GroupBox();
-            textFNF4 = new TextBox();
-            comboFNF4 = new RComboBox();
-            labelFNF4 = new Label();
-            textM4 = new TextBox();
-            textM3 = new TextBox();
-            comboM4 = new RComboBox();
-            labelM4 = new Label();
-            comboM3 = new RComboBox();
-            labelM3 = new Label();
-            groupLight = new GroupBox();
-            labelSpeed = new Label();
-            comboKeyboardSpeed = new RComboBox();
-            checkShutdown = new CheckBox();
-            checkSleep = new CheckBox();
-            checkBoot = new CheckBox();
-            checkAwake = new CheckBox();
-            groupOther = new GroupBox();
-            checkNoOverdrive = new CheckBox();
-            checkKeyboardAuto = new CheckBox();
-            checkTopmost = new CheckBox();
-            pictureHelp = new PictureBox();
-            groupBox1.SuspendLayout();
-            groupLight.SuspendLayout();
-            groupOther.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureHelp).BeginInit();
-            SuspendLayout();
-            // 
-            // groupBox1
-            // 
-            groupBox1.Controls.Add(pictureHelp);
-            groupBox1.Controls.Add(textFNF4);
-            groupBox1.Controls.Add(comboFNF4);
-            groupBox1.Controls.Add(labelFNF4);
-            groupBox1.Controls.Add(textM4);
-            groupBox1.Controls.Add(textM3);
-            groupBox1.Controls.Add(comboM4);
-            groupBox1.Controls.Add(labelM4);
-            groupBox1.Controls.Add(comboM3);
-            groupBox1.Controls.Add(labelM3);
-            groupBox1.Dock = DockStyle.Top;
-            groupBox1.Location = new Point(10, 10);
-            groupBox1.Name = "groupBox1";
-            groupBox1.Size = new Size(810, 242);
-            groupBox1.TabIndex = 0;
-            groupBox1.TabStop = false;
-            groupBox1.Text = Properties.Strings.KeyBindings;
-            // 
-            // textFNF4
-            // 
-            textFNF4.Location = new Point(415, 176);
-            textFNF4.Name = "textFNF4";
-            textFNF4.PlaceholderText = "action";
-            textFNF4.Size = new Size(320, 39);
-            textFNF4.TabIndex = 8;
-            // 
-            // comboFNF4
-            // 
-            comboFNF4.FormattingEnabled = true;
-            comboFNF4.Location = new Point(93, 175);
-            comboFNF4.Name = "comboFNF4";
-            comboFNF4.Size = new Size(312, 40);
-            comboFNF4.TabIndex = 7;
-            comboFNF4.BorderColor = Color.White;
-            // 
-            // labelFNF4
-            // 
-            labelFNF4.AutoSize = true;
-            labelFNF4.Location = new Point(2, 178);
-            labelFNF4.Name = "labelFNF4";
-            labelFNF4.Size = new Size(90, 32);
-            labelFNF4.TabIndex = 6;
-            labelFNF4.Text = "FN+F4:";
-            // 
-            // textM4
-            // 
-            textM4.Location = new Point(415, 113);
-            textM4.Name = "textM4";
-            textM4.PlaceholderText = "action";
-            textM4.Size = new Size(320, 39);
-            textM4.TabIndex = 5;
-            // 
-            // textM3
-            // 
-            textM3.Location = new Point(415, 54);
-            textM3.Name = "textM3";
-            textM3.PlaceholderText = "notepad /p \"file.txt\"";
-            textM3.Size = new Size(320, 39);
-            textM3.TabIndex = 4;
-            // 
-            // comboM4
-            // 
-            comboM4.FormattingEnabled = true;
-            comboM4.Items.AddRange(new object[] { Properties.Strings.PerformanceMode, Properties.Strings.OpenGHelper, Properties.Strings.Custom });
-            comboM4.Location = new Point(93, 112);
-            comboM4.Name = "comboM4";
-            comboM4.Size = new Size(312, 40);
-            comboM4.TabIndex = 3;
-            comboM4.BorderColor = Color.White;
-
-            // 
-            // labelM4
-            // 
-            labelM4.AutoSize = true;
-            labelM4.Location = new Point(25, 116);
-            labelM4.Name = "labelM4";
-            labelM4.Size = new Size(54, 32);
-            labelM4.TabIndex = 2;
-            labelM4.Text = "M4:";
-            // 
-            // comboM3
-            // 
-            comboM3.FormattingEnabled = true;
-            comboM3.Items.AddRange(new object[] { Properties.Strings.Default, Properties.Strings.VolumeMute, Properties.Strings.PlayPause, Properties.Strings.PrintScreen, Properties.Strings.ToggleAura, Properties.Strings.Custom });
-            comboM3.Location = new Point(93, 54);
-            comboM3.Name = "comboM3";
-            comboM3.Size = new Size(312, 40);
-            comboM3.TabIndex = 1;
-            comboM3.BorderColor = Color.White;
-
-            // 
-            // labelM3
-            // 
-            labelM3.AutoSize = true;
-            labelM3.Location = new Point(25, 58);
-            labelM3.Name = "labelM3";
-            labelM3.Size = new Size(54, 32);
-            labelM3.TabIndex = 0;
-            labelM3.Text = "M3:";
-            // 
-            // groupLight
-            // 
-            groupLight.Controls.Add(labelSpeed);
-            groupLight.Controls.Add(comboKeyboardSpeed);
-            groupLight.Controls.Add(checkShutdown);
-            groupLight.Controls.Add(checkSleep);
-            groupLight.Controls.Add(checkBoot);
-            groupLight.Controls.Add(checkAwake);
-            groupLight.Dock = DockStyle.Top;
-            groupLight.Location = new Point(10, 252);
-            groupLight.Name = "groupLight";
-            groupLight.Size = new Size(810, 320);
-            groupLight.TabIndex = 1;
-            groupLight.TabStop = false;
-            groupLight.Text = Properties.Strings.KeyboardBacklight;
-            // 
-            // labelSpeed
-            // 
-            labelSpeed.AutoSize = true;
-            labelSpeed.Location = new Point(25, 237);
-            labelSpeed.MaximumSize = new Size(200, 0);
-            labelSpeed.Name = "labelSpeed";
-            labelSpeed.Size = new Size(198, 32);
-            labelSpeed.TabIndex = 40;
-            labelSpeed.Text = Properties.Strings.AnimationSpeed;
-            // 
-            // comboKeyboardSpeed
-            // 
-            comboKeyboardSpeed.BorderColor = Color.White;
-            comboKeyboardSpeed.ButtonColor = SystemColors.ControlLight;
-            comboKeyboardSpeed.FlatStyle = FlatStyle.Flat;
-            comboKeyboardSpeed.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
-            comboKeyboardSpeed.FormattingEnabled = true;
-            comboKeyboardSpeed.ItemHeight = 32;
-            comboKeyboardSpeed.Items.AddRange(new object[] { "Slow", "Normal", "Fast" });
-            comboKeyboardSpeed.Location = new Point(230, 234);
-            comboKeyboardSpeed.Margin = new Padding(4, 10, 4, 8);
-            comboKeyboardSpeed.Name = "comboKeyboardSpeed";
-            comboKeyboardSpeed.Size = new Size(291, 40);
-            comboKeyboardSpeed.TabIndex = 39;
-            comboKeyboardSpeed.TabStop = false;
-            // 
-            // checkShutdown
-            // 
-            checkShutdown.AutoSize = true;
-            checkShutdown.Location = new Point(25, 185);
-            checkShutdown.Name = "checkShutdown";
-            checkShutdown.Size = new Size(154, 36);
-            checkShutdown.TabIndex = 3;
-            checkShutdown.Text = Properties.Strings.Shutdown;
-            checkShutdown.UseVisualStyleBackColor = true;
-            // 
-            // checkSleep
-            // 
-            checkSleep.AutoSize = true;
-            checkSleep.Location = new Point(25, 143);
-            checkSleep.Name = "checkSleep";
-            checkSleep.Size = new Size(105, 36);
-            checkSleep.TabIndex = 2;
-            checkSleep.Text = Properties.Strings.Sleep;
-            checkSleep.UseVisualStyleBackColor = true;
-            // 
-            // checkBoot
-            // 
-            checkBoot.AutoSize = true;
-            checkBoot.Location = new Point(25, 101);
-            checkBoot.Name = "checkBoot";
-            checkBoot.Size = new Size(96, 36);
-            checkBoot.TabIndex = 1;
-            checkBoot.Text = Properties.Strings.Boot;
-            checkBoot.UseVisualStyleBackColor = true;
-            // 
-            // checkAwake
-            // 
-            checkAwake.AutoSize = true;
-            checkAwake.Location = new Point(25, 59);
-            checkAwake.Name = "checkAwake";
-            checkAwake.Size = new Size(115, 36);
-            checkAwake.TabIndex = 0;
-            checkAwake.Text = Properties.Strings.Awake;
-            checkAwake.UseVisualStyleBackColor = true;
-            // 
-            // groupOther
-            // 
-            groupOther.Controls.Add(checkNoOverdrive);
-            groupOther.Controls.Add(checkKeyboardAuto);
-            groupOther.Controls.Add(checkTopmost);
-            groupOther.Dock = DockStyle.Top;
-            groupOther.Location = new Point(10, 572);
-            groupOther.Name = "groupOther";
-            groupOther.Size = new Size(810, 225);
-            groupOther.TabIndex = 2;
-            groupOther.TabStop = false;
-            groupOther.Text = Properties.Strings.Other;
-            // 
-            // checkNoOverdrive
-            // 
-            checkNoOverdrive.AutoSize = true;
-            checkNoOverdrive.Location = new Point(25, 156);
-            checkNoOverdrive.Name = "checkNoOverdrive";
-            checkNoOverdrive.Size = new Size(307, 36);
-            checkNoOverdrive.TabIndex = 3;
-            checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
-            checkNoOverdrive.UseVisualStyleBackColor = true;
-            // 
-            // checkKeyboardAuto
-            // 
-            checkKeyboardAuto.AutoEllipsis = true;
-            checkKeyboardAuto.AutoSize = true;
-            checkKeyboardAuto.Location = new Point(25, 51);
-            checkKeyboardAuto.MaximumSize = new Size(780, 0);
-            checkKeyboardAuto.Name = "checkKeyboardAuto";
-            checkKeyboardAuto.Size = new Size(712, 36);
-            checkKeyboardAuto.TabIndex = 2;
-            checkKeyboardAuto.Text = Properties.Strings.KeyboardAuto;
-            checkKeyboardAuto.UseVisualStyleBackColor = true;
-            // 
-            // checkTopmost
-            // 
-            checkTopmost.AutoSize = true;
-            checkTopmost.Location = new Point(25, 104);
-            checkTopmost.Name = "checkTopmost";
-            checkTopmost.Size = new Size(390, 36);
-            checkTopmost.TabIndex = 1;
-            checkTopmost.Text = Properties.Strings.WindowTop;
-            checkTopmost.UseVisualStyleBackColor = true;
-            // 
-            // pictureHelp
-            // 
-            pictureHelp.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureHelp.Cursor = Cursors.Hand;
-            pictureHelp.BackgroundImage = Properties.Resources.icons8_help_64;
-            pictureHelp.Location = new Point(744, 57);
-            pictureHelp.Name = "pictureHelp";
-            pictureHelp.Size = new Size(32, 32);
-            pictureHelp.TabIndex = 9;
-            pictureHelp.TabStop = false;
-            // 
-            // Keyboard
-            // 
-            AutoScaleDimensions = new SizeF(13F, 32F);
-            AutoScaleMode = AutoScaleMode.Font;
-            ClientSize = new Size(830, 858);
-            Controls.Add(groupOther);
-            Controls.Add(groupLight);
-            Controls.Add(groupBox1);
-            FormBorderStyle = FormBorderStyle.FixedSingle;
-            MaximizeBox = false;
-            MdiChildrenMinimizedAnchorBottom = false;
-            MinimizeBox = false;
-            Name = "Keyboard";
-            Padding = new Padding(10);
-            ShowIcon = false;
-            ShowInTaskbar = false;
-            Text = Properties.Strings.ExtraSettings;
-            groupBox1.ResumeLayout(false);
-            groupBox1.PerformLayout();
-            groupLight.ResumeLayout(false);
-            groupLight.PerformLayout();
-            groupOther.ResumeLayout(false);
-            groupOther.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureHelp).EndInit();
-            ResumeLayout(false);
-        }
-
-        #endregion
-
-        private GroupBox groupBox1;
-        private Label labelM3;
-        private RComboBox comboM3;
-        private RComboBox comboM4;
-        private Label labelM4;
-        private TextBox textM4;
-        private TextBox textM3;
-        private TextBox textFNF4;
-        private RComboBox comboFNF4;
-        private Label labelFNF4;
-        private GroupBox groupLight;
-        private CheckBox checkSleep;
-        private CheckBox checkBoot;
-        private CheckBox checkAwake;
-        private CheckBox checkShutdown;
-        private Label labelSpeed;
-        private RComboBox comboKeyboardSpeed;
-        private GroupBox groupOther;
-        private CheckBox checkTopmost;
-        private CheckBox checkKeyboardAuto;
-        private CheckBox checkNoOverdrive;
-        private PictureBox pictureHelp;
-    }
-}

app/Keyboard.cs

@@ -1,140 +0,0 @@
-using CustomControls;
-using System.Diagnostics;
-
-namespace GHelper
-{
-    public partial class Keyboard : RForm
-    {
-
-        Dictionary<string, string> customActions = new Dictionary<string, string>
-        {
-          {"","--------------" },
-          {"mute", Properties.Strings.VolumeMute},
-          {"screenshot", Properties.Strings.PrintScreen},
-          {"play", Properties.Strings.PlayPause},
-          {"aura", Properties.Strings.ToggleAura},
-          {"ghelper", Properties.Strings.OpenGHelper},
-          {"custom", Properties.Strings.Custom}
-        };
-
-        private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
-        {
-            if (name == "m4")
-                customActions[""] = Properties.Strings.PerformanceMode;
-
-            if (name == "fnf4")
-            {
-                customActions[""] = Properties.Strings.ToggleAura;
-                customActions.Remove("aura");
-            }
-
-            combo.DropDownStyle = ComboBoxStyle.DropDownList;
-            combo.DataSource = new BindingSource(customActions, null);
-            combo.DisplayMember = "Value";
-            combo.ValueMember = "Key";
-
-            string action = Program.config.getConfigString(name);
-
-            combo.SelectedValue = (action is not null) ? action : "";
-            if (combo.SelectedValue is null) combo.SelectedValue = "";
-
-            combo.SelectedValueChanged += delegate
-            {
-                if (combo.SelectedValue is not null)
-                    Program.config.setConfig(name, combo.SelectedValue.ToString());
-            };
-
-            txbox.Text = Program.config.getConfigString(name + "_custom");
-            txbox.TextChanged += delegate
-            {
-                Program.config.setConfig(name + "_custom", txbox.Text);
-            };
-        }
-
-        public Keyboard()
-        {
-            InitializeComponent();
-            InitTheme();
-
-            SetKeyCombo(comboM3, textM3, "m3");
-            SetKeyCombo(comboM4, textM4, "m4");
-            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
-
-            Shown += Keyboard_Shown;
-
-            comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboKeyboardSpeed.DataSource = new BindingSource(Aura.GetSpeeds(), null);
-            comboKeyboardSpeed.DisplayMember = "Value";
-            comboKeyboardSpeed.ValueMember = "Key";
-            comboKeyboardSpeed.SelectedValue = Aura.Speed;
-            comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
-
-            checkAwake.Checked = !(Program.config.getConfig("keyboard_awake") == 0);
-            checkBoot.Checked = !(Program.config.getConfig("keyboard_boot") == 0);
-            checkSleep.Checked = !(Program.config.getConfig("keyboard_sleep") == 0);
-            checkShutdown.Checked = !(Program.config.getConfig("keyboard_shutdown") == 0);
-
-            checkAwake.CheckedChanged += CheckPower_CheckedChanged;
-            checkBoot.CheckedChanged += CheckPower_CheckedChanged;
-            checkSleep.CheckedChanged += CheckPower_CheckedChanged;
-            checkShutdown.CheckedChanged += CheckPower_CheckedChanged;
-
-            checkTopmost.Checked = (Program.config.getConfig("topmost") == 1);
-            checkTopmost.CheckedChanged += CheckTopmost_CheckedChanged; ;
-
-            checkKeyboardAuto.Checked = (Program.config.getConfig("keyboard_auto") == 1);
-            checkKeyboardAuto.CheckedChanged += CheckKeyboardAuto_CheckedChanged;
-
-            checkNoOverdrive.Checked = (Program.config.getConfig("no_overdrive") == 1);
-            checkNoOverdrive.CheckedChanged += CheckNoOverdrive_CheckedChanged;
-
-            pictureHelp.Click += PictureHelp_Click;
-
-        }
-
-        private void PictureHelp_Click(object? sender, EventArgs e)
-        {
-            Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper#custom-hotkey-actions") { UseShellExecute = true });
-        }
-
-        private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
-            Program.settingsForm.AutoScreen(true);
-        }
-
-        private void CheckKeyboardAuto_CheckedChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("keyboard_auto", (checkKeyboardAuto.Checked ? 1 : 0));
-        }
-
-        private void CheckTopmost_CheckedChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("topmost", (checkTopmost.Checked ? 1 : 0));
-            Program.settingsForm.TopMost = checkTopmost.Checked;
-        }
-
-        private void CheckPower_CheckedChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("keyboard_awake", (checkAwake.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_boot", (checkBoot.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_sleep", (checkSleep.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_shutdown", (checkShutdown.Checked ? 1 : 0));
-
-            Aura.ApplyAuraPower(checkAwake.Checked, checkBoot.Checked, checkSleep.Checked, checkShutdown.Checked);
-        }
-
-        private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
-            Program.settingsForm.SetAura();
-        }
-
-
-        private void Keyboard_Shown(object? sender, EventArgs e)
-        {
-            Top = Program.settingsForm.Top;
-            Left = Program.settingsForm.Left - Width - 5;
-        }
-    }
-}

app/Keyboard.resx

@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

app/Mode/ModeControl.cs

@@ -0,0 +1,407 @@
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using Ryzen;
+
+namespace GHelper.Mode
+{
+    public class ModeControl
+    {
+
+        static SettingsForm settings = Program.settingsForm;
+
+        private static bool customFans = false;
+        private static int customPower = 0;
+
+        private int _cpuUV = 0;
+        private int _igpuUV = 0;
+
+        static System.Timers.Timer reapplyTimer = default!;
+
+        public ModeControl()
+        {
+            reapplyTimer = new System.Timers.Timer(30 * 1000);
+            reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
+            reapplyTimer.Enabled = false;
+        }
+
+        private void ReapplyTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            SetCPUTemp(AppConfig.GetMode("cpu_temp"), false);
+        }
+
+        public void AutoPerformance(bool powerChanged = false)
+        {
+            var Plugged = SystemInformation.PowerStatus.PowerLineStatus;
+
+            int mode = AppConfig.Get("performance_" + (int)Plugged);
+
+            if (mode != -1)
+                SetPerformanceMode(mode, powerChanged);
+            else
+                SetPerformanceMode(Modes.GetCurrent());
+        }
+
+
+        public void ResetPerformanceMode()
+        {
+            ResetRyzen();
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
+        }
+
+        public void SetPerformanceMode(int mode = -1, bool notify = false)
+        {
+
+            int oldMode = Modes.GetCurrent();
+            if (mode < 0) mode = oldMode;
+
+            if (!Modes.Exists(mode)) mode = 0;
+
+            customFans = false;
+            customPower = 0;
+
+            settings.ShowMode(mode);
+            SetModeLabel();
+
+            Modes.SetCurrent(mode);
+
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
+
+            if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
+
+            if (notify)
+                Program.toast.RunToast(Modes.GetCurrentName(), SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online ? ToastIcon.Charger : ToastIcon.Battery);
+
+            SetGPUClocks();
+            AutoFans();
+            AutoPower(1000);
+
+            if (AppConfig.Get("auto_apply_power_plan") != 0)
+            {
+                if (AppConfig.GetModeString("scheme") is not null)
+                    NativeMethods.SetPowerScheme(AppConfig.GetModeString("scheme"));
+                else
+                    NativeMethods.SetPowerScheme(Modes.GetBase(mode));
+            }
+
+            if (AppConfig.GetMode("auto_boost") != -1)
+            {
+                NativeMethods.SetCPUBoost(AppConfig.GetMode("auto_boost"));
+            }
+
+            /*
+            if (NativeMethods.PowerGetEffectiveOverlayScheme(out Guid activeScheme) == 0)
+            {
+                Debug.WriteLine("Effective :" + activeScheme);
+            }
+            */
+
+            settings.FansInit();
+        }
+
+
+        public void CyclePerformanceMode()
+        {
+            SetPerformanceMode(Modes.GetNext(Control.ModifierKeys == Keys.Shift), true);
+        }
+
+        public void AutoFans(bool force = false)
+        {
+            customFans = false;
+
+            if (AppConfig.IsMode("auto_apply") || force)
+            {
+
+                bool xgmFan = false;
+                if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected())
+                {
+                    AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                    xgmFan = true;
+                }
+
+                int cpuResult = Program.acpi.SetFanCurve(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
+                int gpuResult = Program.acpi.SetFanCurve(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
+
+                if (AppConfig.Is("mid_fan"))
+                    Program.acpi.SetFanCurve(AsusFan.Mid, AppConfig.GetFanConfig(AsusFan.Mid));
+
+
+                // something went wrong, resetting to default profile
+                if (cpuResult != 1 || gpuResult != 1)
+                {
+                    int mode = Modes.GetCurrentBase();
+                    Logger.WriteLine("ASUS BIOS rejected fan curve, resetting mode to " + mode);
+                    Program.acpi.DeviceSet(AsusACPI.PerformanceMode, mode, "Reset Mode");
+                    settings.LabelFansResult("ASUS BIOS rejected fan curve");
+                }
+                else
+                {
+                    settings.LabelFansResult("");
+                    customFans = true;
+                }
+
+                // force set PPTs for missbehaving bios on FX507/517 series
+                if ((AppConfig.ContainsModel("FX507") || AppConfig.ContainsModel("FX517") || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
+                {
+                    Task.Run(async () =>
+                    {
+                        await Task.Delay(TimeSpan.FromSeconds(1));
+                        Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, 80, "PowerLimit Fix A0");
+                        Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, 80, "PowerLimit Fix A3");
+                    });
+                }
+
+            }
+
+            SetModeLabel();
+
+        }
+
+        private static bool IsManualModeRequired()
+        {
+            if (!AppConfig.IsMode("auto_apply_power"))
+                return false;
+
+            return
+                AppConfig.Is("manual_mode") ||
+                AppConfig.ContainsModel("GU603") ||
+                AppConfig.ContainsModel("GU604") ||
+                AppConfig.ContainsModel("G733");
+        }
+
+        public void AutoPower(int delay = 0)
+        {
+
+            customPower = 0;
+
+            bool applyPower = AppConfig.IsMode("auto_apply_power");
+            bool applyFans = AppConfig.IsMode("auto_apply");
+            //bool applyGPU = true;
+
+            if (applyPower)
+            {
+                // force fan curve for misbehaving bios PPTs on G513
+                if (AppConfig.ContainsModel("G513") && !applyFans)
+                {
+                    delay = 500;
+                    AutoFans(true);
+                }
+
+                // Fix for models that don't support PPT settings in all modes, setting a "manual" mode for them
+                if (IsManualModeRequired() && !applyFans)
+                {
+                    AutoFans(true);
+                }
+            }
+
+            if (delay > 0)
+            {
+                var timer = new System.Timers.Timer(delay);
+                timer.Elapsed += delegate
+                {
+                    timer.Stop();
+                    timer.Dispose();
+
+                    if (applyPower) SetPower();
+                    SetGPUPower();
+                    AutoRyzen();
+                };
+                timer.Start();
+            }
+            else
+            {
+                if (applyPower) SetPower(true);
+                SetGPUPower();
+                AutoRyzen();
+            }
+
+        }
+
+        public void SetModeLabel()
+        {
+            settings.SetModeLabel(Properties.Strings.PerformanceMode + ": " + Modes.GetCurrentName() + (customFans ? "+" : "") + ((customPower > 0) ? " " + customPower + "W" : ""));
+        }
+
+        public void SetPower(bool launchAsAdmin = false)
+        {
+
+            int limit_total = AppConfig.GetMode("limit_total");
+            int limit_cpu = AppConfig.GetMode("limit_cpu");
+            int limit_fast = AppConfig.GetMode("limit_fast");
+
+            if (limit_total > AsusACPI.MaxTotal) return;
+            if (limit_total < AsusACPI.MinTotal) return;
+
+            if (limit_cpu > AsusACPI.MaxCPU) return;
+            if (limit_cpu < AsusACPI.MinCPU) return;
+
+            if (limit_fast > AsusACPI.MaxTotal) return;
+            if (limit_fast < AsusACPI.MinTotal) return;
+
+            // SPL + SPPT togeher in one slider
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, limit_total, "PowerLimit A0");
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, limit_total, "PowerLimit A3");
+                customPower = limit_total;
+            }
+            else if (RyzenControl.IsAMD())
+            {
+
+                if (ProcessHelper.IsUserAdministrator())
+                {
+                    SendCommand.set_stapm_limit((uint)limit_total * 1000);
+                    SendCommand.set_stapm2_limit((uint)limit_total * 1000);
+                    SendCommand.set_slow_limit((uint)limit_total * 1000);
+                    SendCommand.set_fast_limit((uint)limit_total * 1000);
+                    customPower = limit_total;
+                }
+                else if (launchAsAdmin)
+                {
+                    ProcessHelper.RunAsAdmin("cpu");
+                    return;
+                }
+            }
+
+            if (Program.acpi.IsAllAmdPPT()) // CPU limit all amd models
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_CPUB0, limit_cpu, "PowerLimit B0");
+                customPower = limit_cpu;
+            }
+            else if (Program.acpi.DeviceGet(AsusACPI.PPT_APUC1) >= 0) // FPPT boost for non all-amd models
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUC1, limit_fast, "PowerLimit C1");
+                customPower = limit_fast;
+            }
+
+
+            SetModeLabel();
+
+        }
+
+        public void SetGPUClocks(bool launchAsAdmin = true)
+        {
+
+            int gpu_core = AppConfig.GetMode("gpu_core");
+            int gpu_memory = AppConfig.GetMode("gpu_memory");
+
+            if (gpu_core == -1 && gpu_memory == -1) return;
+
+            //if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
+
+            if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) return;
+            if (HardwareControl.GpuControl is null) return;
+            if (!HardwareControl.GpuControl!.IsNvidia) return;
+
+            using NvidiaGpuControl nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+            try
+            {
+                int getStatus = nvControl.GetClocks(out int current_core, out int current_memory);
+                if (getStatus != -1)
+                {
+                    if (Math.Abs(gpu_core - current_core) < 5 && Math.Abs(gpu_memory - current_memory) < 5) return;
+                }
+
+                int setStatus = nvControl.SetClocks(gpu_core, gpu_memory);
+                if (launchAsAdmin && setStatus == -1) ProcessHelper.RunAsAdmin("gpu");
+
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        public void SetGPUPower()
+        {
+
+            int gpu_boost = AppConfig.GetMode("gpu_boost");
+            int gpu_temp = AppConfig.GetMode("gpu_temp");
+
+
+            if (gpu_boost < AsusACPI.MinGPUBoost || gpu_boost > AsusACPI.MaxGPUBoost) return;
+            if (gpu_temp < AsusACPI.MinGPUTemp || gpu_temp > AsusACPI.MaxGPUTemp) return;
+
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.PPT_GPUC0, gpu_boost, "PowerLimit C0");
+
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC2) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.PPT_GPUC2, gpu_temp, "PowerLimit C2");
+
+        }
+
+        public void SetCPUTemp(int? cpuTemp, bool log = true)
+        {
+            if (cpuTemp >= RyzenControl.MinTemp && cpuTemp <= RyzenControl.MaxTemp)
+            {
+                var resultCPU = SendCommand.set_tctl_temp((uint)cpuTemp);
+                if (log) Logger.WriteLine($"CPU Temp: {cpuTemp} {resultCPU}");
+
+                var restultAPU = SendCommand.set_apu_skin_temp_limit((uint)cpuTemp);
+                if (log) Logger.WriteLine($"APU Temp: {cpuTemp} {restultAPU}");
+
+                reapplyTimer.Enabled = AppConfig.IsMode("auto_uv");
+
+            }
+            else
+            {
+                reapplyTimer.Enabled = false;
+            }
+        }
+
+        public void SetUV(int cpuUV)
+        {
+            if (cpuUV >= RyzenControl.MinCPUUV && cpuUV <= RyzenControl.MaxCPUUV)
+            {
+                var uvResult = SendCommand.set_coall(cpuUV);
+                Logger.WriteLine($"UV: {cpuUV} {uvResult}");
+                if (uvResult == Smu.Status.OK) _cpuUV = cpuUV;
+            }
+        }
+
+        public void SetUViGPU(int igpuUV)
+        {
+            if (igpuUV >= RyzenControl.MinIGPUUV && igpuUV <= RyzenControl.MaxIGPUUV)
+            {
+                var iGPUResult = SendCommand.set_cogfx(igpuUV);
+                Logger.WriteLine($"iGPU UV: {igpuUV} {iGPUResult}");
+                if (iGPUResult == Smu.Status.OK) _igpuUV = igpuUV;
+            }
+        }
+
+
+        public void SetRyzen(bool launchAsAdmin = false)
+        {
+            if (!ProcessHelper.IsUserAdministrator())
+            {
+                if (launchAsAdmin) ProcessHelper.RunAsAdmin("uv");
+                return;
+            }
+
+            try
+            {
+                SetUV(AppConfig.GetMode("cpu_uv", 0));
+                SetUViGPU(AppConfig.GetMode("igpu_uv", 0));
+                SetCPUTemp(AppConfig.GetMode("cpu_temp"));
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine("UV Error: " + ex.ToString());
+            }
+        }
+
+        public void ResetRyzen()
+        {
+            if (_cpuUV != 0) SetUV(0);
+            if (_igpuUV != 0) SetUViGPU(0);
+        }
+
+        public void AutoRyzen()
+        {
+            if (!RyzenControl.IsAMD()) return;
+
+            if (AppConfig.IsMode("auto_uv")) SetRyzen();
+            else ResetRyzen();
+        }
+
+    }
+}

app/Mode/Modes.cs

@@ -0,0 +1,154 @@
+namespace GHelper.Mode
+{
+    internal class Modes
+    {
+
+        const int maxModes = 20;
+
+        public static Dictionary<int, string> GetDictonary()
+        {
+            Dictionary<int, string> modes = new Dictionary<int, string>
+            {
+              {2, Properties.Strings.Silent},
+              {0, Properties.Strings.Balanced},
+              {1, Properties.Strings.Turbo}
+            };
+
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (Exists(i)) modes.Add(i, GetName(i));
+            }
+
+            return modes;
+        }
+
+        public static List<int> GetList()
+        {
+            List<int> modes = new() { 2, 0, 1 };
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (Exists(i)) modes.Add(i);
+            }
+
+            return modes;
+        }
+
+        public static void Remove(int mode)
+        {
+            List<string> cleanup = new() {
+                "mode_base",
+                "mode_name",
+                "limit_total",
+                "limit_fast",
+                "limit_cpu",
+                "limit_total",
+                "fan_profile_cpu",
+                "fan_profile_gpu",
+                "fan_profile_mid",
+                "gpu_boost",
+                "gpu_temp",
+                "gpu_core",
+                "gpu_memory",
+                "auto_boost",
+                "auto_apply",
+                "auto_apply_power"
+            };
+
+            foreach (string clean in cleanup)
+            {
+                AppConfig.Remove(clean + "_" + mode);
+            }
+        }
+
+        public static int Add()
+        {
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (!Exists(i))
+                {
+                    int modeBase = GetCurrentBase();
+                    string nameName = "Custom " + (i - 2);
+                    AppConfig.Set("mode_base_" + i, modeBase);
+                    AppConfig.Set("mode_name_" + i, nameName);
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        public static int GetCurrent()
+        {
+            return AppConfig.Get("performance_mode");
+        }
+
+        public static bool IsCurrentCustom()
+        {
+            return GetCurrent() > 2;
+        }
+
+        public static void SetCurrent(int mode)
+        {
+            AppConfig.Set("performance_" + (int)SystemInformation.PowerStatus.PowerLineStatus, mode);
+            AppConfig.Set("performance_mode", mode);
+        }
+
+        public static int GetCurrentBase()
+        {
+            return GetBase(GetCurrent());
+        }
+
+        public static string GetCurrentName()
+        {
+            return GetName(GetCurrent());
+        }
+
+        public static bool Exists(int mode)
+        {
+            return GetBase(mode) >= 0;
+        }
+
+        public static int GetBase(int mode)
+        {
+            if (mode >= 0 && mode <= 2)
+                return mode;
+            else
+                return AppConfig.Get("mode_base_" + mode);
+        }
+
+        public static string GetName(int mode)
+        {
+            switch (mode)
+            {
+                case 0:
+                    return Properties.Strings.Balanced;
+                case 1:
+                    return Properties.Strings.Turbo;
+                case 2:
+                    return Properties.Strings.Silent;
+                default:
+                    return AppConfig.GetString("mode_name_" + mode);
+            }
+        }
+
+
+        public static int GetNext(bool back = false)
+        {
+            var modes = GetList();
+            int index = modes.IndexOf(GetCurrent());
+
+            if (back)
+            {
+                index--;
+                if (index < 0) index = modes.Count - 1;
+                return modes[index];
+            }
+            else
+            {
+                index++;
+                if (index > modes.Count - 1) index = 0;
+                return modes[index];
+            }
+        }
+    }
+}

app/NativeMethods.cs

@@ -1,5 +1,4 @@
-using GHelper;
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using static Tools.ScreenInterrogatory;
@@ -7,47 +6,6 @@ using static Tools.ScreenInterrogatory;
 namespace Tools
 {
 
-    public class KeyHandler
-    {
-
-        public const int NOMOD = 0x0000;
-        public const int ALT = 0x0001;
-        public const int CTRL = 0x0002;
-        public const int SHIFT = 0x0004;
-        public const int WIN = 0x0008;
-
-        public const int WM_HOTKEY_MSG_ID = 0x0312;
-
-
-        [DllImport("user32.dll")]
-        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
-        [DllImport("user32.dll")]
-        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
-
-        private int modifier;
-        private int key;
-        private IntPtr hWnd;
-        private int id;
-        public KeyHandler(int modifier, Keys key, nint handle)
-        {
-            this.modifier = modifier;
-            this.key = (int)key;
-            this.hWnd = handle;
-            id = this.GetHashCode();
-        }
-        public override int GetHashCode()
-        {
-            return modifier ^ key ^ hWnd.ToInt32();
-        }
-        public bool Register()
-        {
-            return RegisterHotKey(hWnd, id, modifier, key);
-        }
-        public bool Unregiser()
-        {
-            return UnregisterHotKey(hWnd, id);
-        }
-    }
 
     public static class ScreenInterrogatory
     {
@@ -351,6 +309,54 @@ namespace Tools
 public class NativeMethods
 {
 
+    internal struct LASTINPUTINFO
+    {
+        public uint cbSize;
+        public uint dwTime;
+    }
+
+    [DllImport("User32.dll")]
+    private static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
+
+    public static TimeSpan GetIdleTime()
+    {
+        LASTINPUTINFO lastInPut = new LASTINPUTINFO();
+        lastInPut.cbSize = (uint)Marshal.SizeOf(lastInPut);
+        GetLastInputInfo(ref lastInPut);
+        return TimeSpan.FromMilliseconds((uint)Environment.TickCount - lastInPut.dwTime);
+
+    }
+
+    [DllImport("User32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr handle);
+
+    private const int WM_SYSCOMMAND = 0x0112;
+    private const int SC_MONITORPOWER = 0xF170;
+    private const int MONITOR_OFF = 2;
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern uint FormatMessage(uint dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, out string lpBuffer, uint nSize, IntPtr Arguments);
+
+    public static void TurnOffScreen(IntPtr handle)
+    {
+        IntPtr result = SendMessage(handle, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
+        if (result == IntPtr.Zero)
+        {
+            int error = Marshal.GetLastWin32Error();
+            string message = "";
+            uint formatFlags = 0x00001000 | 0x00000200 | 0x00000100 | 0x00000080;
+            uint formatResult = FormatMessage(formatFlags, IntPtr.Zero, (uint)error, 0, out message, 0, IntPtr.Zero);
+            if (formatResult == 0)
+            {
+                message = "Unknown error.";
+            }
+            Logger.WriteLine($"Failed to turn off screen. Error code: {error}. {message}");
+        }
+    }
+
     // Monitor Power detection
 
     internal const uint DEVICE_NOTIFY_WINDOW_HANDLE = 0x0;
@@ -408,22 +414,8 @@ public class NativeMethods
     }
 
 
-    public const int KEYEVENTF_EXTENDEDKEY = 1;
-    public const int KEYEVENTF_KEYUP = 2;
-
-    public const int VK_MEDIA_NEXT_TRACK = 0xB0;
-    public const int VK_MEDIA_PLAY_PAUSE = 0xB3;
-    public const int VK_MEDIA_PREV_TRACK = 0xB1;
-    public const int VK_VOLUME_MUTE = 0xAD;
-    public const int VK_SNAPSHOT = 0x2C;
-
-    [DllImport("user32.dll", SetLastError = true)]
-    public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
-
-    public static void KeyPress(int key = VK_MEDIA_PLAY_PAUSE)
-    {
-        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
-    }
+    [DllImport("Powrprof.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
+    public static extern bool SetSuspendState(bool hiberate, bool forceCritical, bool disableWakeEvent);
 
 
     [DllImport("user32.dll")]
@@ -488,6 +480,17 @@ public class NativeMethods
         );
 
 
+    [DllImport("powrprof.dll")]
+    static extern uint PowerReadACValue(
+        IntPtr RootPowerKey,
+        Guid SchemeGuid,
+        Guid SubGroupOfPowerSettingGuid,
+        Guid PowerSettingGuid,
+        ref int Type,
+        ref IntPtr Buffer,
+        ref uint BufferSize
+        );
+
 
     [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
     static extern UInt32 PowerSetActiveScheme(IntPtr RootPowerKey,
@@ -499,6 +502,9 @@ public class NativeMethods
     static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
     static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
 
+    private static Guid GUID_SLEEP_SUBGROUP = new Guid("238c9fa8-0aad-41ed-83f4-97be242c8f20");
+    private static Guid GUID_HIBERNATEIDLE = new Guid("9d7815a6-7ee4-497e-8888-515a05f02364");
+
     [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
     public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
 
@@ -582,6 +588,42 @@ public class NativeMethods
         return dm;
     }
 
+    public enum COLORPROFILETYPE
+    {
+        CPT_ICC,
+        CPT_DMP,
+        CPT_CAMP,
+        CPT_GMMP
+    }
+    public enum COLORPROFILESUBTYPE
+    {
+        CPST_PERCEPTUAL,
+        CPST_RELATIVE_COLORIMETRIC,
+        CPST_SATURATION,
+        CPST_ABSOLUTE_COLORIMETRIC,
+        CPST_NONE,
+        CPST_RGB_WORKING_SPACE,
+        CPST_CUSTOM_WORKING_SPACE,
+        CPST_STANDARD_DISPLAY_COLOR_MODE,
+        CPST_EXTENDED_DISPLAY_COLOR_MODE
+    }
+    public enum WCS_PROFILE_MANAGEMENT_SCOPE
+    {
+        WCS_PROFILE_MANAGEMENT_SCOPE_SYSTEM_WIDE,
+        WCS_PROFILE_MANAGEMENT_SCOPE_CURRENT_USER
+    }
+
+    [DllImport("mscms.dll", CharSet = CharSet.Unicode)]
+    public static extern bool WcsSetDefaultColorProfile(
+        WCS_PROFILE_MANAGEMENT_SCOPE scope,
+        string pDeviceName,
+        COLORPROFILETYPE cptColorProfileType,
+        COLORPROFILESUBTYPE cpstColorProfileSubType,
+        uint dwProfileID,
+        string pProfileName
+    );
+
+
     public const int ENUM_CURRENT_SETTINGS = -1;
     public const string defaultDevice = "\\\\.\\DISPLAY1";
 
@@ -594,16 +636,19 @@ public class NativeMethods
             var devices = GetAllDevices().ToArray();
             int count = 0, displayNum = -1;
 
+            string internalName = AppConfig.GetString("internal_display");
+
             foreach (var device in devices)
             {
                 if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
-                    device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED)
+                    device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
+                    device.monitorFriendlyDeviceName == internalName)
                 {
                     displayNum = count;
+                    AppConfig.Set("internal_display", device.monitorFriendlyDeviceName);
                 }
                 count++;
-                //Logger.WriteLine(device.outputTechnology.ToString());
-                //Logger.WriteLine(device.monitorFriendlyDeviceName);
+                //Logger.WriteLine(device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString());
             }
 
             var screens = Screen.AllScreens;
@@ -620,12 +665,14 @@ public class NativeMethods
                 //Logger.WriteLine(screen.DeviceName);
                 count++;
             }
+
+            if (displayNum > 0 && count == 0) laptopScreen = defaultDevice;
         }
         catch (Exception ex)
         {
             Logger.WriteLine(ex.ToString());
             Logger.WriteLine("Can't detect internal screen");
-            //laptopScreen = Screen.PrimaryScreen.DeviceName;
+            laptopScreen = Screen.PrimaryScreen.DeviceName;
         }
 
 
@@ -676,6 +723,15 @@ public class NativeMethods
             dm.dmDisplayFrequency = frequency;
             int iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
             Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
+
+            //Fallback scenario
+            if (iRet != 0)
+            {
+                Thread.Sleep(300);
+                iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
+                Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
+            }
+
             return iRet;
         }
 
@@ -683,6 +739,20 @@ public class NativeMethods
 
     }
 
+    public static nint GetHuibernateAfter()
+    {
+        Guid activePolicyGuid = GetActiveScheme();
+        var type = 0;
+        nint value = 0;
+        var valueSize = 4u;
+
+        PowerReadACValue(IntPtr.Zero, activePolicyGuid,
+             GUID_SLEEP_SUBGROUP, GUID_HIBERNATEIDLE,
+            ref type, ref value, ref valueSize);
+
+        return value;
+    }
+
     static Guid GetActiveScheme()
     {
         IntPtr pActiveSchemeGuid;
@@ -709,6 +779,8 @@ public class NativeMethods
     {
         Guid activeSchemeGuid = GetActiveScheme();
 
+        if (boost == GetCPUBoost()) return;
+
         var hrAC = PowerWriteACValueIndex(
              IntPtr.Zero,
              activeSchemeGuid,
@@ -732,8 +804,25 @@ public class NativeMethods
 
     public static void SetPowerScheme(string scheme)
     {
-        PowerSetActiveScheme(IntPtr.Zero, new Guid(scheme));
-        PowerSetActiveOverlayScheme(new Guid(scheme));
+        List<string> overlays = new() {
+            "00000000-0000-0000-0000-000000000000",
+            "ded574b5-45a0-4f42-8737-46345c09c238",
+            "961cc777-2547-4f9d-8174-7d86181b8a7a",
+            "3af9B8d9-7c97-431d-ad78-34a8bfea439f"
+        };
+
+        if (overlays.Contains(scheme))
+        {
+            PowerSetActiveOverlayScheme(new Guid(scheme));
+            Logger.WriteLine("Power mode:" + scheme);
+        }
+        else
+        {
+            PowerSetActiveScheme(IntPtr.Zero, new Guid(scheme));
+            Logger.WriteLine("Power plan:" + scheme);
+        }
+
+
     }
 
     public static void SetPowerScheme(int mode)

app/Program.cs

@@ -1,11 +1,18 @@
+using GHelper.Gpu;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.Mode;
+using GHelper.Display;
 using Microsoft.Win32;
+using Ryzen;
 using System.Diagnostics;
 using System.Globalization;
-using System.Management;
-using Tools;
+using System.Reflection;
+using static NativeMethods;
 
 namespace GHelper
 {
+
     static class Program
     {
         public static NotifyIcon trayIcon = new NotifyIcon
@@ -15,39 +22,48 @@ namespace GHelper
             Visible = true
         };
 
-        public static ASUSWmi? wmi;
-        public static AppConfig config = new AppConfig();
+        public static AsusACPI acpi;
 
         public static SettingsForm settingsForm = new SettingsForm();
+
+        public static ModeControl modeControl = new ModeControl();
+        static GPUModeControl gpuControl = new GPUModeControl();
+        static ScreenControl screenControl = new ScreenControl();
+
         public static ToastForm toast = new ToastForm();
 
         public static IntPtr unRegPowerNotify;
 
         private static long lastAuto;
         private static long lastTheme;
-        private static PowerLineStatus isPlugged = PowerLineStatus.Unknown;
+
+        public static InputDispatcher? inputDispatcher;
+
+        private static PowerLineStatus isPlugged = SystemInformation.PowerStatus.PowerLineStatus;
 
         // The main entry point for the application
-        public static void Main()
+        public static void Main(string[] args)
         {
 
-            Thread.CurrentThread.CurrentUICulture = CultureInfo.CurrentUICulture;
+            string action = "";
+            if (args.Length > 0) action = args[0];
 
-            Debug.WriteLine(CultureInfo.CurrentUICulture);
+            string language = AppConfig.GetString("language");
 
-            //Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("zh");
-
-            if (Process.GetProcesses().Count(p => p.ProcessName == "GHelper") > 1)
+            if (language != null && language.Length > 0)
+                Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(language);
+            else
             {
-                MessageBox.Show(Properties.Strings.AppAlreadyRunningText, Properties.Strings.AppAlreadyRunning, MessageBoxButtons.OK);
-                Application.Exit();
-                return;
+                var culture = CultureInfo.CurrentUICulture;
+                if (culture.ToString() == "kr") culture = CultureInfo.GetCultureInfo("ko");
+                Thread.CurrentThread.CurrentUICulture = culture;
             }
 
+            ProcessHelper.CheckAlreadyRunning();
 
             try
             {
-                wmi = new ASUSWmi();
+                acpi = new AsusACPI();
             }
             catch
             {
@@ -59,56 +75,46 @@ namespace GHelper
 
                 Application.Exit();
                 return;
-
             }
 
-
-
             Logger.WriteLine("------------");
-            Logger.WriteLine("App launched: " + config.GetModel());
+            Logger.WriteLine("App launched: " + AppConfig.GetModel() + " :" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + CultureInfo.CurrentUICulture + (ProcessHelper.IsUserAdministrator() ? "." : ""));
 
             Application.EnableVisualStyles();
 
-            var ds = settingsForm.Handle;
+            HardwareControl.RecreateGpuControl();
+            RyzenControl.Init();
 
             trayIcon.MouseClick += TrayIcon_MouseClick;
 
-            wmi.SubscribeToEvents(WatcherEventArrived);
+            inputDispatcher = new InputDispatcher();
 
             settingsForm.InitAura();
             settingsForm.InitMatrix();
 
-            settingsForm.SetStartupCheck(Startup.IsScheduled());
 
             SetAutoModes();
 
-            HardwareMonitor.RecreateGpuTemperatureProvider();
-
             // Subscribing for system power change events
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
             SystemEvents.UserPreferenceChanged += SystemEvents_UserPreferenceChanged;
 
             // Subscribing for monitor power on events
-            var settingGuid = new NativeMethods.PowerSettingGuid();
-            unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(ds, settingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
+            PowerSettingGuid settingGuid = new NativeMethods.PowerSettingGuid();
+            unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(settingsForm.Handle, settingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
 
-            // CTRL + SHIFT + F5 to cycle profiles
-            var ghk = new KeyHandler(KeyHandler.SHIFT | KeyHandler.CTRL, Keys.F5, ds);
-            ghk.Register();
 
-            if (Environment.CurrentDirectory.Trim('\\') == Application.StartupPath.Trim('\\'))
+            if (Environment.CurrentDirectory.Trim('\\') == Application.StartupPath.Trim('\\') || action.Length > 0)
             {
-                SettingsToggle();
+                SettingsToggle(action);
             }
 
-
-
             Application.Run();
 
-
         }
 
 
+
         static void SystemEvents_UserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
         {
 
@@ -130,175 +136,99 @@ namespace GHelper
                     if (settingsForm.keyb is not null && settingsForm.keyb.Text != "")
                         settingsForm.keyb.InitTheme();
 
+                    if (settingsForm.updates is not null && settingsForm.updates.Text != "")
+                        settingsForm.updates.InitTheme();
+
                     break;
             }
         }
 
 
 
-        public static void SetAutoModes()
+        public static void SetAutoModes(bool powerChanged = false)
         {
 
-            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAuto) < 2000) return;
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAuto) < 3000) return;
             lastAuto = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
             isPlugged = SystemInformation.PowerStatus.PowerLineStatus;
             Logger.WriteLine("AutoSetting for " + isPlugged.ToString());
 
-            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
-            settingsForm.AutoPerformance();
+            inputDispatcher.Init();
 
-            bool switched = settingsForm.AutoGPUMode();
+            settingsForm.SetBatteryChargeLimit(AppConfig.Get("charge_limit"));
+            modeControl.AutoPerformance(powerChanged);
+
+            bool switched = gpuControl.AutoGPUMode();
 
             if (!switched)
             {
-                settingsForm.InitGPUMode();
-                settingsForm.AutoScreen();
+                gpuControl.InitGPUMode();
+                screenControl.AutoScreen();
             }
 
             settingsForm.AutoKeyboard();
-            settingsForm.SetMatrix();
+            settingsForm.matrix.SetMatrix();
         }
 
         private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
         {
             if (SystemInformation.PowerStatus.PowerLineStatus == isPlugged) return;
-
-            Logger.WriteLine("Windows - Power Mode Changed");
-            SetAutoModes();
+            Logger.WriteLine("Power Mode Changed");
+            SetAutoModes(true);
         }
 
 
-        static void LaunchProcess(string fileName = "")
+
+        public static void SettingsToggle(string action = "")
         {
-            ProcessStartInfo start = new ProcessStartInfo();
-            start.FileName = fileName;
-            start.WindowStyle = ProcessWindowStyle.Hidden;
-            start.CreateNoWindow = true;
-            try
-            {
-                Process proc = Process.Start(start);
-            }
-            catch
-            {
-                Logger.WriteLine("Failed to run  " + fileName);
-            }
-
-
-        }
-
-        static void CustomKey(string configKey = "m3")
-        {
-            string command = config.getConfigString(configKey + "_custom");
-            int intKey;
-
-            try
-            {
-                intKey = Convert.ToInt32(command, 16);
-            }
-            catch
-            {
-                intKey = -1;
-            }
-
-
-            if (intKey > 0)
-                NativeMethods.KeyPress(intKey);
-            else
-                LaunchProcess(command);
-
-        }
-
-        static void KeyProcess(string name = "m3")
-        {
-            string action = config.getConfigString(name);
-
-            if (action is null || action.Length <= 1)
-            {
-                if (name == "m4")
-                    action = "performance";
-                if (name == "fnf4")
-                    action = "aura";
-            }
-
-            switch (action)
-            {
-                case "mute":
-                    NativeMethods.KeyPress(NativeMethods.VK_VOLUME_MUTE);
-                    break;
-                case "play":
-                    NativeMethods.KeyPress(NativeMethods.VK_MEDIA_PLAY_PAUSE);
-                    break;
-                case "screenshot":
-                    NativeMethods.KeyPress(NativeMethods.VK_SNAPSHOT);
-                    break;
-                case "aura":
-                    settingsForm.BeginInvoke(settingsForm.CycleAuraMode);
-                    break;
-                case "performance":
-                    settingsForm.BeginInvoke(settingsForm.CyclePerformanceMode);
-                    break;
-                case "ghelper":
-                    settingsForm.BeginInvoke(SettingsToggle);
-                    break;
-                case "custom":
-                    CustomKey(name);
-                    break;
-                default:
-                    break;
-            }
-        }
-
-
-        static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
-        {
-            var collection = (ManagementEventWatcher)sender;
-
-            if (e.NewEvent is null) return;
-
-            int EventID = int.Parse(e.NewEvent["EventID"].ToString());
-
-            Logger.WriteLine("WMI event " + EventID);
-
-            switch (EventID)
-            {
-                case 124:    // M3
-                    KeyProcess("m3");
-                    return;
-                case 56:    // M4 / Rog button
-                    KeyProcess("m4");
-                    return;
-                case 174:   // FN+F5
-                    settingsForm.BeginInvoke(settingsForm.CyclePerformanceMode);
-                    return;
-                case 179:   // FN+F4
-                    KeyProcess("fnf4");
-                    return;
-            }
-
-
-        }
-
-        static void SettingsToggle()
-        {
-            if (settingsForm.Visible)
-                settingsForm.Hide();
+            if (settingsForm.Visible) settingsForm.HideAll();
             else
             {
+
+                settingsForm.Left = Screen.FromControl(settingsForm).WorkingArea.Width - 10 - settingsForm.Width;
+                settingsForm.Top = Screen.FromControl(settingsForm).WorkingArea.Height - 10 - settingsForm.Height;
+
                 settingsForm.Show();
                 settingsForm.Activate();
+
+                settingsForm.Left = Screen.FromControl(settingsForm).WorkingArea.Width - 10 - settingsForm.Width;
+                settingsForm.Top = Screen.FromControl(settingsForm).WorkingArea.Height - 10 - settingsForm.Height;
+
+                settingsForm.VisualiseGPUMode();
+
+                switch (action)
+                {
+                    case "cpu":
+                        Startup.ReScheduleAdmin();
+                        settingsForm.FansToggle();
+                        break;
+                    case "gpu":
+                        Startup.ReScheduleAdmin();
+                        settingsForm.FansToggle(1);
+                        break;
+                    case "gpurestart":
+                        gpuControl.RestartGPU(false);
+                        break;
+                    case "services":
+                        settingsForm.keyb = new Extra();
+                        settingsForm.keyb.Show();
+                        settingsForm.keyb.ServiesToggle();
+                        break;
+                    case "uv":
+                        Startup.ReScheduleAdmin();
+                        settingsForm.FansToggle(2);
+                        modeControl.SetRyzen(); 
+                        break;
+                }
             }
-
-            settingsForm.VisualiseGPUMode();
-
         }
 
         static void TrayIcon_MouseClick(object? sender, MouseEventArgs e)
         {
-            if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right)
-            {
+            if (e.Button == MouseButtons.Left)
                 SettingsToggle();
-            }
+
         }
 
 
@@ -309,6 +239,8 @@ namespace GHelper
             NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotify);
             Application.Exit();
         }
+
+
     }
 
 }

app/Properties/Resources.Designer.cs

@@ -60,6 +60,46 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap backlight_down {
+            get {
+                object obj = ResourceManager.GetObject("backlight_down", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap backlight_up {
+            get {
+                object obj = ResourceManager.GetObject("backlight_up", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap brightness_down {
+            get {
+                object obj = ResourceManager.GetObject("brightness_down", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap brightness_up {
+            get {
+                object obj = ResourceManager.GetObject("brightness_up", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
         /// </summary>
@@ -73,9 +113,9 @@ namespace GHelper.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
-        internal static System.Drawing.Bitmap everything_is_fine_itsfine {
+        internal static System.Drawing.Bitmap icons8_add_64 {
             get {
-                object obj = ResourceManager.GetObject("everything-is-fine-itsfine", resourceCulture);
+                object obj = ResourceManager.GetObject("icons8_add_64", resourceCulture);
                 return ((System.Drawing.Bitmap)(obj));
             }
         }
@@ -100,6 +140,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_boost_30 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-boost-30", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_charged_battery_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_charged_battery_96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -110,6 +170,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_charging_battery_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_charging_battery_96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_edit_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_edit_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -150,6 +230,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_function {
+            get {
+                object obj = ResourceManager.GetObject("icons8_function", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -230,6 +320,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_microphone_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_microphone_96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_mute_unmute_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_mute_unmute_96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -280,6 +390,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_refresh_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-refresh-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_remove_64 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_remove_64", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -290,6 +420,36 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_save_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-save-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_share_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_share_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_software_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-software-48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -330,6 +490,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_temperature_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-temperature-48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_touchpad_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_touchpad_96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -350,6 +530,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_voltage_60 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-voltage-60", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>

app/Properties/Resources.resx

@@ -118,14 +118,20 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="brightness_up" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\brightness-up.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-software-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-software-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-leaf-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-leaf-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-launch-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-launch-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-charging-battery-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-charging-battery-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_mute_unmute_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-mute-unmute-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-organic-food-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-organic-food-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -133,14 +139,17 @@
   <data name="icons8-fiat-500-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-fiat-500-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_microphone_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-microphone-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-project-management-48 (1)" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-project-management-48 (1).png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-bicycle-48 (1)" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-bicycle-48 (1).png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-game-controller-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-game-controller-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_touchpad_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-touchpad-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-fan-head-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-fan-head-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -148,23 +157,47 @@
   <data name="icons8-processor-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-processor-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-spa-flower-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-spa-flower-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_add_64" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-add-64.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-game-controller-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-game-controller-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-spa-flower-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-spa-flower-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_edit_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-edit-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_share_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-share-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="standard" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\standard.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_charged_battery_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-charged-battery-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-voltage-60" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-voltage-60.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="backlight_down" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\backlight-down.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-keyboard-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-keyboard-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="brightness_down" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\brightness-down.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-fan-speed-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-fan-speed-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-speed-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-speed-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-help-64" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-help-64.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_charging_battery_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-charging-battery-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="eco" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\eco.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -175,8 +208,20 @@
   <data name="icons8-video-card-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-video-card-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-organic-food-961" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-organic-food-961.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-charging-battery-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-charging-battery-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="backlight_up" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\backlight-up.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-spa-flower-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-spa-flower-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-save-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-save-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_function" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-function-mac-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-balance-symbol-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-balance-symbol-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -187,9 +232,18 @@
   <data name="icons8-matrix-desktop-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-matrix-desktop-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_remove_64" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-remove-64.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-speed-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-speed-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-xbox-controller-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-xbox-controller-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-organic-food-961" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-organic-food-961.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-project-management-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-project-management-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
@@ -202,16 +256,19 @@
   <data name="icons8-rocket-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-rocket-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-boost-30" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-boost-30.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-speed-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-speed-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="everything-is-fine-itsfine" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\itsfine.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="icons8-help-64" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-help-64.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
   <data name="icons8_video_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-video-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-temperature-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-temperature-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-refresh-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-refresh-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
 </root>

app/Properties/Strings.Designer.cs

@@ -168,6 +168,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Auto adjust Windows Power Modes.
+        /// </summary>
+        internal static string ApplyWindowsPowerPlan {
+            get {
+                return ResourceManager.GetString("ApplyWindowsPowerPlan", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Asus Services Running.
+        /// </summary>
+        internal static string AsusServicesRunning {
+            get {
+                return ResourceManager.GetString("AsusServicesRunning", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Breathe.
         /// </summary>
@@ -267,6 +285,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Backlight timeout on battery.
+        /// </summary>
+        internal static string BacklightTimeout {
+            get {
+                return ResourceManager.GetString("BacklightTimeout", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Backlight timeout when plugged (0 - always on).
+        /// </summary>
+        internal static string BacklightTimeoutPlugged {
+            get {
+                return ResourceManager.GetString("BacklightTimeoutPlugged", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Balanced.
         /// </summary>
@@ -285,6 +321,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to BIOS and Driver Updates.
+        /// </summary>
+        internal static string BiosAndDriverUpdates {
+            get {
+                return ResourceManager.GetString("BiosAndDriverUpdates", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Boot.
         /// </summary>
@@ -294,6 +339,33 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Brightness.
+        /// </summary>
+        internal static string Brightness {
+            get {
+                return ResourceManager.GetString("Brightness", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Brightness Down.
+        /// </summary>
+        internal static string BrightnessDown {
+            get {
+                return ResourceManager.GetString("BrightnessDown", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Brightness Up.
+        /// </summary>
+        internal static string BrightnessUp {
+            get {
+                return ResourceManager.GetString("BrightnessUp", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Color.
         /// </summary>
@@ -357,6 +429,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Drivers and Software.
+        /// </summary>
+        internal static string DriverAndSoftware {
+            get {
+                return ResourceManager.GetString("DriverAndSoftware", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Disables dGPU for battery savings.
         /// </summary>
@@ -375,6 +456,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Disabling the dGPU by going to Eco mode while Display Mode in NVIDIA Control Panel is not set to Optimus might cause problems with brightness controls until after the next reboot. 
+        ///
+        ///Do you still want to continue?.
+        /// </summary>
+        internal static string EnableOptimusText {
+            get {
+                return ResourceManager.GetString("EnableOptimusText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to NVIDIA Display Mode is not set to Optimus.
+        /// </summary>
+        internal static string EnableOptimusTitle {
+            get {
+                return ResourceManager.GetString("EnableOptimusTitle", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Extra.
         /// </summary>
@@ -456,6 +557,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Fan: .
+        /// </summary>
+        internal static string FanSpeed {
+            get {
+                return ResourceManager.GetString("FanSpeed", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Fans + Power.
         /// </summary>
@@ -465,6 +575,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Process Fn+F hotkeys without Fn.
+        /// </summary>
+        internal static string FnLock {
+            get {
+                return ResourceManager.GetString("FnLock", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Dynamic Boost.
+        /// </summary>
+        internal static string GPUBoost {
+            get {
+                return ResourceManager.GetString("GPUBoost", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Changing.
         /// </summary>
@@ -474,6 +602,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Core Clock Offset.
+        /// </summary>
+        internal static string GPUCoreClockOffset {
+            get {
+                return ResourceManager.GetString("GPUCoreClockOffset", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Memory Clock Offset.
+        /// </summary>
+        internal static string GPUMemoryClockOffset {
+            get {
+                return ResourceManager.GetString("GPUMemoryClockOffset", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to GPU Mode.
         /// </summary>
@@ -510,6 +656,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to GPU Settings.
+        /// </summary>
+        internal static string GPUSettings {
+            get {
+                return ResourceManager.GetString("GPUSettings", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Temperature Target.
+        /// </summary>
+        internal static string GPUTempTarget {
+            get {
+                return ResourceManager.GetString("GPUTempTarget", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Key Bindings.
         /// </summary>
@@ -538,11 +702,20 @@ namespace GHelper.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Keyboard Backlight.
+        ///   Looks up a localized string similar to Stop all apps using GPU when switching to Eco.
         /// </summary>
-        internal static string KeyboardBacklight {
+        internal static string KillGpuApps {
             get {
-                return ResourceManager.GetString("KeyboardBacklight", resourceCulture);
+                return ResourceManager.GetString("KillGpuApps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Laptop Backlight.
+        /// </summary>
+        internal static string LaptopBacklight {
+            get {
+                return ResourceManager.GetString("LaptopBacklight", resourceCulture);
             }
         }
         
@@ -564,6 +737,42 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Lid.
+        /// </summary>
+        internal static string Lid {
+            get {
+                return ResourceManager.GetString("Lid", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Lightbar.
+        /// </summary>
+        internal static string Lightbar {
+            get {
+                return ResourceManager.GetString("Lightbar", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Logo.
+        /// </summary>
+        internal static string Logo {
+            get {
+                return ResourceManager.GetString("Logo", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Audio Visualizer.
+        /// </summary>
+        internal static string MatrixAudio {
+            get {
+                return ResourceManager.GetString("MatrixAudio", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Binary Banner.
         /// </summary>
@@ -663,6 +872,33 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Mute Mic.
+        /// </summary>
+        internal static string MuteMic {
+            get {
+                return ResourceManager.GetString("MuteMic", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to New updates.
+        /// </summary>
+        internal static string NewUpdates {
+            get {
+                return ResourceManager.GetString("NewUpdates", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to No new updates.
+        /// </summary>
+        internal static string NoNewUpdates {
+            get {
+                return ResourceManager.GetString("NoNewUpdates", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Open G-Helper window.
         /// </summary>
@@ -690,6 +926,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Keep GPU disabled on USB-C charger in Optimized mode.
+        /// </summary>
+        internal static string OptimizedUSBC {
+            get {
+                return ResourceManager.GetString("OptimizedUSBC", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Other.
         /// </summary>
@@ -709,7 +954,7 @@ namespace GHelper.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Performance Mode.
+        ///   Looks up a localized string similar to Mode.
         /// </summary>
         internal static string PerformanceMode {
             get {
@@ -736,7 +981,7 @@ namespace GHelper.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Power Limits (PPT).
+        ///   Looks up a localized string similar to Power Limits.
         /// </summary>
         internal static string PowerLimits {
             get {
@@ -745,7 +990,7 @@ namespace GHelper.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Power Limits (PPT) is experimental feature. Use carefully and on your own risk!.
+        ///   Looks up a localized string similar to Power Limits is experimental feature. Use carefully and on your own risk!.
         /// </summary>
         internal static string PPTExperimental {
             get {
@@ -771,6 +1016,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Something is using dGPU and preventing Eco mode. Restart dGPU in device manager? * Please proceed on your own risk..
+        /// </summary>
+        internal static string RestartGPU {
+            get {
+                return ResourceManager.GetString("RestartGPU", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to RPM.
         /// </summary>
@@ -834,6 +1088,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Start.
+        /// </summary>
+        internal static string Start {
+            get {
+                return ResourceManager.GetString("Start", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Starting Services.
+        /// </summary>
+        internal static string StartingServices {
+            get {
+                return ResourceManager.GetString("StartingServices", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Startup Error.
         /// </summary>
@@ -843,6 +1115,33 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Stop.
+        /// </summary>
+        internal static string Stop {
+            get {
+                return ResourceManager.GetString("Stop", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Stop GPU Applications.
+        /// </summary>
+        internal static string StopGPUApps {
+            get {
+                return ResourceManager.GetString("StopGPUApps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Stopping Services.
+        /// </summary>
+        internal static string StoppingServices {
+            get {
+                return ResourceManager.GetString("StoppingServices", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Toggle Aura.
         /// </summary>
@@ -852,6 +1151,33 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Toggle Fn-Lock.
+        /// </summary>
+        internal static string ToggleFnLock {
+            get {
+                return ResourceManager.GetString("ToggleFnLock", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Toggle Miniled (if supported).
+        /// </summary>
+        internal static string ToggleMiniled {
+            get {
+                return ResourceManager.GetString("ToggleMiniled", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Toggle Screen.
+        /// </summary>
+        internal static string ToggleScreen {
+            get {
+                return ResourceManager.GetString("ToggleScreen", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Turbo.
         /// </summary>
@@ -897,6 +1223,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Undervolting is experimental and risky feature. If applied values are too low for your hardware, it can become unstable, shut down or cause data corruption. If you want to try - start from small values first, click Apply and test what works for you..
+        /// </summary>
+        internal static string UndervoltingRisky {
+            get {
+                return ResourceManager.GetString("UndervoltingRisky", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Updates.
+        /// </summary>
+        internal static string Updates {
+            get {
+                return ResourceManager.GetString("Updates", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Version.
         /// </summary>
@@ -906,6 +1250,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Volume Down.
+        /// </summary>
+        internal static string VolumeDown {
+            get {
+                return ResourceManager.GetString("VolumeDown", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Volume Mute.
         /// </summary>
@@ -915,6 +1268,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Volume Up.
+        /// </summary>
+        internal static string VolumeUp {
+            get {
+                return ResourceManager.GetString("VolumeUp", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Keep app window always on top.
         /// </summary>

app/Properties/Strings.de.resx

@@ -1,5 +1,64 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -59,106 +118,115 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="ACPIError" xml:space="preserve">
-    <value>Can't connect to ASUS ACPI. Application can't function without it. Try to install Asus System Control Interface</value>
+    <value>Verbindung zu ASUS ACPI fehlgeschlagen. G-Helper kann nicht ausgeführt werden. Bitte installiere ASUS System Control Interface.</value>
   </data>
   <data name="AlertDGPU" xml:space="preserve">
-    <value>Looks like GPU is in heavy use, disable it?</value>
+    <value>Die GPU wird gerade verwendet. Trotzdem deaktivieren?</value>
   </data>
   <data name="AlertDGPUTitle" xml:space="preserve">
-    <value>Eco Mode</value>
+    <value>Eco Modus</value>
   </data>
   <data name="AlertUltimateOff" xml:space="preserve">
-    <value>Switching off Ultimate Mode requires restart</value>
+    <value>Wechseln in den Ultimate Modus benötigt einen Neustart. Jetzt neustarten?</value>
   </data>
   <data name="AlertUltimateOn" xml:space="preserve">
-    <value>Ultimate Mode requires restart</value>
+    <value>Ultimate Modus benötigt einen Neustart</value>
   </data>
   <data name="AlertUltimateTitle" xml:space="preserve">
-    <value>Reboot now?</value>
+    <value>Jetzt neustarten?</value>
   </data>
   <data name="AnimationSpeed" xml:space="preserve">
-    <value>Animation Speed</value>
+    <value>Animationsgeschwindigkeit</value>
   </data>
   <data name="AnimeMatrix" xml:space="preserve">
-    <value>Anime Matrix</value>
+    <value>AniMeMatrix</value>
   </data>
   <data name="AppAlreadyRunning" xml:space="preserve">
-    <value>App already running</value>
+    <value>Die Anwendung läuft bereits</value>
   </data>
   <data name="AppAlreadyRunningText" xml:space="preserve">
-    <value>G-Helper is already running. Check system tray for an icon.</value>
+    <value>G-Helper läuft bereits. Bitte prüfe den Systemtray.</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
-    <value>Apply Custom Fan Curve</value>
+    <value>Lüfterkurve anweden</value>
   </data>
   <data name="ApplyPowerLimits" xml:space="preserve">
-    <value>Apply Power Limits</value>
+    <value>Leistunsgrenzen anwenden</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Windows Leistungsmodus automatisch anpassen</value>
   </data>
   <data name="AuraBreathe" xml:space="preserve">
-    <value>Breathe</value>
+    <value>Atmen</value>
   </data>
   <data name="AuraColorCycle" xml:space="preserve">
-    <value>Color Cycle</value>
+    <value>Farbwechsel</value>
   </data>
   <data name="AuraFast" xml:space="preserve">
-    <value>Fast</value>
+    <value>Schnell</value>
   </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
-    <value>Rainbow</value>
+    <value>Regenbogen</value>
   </data>
   <data name="AuraSlow" xml:space="preserve">
-    <value>Slow</value>
+    <value>Langsam</value>
   </data>
   <data name="AuraStatic" xml:space="preserve">
-    <value>Static</value>
+    <value>Statisch</value>
   </data>
   <data name="AuraStrobe" xml:space="preserve">
-    <value>Strobe</value>
+    <value>Stroboskop</value>
   </data>
   <data name="AutoMode" xml:space="preserve">
     <value>Auto</value>
   </data>
   <data name="AutoRefreshTooltip" xml:space="preserve">
-    <value>Sets 60Hz to save battery, and back when plugged</value>
+    <value>60Hz im Batteriebetrieb Maximal wenn eingesteckt.</value>
   </data>
   <data name="Awake" xml:space="preserve">
-    <value>Awake</value>
+    <value>Im Betrieb</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Tastaturbelechtung abschalten in (Sekunden)</value>
   </data>
   <data name="Balanced" xml:space="preserve">
-    <value>Balanced</value>
+    <value>Ausbalanciert</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
-    <value>Battery Charge Limit</value>
+    <value>Ladebegrenzung</value>
   </data>
   <data name="Boot" xml:space="preserve">
-    <value>Boot</value>
+    <value>Hochfahren</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Helligkeit</value>
   </data>
   <data name="Color" xml:space="preserve">
-    <value>Color</value>
+    <value>Farbe</value>
   </data>
   <data name="CPUBoost" xml:space="preserve">
     <value>CPU Boost</value>
   </data>
   <data name="Custom" xml:space="preserve">
-    <value>Custom</value>
+    <value>Benutzerdefiniert</value>
   </data>
   <data name="Default" xml:space="preserve">
-    <value>Default</value>
+    <value>Standard</value>
   </data>
   <data name="DisableOverdrive" xml:space="preserve">
-    <value>Disable screen overdrive</value>
+    <value>Overdrive abschalten</value>
   </data>
   <data name="Discharging" xml:space="preserve">
-    <value>Discharging</value>
+    <value>Entlädt</value>
   </data>
   <data name="DownloadUpdate" xml:space="preserve">
-    <value>Download Update</value>
+    <value>Updates herunterladen</value>
   </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
-    <value>Disables dGPU for battery savings</value>
+    <value>dGPU zum Stromsparen abschalten</value>
   </data>
   <data name="EcoMode" xml:space="preserve">
     <value>Eco</value>
@@ -167,172 +235,193 @@
     <value>Extra</value>
   </data>
   <data name="ExtraSettings" xml:space="preserve">
-    <value>Extra Settings</value>
+    <value>Extra-Einstellungen</value>
   </data>
   <data name="FactoryDefaults" xml:space="preserve">
-    <value>Factory Defaults</value>
+    <value>Werkseinstellungen</value>
   </data>
   <data name="FanCurves" xml:space="preserve">
-    <value>Fan Curves</value>
+    <value>Lüfterkurven</value>
   </data>
   <data name="FanProfileCPU" xml:space="preserve">
-    <value>CPU Fan Profile</value>
+    <value>CPU Lüfterprofil</value>
   </data>
   <data name="FanProfileGPU" xml:space="preserve">
-    <value>GPU Fan Profile</value>
+    <value>GPU Lüfterprofil</value>
   </data>
   <data name="FanProfileMid" xml:space="preserve">
-    <value>Mid Fan Profile</value>
+    <value>Mittleres Lüfterprofil</value>
   </data>
   <data name="FanProfiles" xml:space="preserve">
-    <value>Fan Profiles</value>
+    <value>Lüfterprofile</value>
   </data>
   <data name="FansAndPower" xml:space="preserve">
-    <value>Fans and Power</value>
+    <value>Lüfter und Leistung</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value> Lüfter: </value>
   </data>
   <data name="FansPower" xml:space="preserve">
-    <value>Fans + Power</value>
+    <value>Lüfter + Leistung</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
   </data>
   <data name="GPUChanging" xml:space="preserve">
-    <value>Changing</value>
+    <value>Wechseln</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Kernfrequenz Anpassung</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Speicherfrequenz Anpassung</value>
   </data>
   <data name="GPUMode" xml:space="preserve">
-    <value>GPU Mode</value>
+    <value>GPU Modus</value>
   </data>
   <data name="GPUModeEco" xml:space="preserve">
-    <value>iGPU only</value>
+    <value>Nur iGPU</value>
   </data>
   <data name="GPUModeStandard" xml:space="preserve">
     <value>iGPU + dGPU</value>
   </data>
   <data name="GPUModeUltimate" xml:space="preserve">
-    <value>dGPU exclusive</value>
+    <value>Nur dGPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Maximale GPU Temperatur</value>
   </data>
   <data name="KeyBindings" xml:space="preserve">
-    <value>Key Bindings</value>
+    <value>Tastenbelegung</value>
   </data>
   <data name="Keyboard" xml:space="preserve">
-    <value>Keyboard</value>
+    <value>Tastatur</value>
   </data>
   <data name="KeyboardAuto" xml:space="preserve">
-    <value>Lower backlight brightness on battery and back when plugged</value>
+    <value>Tastaturbeleuchtung im Batteriebetrieb abdunkeln.</value>
   </data>
   <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Keyboard Backlight</value>
+    <value>Tastaturbeleuchtung</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Laptopbelechtung</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
-    <value>Laptop Keyboard</value>
+    <value>Laptoptastatur</value>
   </data>
   <data name="LaptopScreen" xml:space="preserve">
-    <value>Laptop Screen</value>
+    <value>Laptopbildschirm</value>
   </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>Binary Banner</value>
   </data>
   <data name="MatrixBright" xml:space="preserve">
-    <value>Bright</value>
+    <value>Hell</value>
   </data>
   <data name="MatrixClock" xml:space="preserve">
-    <value>Clock</value>
+    <value>Uhr</value>
   </data>
   <data name="MatrixDim" xml:space="preserve">
-    <value>Dim</value>
+    <value>Dunkel</value>
   </data>
   <data name="MatrixLogo" xml:space="preserve">
-    <value>Rog Logo</value>
+    <value>ROG Logo</value>
   </data>
   <data name="MatrixMedium" xml:space="preserve">
-    <value>Medium</value>
+    <value>Mittel</value>
   </data>
   <data name="MatrixOff" xml:space="preserve">
-    <value>Off</value>
+    <value>Aus</value>
   </data>
   <data name="MatrixPicture" xml:space="preserve">
-    <value>Picture</value>
+    <value>Bild</value>
   </data>
   <data name="MaxRefreshTooltip" xml:space="preserve">
-    <value>Max refresh rate for lower latency</value>
+    <value>Maximale Wiederholrate für niedrigste Latenz</value>
   </data>
   <data name="MinRefreshTooltip" xml:space="preserve">
-    <value>60Hz refresh rate to save battery</value>
+    <value>60Hz um Strom zu sparen</value>
   </data>
   <data name="Multizone" xml:space="preserve">
-    <value>Multizone</value>
+    <value>Multi-Zone</value>
   </data>
   <data name="OpenGHelper" xml:space="preserve">
-    <value>Open G-Helper window</value>
+    <value>G-Helper Fenster öffnen</value>
   </data>
   <data name="Optimized" xml:space="preserve">
-    <value>Optimized</value>
+    <value>Optimiert</value>
   </data>
   <data name="OptimizedGPUTooltip" xml:space="preserve">
-    <value>Switch to Eco on battery and to Standard when plugged</value>
+    <value>Eco Modus im Batteriebetrieb, Standard wenn eingesteckt.</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>GPU beim USB-C Laden im Optimierten Modus deaktiviert lassen</value>
   </data>
   <data name="Other" xml:space="preserve">
-    <value>Other</value>
+    <value>Sonstiges</value>
   </data>
   <data name="Overdrive" xml:space="preserve">
     <value>Overdrive</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Performance Mode</value>
+    <value>Leistungsmodus</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
-    <value>Picture / Gif</value>
+    <value>Bild / GIF</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
-    <value>Play / Pause</value>
+    <value>Wiedergabe / Pause</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Power Limits (PPT)</value>
+    <value>Leistungsbegrenzung</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Power Limits (PPT) is experimental feature. Use carefully and on your own risk!</value>
+    <value>Leistungsbegrenzung ist experimentell. Nutzung erfolgt auf eigene Gefahr!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
-    <value>PrintScreen</value>
+    <value>Druck</value>
   </data>
   <data name="Quit" xml:space="preserve">
-    <value>Quit</value>
+    <value>Schließen</value>
   </data>
   <data name="RPM" xml:space="preserve">
-    <value>RPM</value>
+    <value>U/Min</value>
   </data>
   <data name="RunOnStartup" xml:space="preserve">
-    <value>Run on Startup</value>
+    <value>Beim Start ausführen</value>
   </data>
   <data name="Shutdown" xml:space="preserve">
-    <value>Shutdown</value>
+    <value>Herunterfahren</value>
   </data>
   <data name="Silent" xml:space="preserve">
-    <value>Silent</value>
+    <value>Leise</value>
   </data>
   <data name="Sleep" xml:space="preserve">
-    <value>Sleep</value>
+    <value>Standby</value>
   </data>
   <data name="StandardGPUTooltip" xml:space="preserve">
-    <value>Enables dGPU for standard use</value>
+    <value>dGPU aktivieren</value>
   </data>
   <data name="StandardMode" xml:space="preserve">
     <value>Standard</value>
   </data>
   <data name="StartupError" xml:space="preserve">
-    <value>Startup Error</value>
+    <value>Startfehler</value>
   </data>
   <data name="ToggleAura" xml:space="preserve">
-    <value>Toggle Aura</value>
+    <value>Aura umschalten</value>
   </data>
   <data name="Turbo" xml:space="preserve">
     <value>Turbo</value>
   </data>
   <data name="TurnedOff" xml:space="preserve">
-    <value>Turned off</value>
+    <value>Ausgeschaltet</value>
   </data>
   <data name="TurnOffOnBattery" xml:space="preserve">
-    <value>Turn off on battery</value>
+    <value>Im Batteriebetrieb abschalten</value>
   </data>
   <data name="UltimateGPUTooltip" xml:space="preserve">
-    <value>Routes laptop screen to dGPU, maximizing FPS</value>
+    <value>Verbindet den Bildschirm mit der dGPU für maximale Leistung.</value>
   </data>
   <data name="UltimateMode" xml:space="preserve">
     <value>Ultimate</value>
@@ -341,9 +430,9 @@
     <value>Version</value>
   </data>
   <data name="VolumeMute" xml:space="preserve">
-    <value>Volume Mute</value>
+    <value>Stummschalten</value>
   </data>
   <data name="WindowTop" xml:space="preserve">
-    <value>Keep app window always on top</value>
+    <value>Fenster immer über allen anderen</value>
   </data>
 </root>

app/Properties/Strings.es.resx

@@ -136,7 +136,7 @@
     <value>¿Reiniciar ahora?</value>
   </data>
   <data name="AnimationSpeed" xml:space="preserve">
-    <value>Velocidad de animación</value>
+    <value>Velocidad</value>
   </data>
   <data name="AnimeMatrix" xml:space="preserve">
     <value>Anime Matrix</value>
@@ -153,6 +153,12 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Aplicar límites de energía</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Auto-ajustar plan de energía Windows</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>Servicios de Asus en ejecución</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Respiración</value>
   </data>
@@ -186,15 +192,33 @@
   <data name="Awake" xml:space="preserve">
     <value>Encendida</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Apagar con batería tras (0 - nunca)</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Apagar cuando está enchufado tras (0 - nunca)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>Equilibrado</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Límite de carga</value>
   </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>Actualizaciones de BIOS y Drivers</value>
+  </data>
   <data name="Boot" xml:space="preserve">
     <value>Al arrancar</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Brillo</value>
+  </data>
+  <data name="BrightnessDown" xml:space="preserve">
+    <value>Bajar brillo</value>
+  </data>
+  <data name="BrightnessUp" xml:space="preserve">
+    <value>Subir brillo</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Color</value>
   </data>
@@ -216,12 +240,23 @@
   <data name="DownloadUpdate" xml:space="preserve">
     <value>Descargar actualización</value>
   </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>Drivers y Software</value>
+  </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
     <value>Deshabilita la dGPU para ahorrar batería</value>
   </data>
   <data name="EcoMode" xml:space="preserve">
     <value>Eco</value>
   </data>
+  <data name="EnableOptimusText" xml:space="preserve">
+    <value>Deshabilitar la dGPU cambiando a modo Eco moentras el Modo de Pantalla en el Panel de Control de NVIDIA no está configurado en Optimus puede causar problemas con el control del brillo hasta después del próximo reinicio.
+
+¿Seguro que desea continuar?</value>
+  </data>
+  <data name="EnableOptimusTitle" xml:space="preserve">
+    <value>Modo de Pantalla NVIDIA no está configurado en Optimus</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Adicional</value>
   </data>
@@ -249,12 +284,27 @@
   <data name="FansAndPower" xml:space="preserve">
     <value>Ventiladores y energía</value>
   </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value> Fan: </value>
+  </data>
   <data name="FansPower" xml:space="preserve">
     <value>Ventiladores + Energía</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Usar teclas de acceso rápido (Fn+F) sin pulsar Fn</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>Cargando</value>
   </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Core Clock Offset</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Memory Clock Offset</value>
+  </data>
   <data name="GPUMode" xml:space="preserve">
     <value>Modo de GPU</value>
   </data>
@@ -267,6 +317,12 @@
   <data name="GPUModeUltimate" xml:space="preserve">
     <value>Exclusivo dGPU</value>
   </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>Ajustes de GPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Temperatura objetivo</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Atajos de teclado</value>
   </data>
@@ -276,8 +332,11 @@
   <data name="KeyboardAuto" xml:space="preserve">
     <value>Bajar retroiluminación con batería</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Retroiluminación del teclado</value>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Detener todas las aplicaciones que usan la dGPU cuando se cambia a Eco</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Retroiluminación</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>Teclado del portátil</value>
@@ -285,6 +344,18 @@
   <data name="LaptopScreen" xml:space="preserve">
     <value>Pantalla del portátil</value>
   </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Tapa</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Barra de luz</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Visualizador de audio</value>
+  </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>Banner binario</value>
   </data>
@@ -318,6 +389,15 @@
   <data name="Multizone" xml:space="preserve">
     <value>Multizona</value>
   </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Silenciar micrófono</value>
+  </data>
+  <data name="NewUpdates" xml:space="preserve">
+    <value>Nuevas actualizaciones</value>
+  </data>
+  <data name="NoNewUpdates" xml:space="preserve">
+    <value>No hay nuevas actualizaciones</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Abrir ventana G-Helper</value>
   </data>
@@ -327,6 +407,9 @@
   <data name="OptimizedGPUTooltip" xml:space="preserve">
     <value>Cambia a Eco con batería y a Estándar cuando está enchufado</value>
   </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Deshabilitar dGPU con cargador USB-C en modo Optimizado</value>
+  </data>
   <data name="Other" xml:space="preserve">
     <value>Otro</value>
   </data>
@@ -334,7 +417,7 @@
     <value>Overdrive</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Modo de rendimiento</value>
+    <value>Modo</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Imagen / Gif</value>
@@ -343,10 +426,10 @@
     <value>Reproducir / Pausar</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Límites de energía (PPT)</value>
+    <value>Límites de energía</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Los límites de energía (PPT) son una característica experimental. ¡Úselo con cuidado y bajo su propio riesgo!</value>
+    <value>Los límites de energía son una característica experimental. ¡Úselo con cuidado y bajo su propio riesgo!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>Capturar pantalla</value>
@@ -354,6 +437,9 @@
   <data name="Quit" xml:space="preserve">
     <value>Quitar</value>
   </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Algo está usando la dGPU e impide usar Modo Eco. ¿Reiniciar dGPU en administrador de dispositivos? * Proceda bajo su propio riesgo.</value>
+  </data>
   <data name="RPM" xml:space="preserve">
     <value>RPM</value>
   </data>
@@ -375,12 +461,36 @@
   <data name="StandardMode" xml:space="preserve">
     <value>Estándar</value>
   </data>
+  <data name="Start" xml:space="preserve">
+    <value>Iniciar</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>Iniciando servicios</value>
+  </data>
   <data name="StartupError" xml:space="preserve">
     <value>Error de inicio</value>
   </data>
+  <data name="Stop" xml:space="preserve">
+    <value>Detener</value>
+  </data>
+  <data name="StopGPUApps" xml:space="preserve">
+    <value>Detener aplicaciones dGPU</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>Deteniendo servicios</value>
+  </data>
   <data name="ToggleAura" xml:space="preserve">
     <value>Alternar Aura</value>
   </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>Alternar Fn-Lock</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Alternar Miniled (si comp.)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Alternar pantalla</value>
+  </data>
   <data name="Turbo" xml:space="preserve">
     <value>Turbo</value>
   </data>
@@ -396,12 +506,24 @@
   <data name="UltimateMode" xml:space="preserve">
     <value>Ultimate</value>
   </data>
+  <data name="UndervoltingRisky" xml:space="preserve">
+    <value>Undervolting es una característica experimental. Aplicar valores demasiado bajos puede causar inestabilidad en el hardware o corrupción de datos. Si desea probar, empiece con valores pequeños, haga click en Aplicar y pruebe.</value>
+  </data>
+  <data name="Updates" xml:space="preserve">
+    <value>Actualización</value>
+  </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>Versión</value>
   </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Bajar volumen</value>
+  </data>
   <data name="VolumeMute" xml:space="preserve">
     <value>Silenciar volumen</value>
   </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Subir volumen</value>
+  </data>
   <data name="WindowTop" xml:space="preserve">
     <value>Mantener aplicación siempre visible</value>
   </data>

app/Properties/Strings.fr.resx

@@ -1,5 +1,64 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -59,291 +118,351 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="ACPIError" xml:space="preserve">
-    <value>Can't connect to ASUS ACPI. Application can't function without it. Try to install Asus System Control Interface</value>
+    <value>Connexion impossible avec ASUS ACPI. L'application ne peut fonctionner sans. Veuillez installer Asus System Control Interface.</value>
   </data>
   <data name="AlertDGPU" xml:space="preserve">
-    <value>Looks like GPU is in heavy use, disable it?</value>
+    <value>Le GPU semble être surchargé, voulez vous le désactiver ?</value>
   </data>
   <data name="AlertDGPUTitle" xml:space="preserve">
-    <value>Eco Mode</value>
+    <value>Mode Éco</value>
   </data>
   <data name="AlertUltimateOff" xml:space="preserve">
-    <value>Switching off Ultimate Mode requires restart</value>
+    <value>Désactiver le Mode Ultime requiert un redémarrage</value>
   </data>
   <data name="AlertUltimateOn" xml:space="preserve">
-    <value>Ultimate Mode requires restart</value>
+    <value>Activer le Mode Ultime requiert un redémarrage</value>
   </data>
   <data name="AlertUltimateTitle" xml:space="preserve">
-    <value>Reboot now?</value>
+    <value>Redémarrer maintenant ?</value>
   </data>
   <data name="AnimationSpeed" xml:space="preserve">
-    <value>Animation Speed</value>
+    <value>Vitesse de l'animation</value>
   </data>
   <data name="AnimeMatrix" xml:space="preserve">
     <value>Anime Matrix</value>
   </data>
   <data name="AppAlreadyRunning" xml:space="preserve">
-    <value>App already running</value>
+    <value>L'application est déjà en cours d'exécution</value>
   </data>
   <data name="AppAlreadyRunningText" xml:space="preserve">
-    <value>G-Helper is already running. Check system tray for an icon.</value>
+    <value>G-Helper est déjà en cours d'exécution. Vérifiez la barre d'état système.</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
-    <value>Apply Custom Fan Curve</value>
+    <value>Appliquer la courbe</value>
   </data>
   <data name="ApplyPowerLimits" xml:space="preserve">
-    <value>Apply Power Limits</value>
+    <value>Appliquer les limites</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Ajustement auto des modes de gestion alim. Windows</value>
   </data>
   <data name="AuraBreathe" xml:space="preserve">
-    <value>Breathe</value>
+    <value>Pulsation</value>
   </data>
   <data name="AuraColorCycle" xml:space="preserve">
-    <value>Color Cycle</value>
+    <value>Cycle de couleur</value>
   </data>
   <data name="AuraFast" xml:space="preserve">
-    <value>Fast</value>
+    <value>Rapide</value>
   </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
-    <value>Rainbow</value>
+    <value>Arc-en-ciel</value>
   </data>
   <data name="AuraSlow" xml:space="preserve">
-    <value>Slow</value>
+    <value>Lent</value>
   </data>
   <data name="AuraStatic" xml:space="preserve">
-    <value>Static</value>
+    <value>Statique</value>
   </data>
   <data name="AuraStrobe" xml:space="preserve">
-    <value>Strobe</value>
+    <value>Stroboscopique</value>
   </data>
   <data name="AutoMode" xml:space="preserve">
-    <value>Auto</value>
+    <value>Automatique</value>
   </data>
   <data name="AutoRefreshTooltip" xml:space="preserve">
-    <value>Sets 60Hz to save battery, and back when plugged</value>
+    <value>Limite à 60 Hz pour éco. batterie, valeur normale sur secteur</value>
   </data>
   <data name="Awake" xml:space="preserve">
-    <value>Awake</value>
+    <value>Allumé</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Délai (secondes) avant extinction rétroéclairage</value>
   </data>
   <data name="Balanced" xml:space="preserve">
-    <value>Balanced</value>
+    <value>Équilibré</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
-    <value>Battery Charge Limit</value>
+    <value>Limite de charge </value>
   </data>
   <data name="Boot" xml:space="preserve">
-    <value>Boot</value>
+    <value>Au démarrage</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Luminosité</value>
   </data>
   <data name="Color" xml:space="preserve">
-    <value>Color</value>
+    <value>Couleur</value>
   </data>
   <data name="CPUBoost" xml:space="preserve">
     <value>CPU Boost</value>
   </data>
   <data name="Custom" xml:space="preserve">
-    <value>Custom</value>
+    <value>Personnalisé</value>
   </data>
   <data name="Default" xml:space="preserve">
-    <value>Default</value>
+    <value>Par défaut</value>
   </data>
   <data name="DisableOverdrive" xml:space="preserve">
-    <value>Disable screen overdrive</value>
+    <value>Désactiver l'overdrive de l'écran</value>
   </data>
   <data name="Discharging" xml:space="preserve">
-    <value>Discharging</value>
+    <value>Taux décharge </value>
   </data>
   <data name="DownloadUpdate" xml:space="preserve">
-    <value>Download Update</value>
+    <value>Télécharger la mise à jour</value>
   </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
-    <value>Disables dGPU for battery savings</value>
+    <value>Désactive le dGPU pour préserver la batterie</value>
   </data>
   <data name="EcoMode" xml:space="preserve">
-    <value>Eco</value>
+    <value>Éco</value>
   </data>
   <data name="Extra" xml:space="preserve">
-    <value>Extra</value>
+    <value>+ d'options</value>
   </data>
   <data name="ExtraSettings" xml:space="preserve">
-    <value>Extra Settings</value>
+    <value>Paramètres supplémentaires</value>
   </data>
   <data name="FactoryDefaults" xml:space="preserve">
-    <value>Factory Defaults</value>
+    <value>Paramètres d'usine</value>
   </data>
   <data name="FanCurves" xml:space="preserve">
-    <value>Fan Curves</value>
+    <value>Courbes des ventilateurs</value>
   </data>
   <data name="FanProfileCPU" xml:space="preserve">
-    <value>CPU Fan Profile</value>
+    <value>Profil du ventilateur CPU</value>
   </data>
   <data name="FanProfileGPU" xml:space="preserve">
-    <value>GPU Fan Profile</value>
+    <value>Profil du ventilateur GPU</value>
   </data>
   <data name="FanProfileMid" xml:space="preserve">
-    <value>Mid Fan Profile</value>
+    <value>Profil du ventilateur central</value>
   </data>
   <data name="FanProfiles" xml:space="preserve">
-    <value>Fan Profiles</value>
+    <value>Profil</value>
   </data>
   <data name="FansAndPower" xml:space="preserve">
-    <value>Fans and Power</value>
+    <value>Ventilateurs + Puissance</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Vent: </value>
   </data>
   <data name="FansPower" xml:space="preserve">
-    <value>Fans + Power</value>
+    <value>Ventilateurs + Puissance</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
   </data>
   <data name="GPUChanging" xml:space="preserve">
-    <value>Changing</value>
+    <value>Changement</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Ajustement fréq. de base</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Ajustement fréq. mémoire</value>
   </data>
   <data name="GPUMode" xml:space="preserve">
-    <value>GPU Mode</value>
+    <value>Mode GPU </value>
   </data>
   <data name="GPUModeEco" xml:space="preserve">
-    <value>iGPU only</value>
+    <value>iGPU uniquement</value>
   </data>
   <data name="GPUModeStandard" xml:space="preserve">
     <value>iGPU + dGPU</value>
   </data>
   <data name="GPUModeUltimate" xml:space="preserve">
-    <value>dGPU exclusive</value>
+    <value>dGPU exclusif</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>Paramètres du GPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Température cible</value>
   </data>
   <data name="KeyBindings" xml:space="preserve">
-    <value>Key Bindings</value>
+    <value>Raccourcis clavier</value>
   </data>
   <data name="Keyboard" xml:space="preserve">
-    <value>Keyboard</value>
+    <value>Clavier</value>
   </data>
   <data name="KeyboardAuto" xml:space="preserve">
-    <value>Lower backlight brightness on battery and back when plugged</value>
+    <value>Réduire rétroéclairage sur batterie et mode normal sur secteur</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Keyboard Backlight</value>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Rétroéclairage de l'ordinateur</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
-    <value>Laptop Keyboard</value>
+    <value>Clavier de l'ordinateur</value>
   </data>
   <data name="LaptopScreen" xml:space="preserve">
-    <value>Laptop Screen</value>
+    <value>Écran de l'ordinateur </value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Capot</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Barre lumineuse</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Visualiseur Audio</value>
   </data>
   <data name="MatrixBanner" xml:space="preserve">
-    <value>Binary Banner</value>
+    <value>Bannière binaire</value>
   </data>
   <data name="MatrixBright" xml:space="preserve">
-    <value>Bright</value>
+    <value>Lumineux</value>
   </data>
   <data name="MatrixClock" xml:space="preserve">
-    <value>Clock</value>
+    <value>Horloge</value>
   </data>
   <data name="MatrixDim" xml:space="preserve">
-    <value>Dim</value>
+    <value>Faible</value>
   </data>
   <data name="MatrixLogo" xml:space="preserve">
-    <value>Rog Logo</value>
+    <value>Logo ROG</value>
   </data>
   <data name="MatrixMedium" xml:space="preserve">
-    <value>Medium</value>
+    <value>Moyen</value>
   </data>
   <data name="MatrixOff" xml:space="preserve">
-    <value>Off</value>
+    <value>Éteint</value>
   </data>
   <data name="MatrixPicture" xml:space="preserve">
-    <value>Picture</value>
+    <value>Images</value>
   </data>
   <data name="MaxRefreshTooltip" xml:space="preserve">
-    <value>Max refresh rate for lower latency</value>
+    <value>Rafraîchissement maximum, faible latence</value>
   </data>
   <data name="MinRefreshTooltip" xml:space="preserve">
-    <value>60Hz refresh rate to save battery</value>
+    <value>Rafraichîssement 60 Hz pour économiser de la batterie</value>
   </data>
   <data name="Multizone" xml:space="preserve">
-    <value>Multizone</value>
+    <value>Multi-zone</value>
+  </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Désactiver le micro</value>
   </data>
   <data name="OpenGHelper" xml:space="preserve">
-    <value>Open G-Helper window</value>
+    <value>Ouvrir G-Helper</value>
   </data>
   <data name="Optimized" xml:space="preserve">
-    <value>Optimized</value>
+    <value>Optimisé</value>
   </data>
   <data name="OptimizedGPUTooltip" xml:space="preserve">
-    <value>Switch to Eco on battery and to Standard when plugged</value>
+    <value>Éco sur batterie, bascule vers Standard sur secteur</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Garder le GPU désactivé lorsque branché via USB-C en mode Optimisé</value>
   </data>
   <data name="Other" xml:space="preserve">
-    <value>Other</value>
+    <value>Autre</value>
   </data>
   <data name="Overdrive" xml:space="preserve">
     <value>Overdrive</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Performance Mode</value>
+    <value>Mode Performance</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
-    <value>Picture / Gif</value>
+    <value>Image / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
-    <value>Play / Pause</value>
+    <value>Lecture / Pause</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Power Limits (PPT)</value>
+    <value>Limites de puissance</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Power Limits (PPT) is experimental feature. Use carefully and on your own risk!</value>
+    <value>Limites de puissance est une fonctionnalité expérimentale. Faire attention, à utiliser à vos risques !</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
-    <value>PrintScreen</value>
+    <value>Capture d'écran</value>
   </data>
   <data name="Quit" xml:space="preserve">
-    <value>Quit</value>
+    <value>Quitter</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Un processus utilisant le dGPU empêche le passage en mode Éco. Redémarrer le dGPU ? * Procédez à vos risques.</value>
   </data>
   <data name="RPM" xml:space="preserve">
-    <value>RPM</value>
+    <value> RPM</value>
   </data>
   <data name="RunOnStartup" xml:space="preserve">
-    <value>Run on Startup</value>
+    <value>Exécuter au démarrage</value>
   </data>
   <data name="Shutdown" xml:space="preserve">
-    <value>Shutdown</value>
+    <value>Arrêter</value>
   </data>
   <data name="Silent" xml:space="preserve">
-    <value>Silent</value>
+    <value>Silencieux</value>
   </data>
   <data name="Sleep" xml:space="preserve">
-    <value>Sleep</value>
+    <value>Veille</value>
   </data>
   <data name="StandardGPUTooltip" xml:space="preserve">
-    <value>Enables dGPU for standard use</value>
+    <value>Active le dGPU pour une utilisation standard</value>
   </data>
   <data name="StandardMode" xml:space="preserve">
     <value>Standard</value>
   </data>
   <data name="StartupError" xml:space="preserve">
-    <value>Startup Error</value>
+    <value>Erreur au lancement</value>
   </data>
   <data name="ToggleAura" xml:space="preserve">
-    <value>Toggle Aura</value>
+    <value>Activer Aura</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Activer Miniled (si supporté)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Allumer l'écran</value>
   </data>
   <data name="Turbo" xml:space="preserve">
     <value>Turbo</value>
   </data>
   <data name="TurnedOff" xml:space="preserve">
-    <value>Turned off</value>
+    <value>Éteint</value>
   </data>
   <data name="TurnOffOnBattery" xml:space="preserve">
-    <value>Turn off on battery</value>
+    <value>Éteindre sur batterie</value>
   </data>
   <data name="UltimateGPUTooltip" xml:space="preserve">
-    <value>Routes laptop screen to dGPU, maximizing FPS</value>
+    <value>Redirige l'écran du portable vers le dGPU, maximisation taux FPS </value>
   </data>
   <data name="UltimateMode" xml:space="preserve">
-    <value>Ultimate</value>
+    <value>Ultime</value>
   </data>
   <data name="VersionLabel" xml:space="preserve">
-    <value>Version</value>
+    <value>Version </value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Vol-</value>
   </data>
   <data name="VolumeMute" xml:space="preserve">
-    <value>Volume Mute</value>
+    <value>Mettre en sourdine</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Vol+</value>
   </data>
   <data name="WindowTop" xml:space="preserve">
-    <value>Keep app window always on top</value>
+    <value>Maintenir la fenêtre au premier plan</value>
   </data>
 </root>

app/Properties/Strings.it.resx

@@ -1,5 +1,64 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -94,6 +153,9 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Apply Power Limits</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Auto Adjust Windows Power Mode</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Breathe</value>
   </data>
@@ -284,10 +346,10 @@
     <value>Play / Pause</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Power Limits (PPT)</value>
+    <value>Power Limits</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Power Limits (PPT) is experimental feature. Use carefully and on your own risk!</value>
+    <value>Power Limits is experimental feature. Use carefully and on your own risk!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>

app/Properties/Strings.ko.resx

@@ -0,0 +1,510 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ACPIError" xml:space="preserve">
+    <value>ASUS ACPI에 연결할 수 없어 응용 프로그램이 작동하지 않습니다. Asus System Control Interface를 먼저 설치하십시오.</value>
+  </data>
+  <data name="AlertDGPU" xml:space="preserve">
+    <value>GPU 사용량이 높습니다. 비활성화 하시겠습니까?</value>
+  </data>
+  <data name="AlertDGPUTitle" xml:space="preserve">
+    <value>Eco 모드</value>
+  </data>
+  <data name="AlertUltimateOff" xml:space="preserve">
+    <value>Ultimate 모드를 끄기 위해서는 다시 시작해야 합니다.</value>
+  </data>
+  <data name="AlertUltimateOn" xml:space="preserve">
+    <value>Ultimate 모드를 켜기 위해서는 다시 시작해야 합니다.</value>
+  </data>
+  <data name="AlertUltimateTitle" xml:space="preserve">
+    <value>다시 시작하시겠습니까?</value>
+  </data>
+  <data name="AnimationSpeed" xml:space="preserve">
+    <value>애니메이션 속도</value>
+  </data>
+  <data name="AnimeMatrix" xml:space="preserve">
+    <value>Anime Matrix</value>
+  </data>
+  <data name="AppAlreadyRunning" xml:space="preserve">
+    <value>프로그램이 이미 실행중입니다.</value>
+  </data>
+  <data name="AppAlreadyRunningText" xml:space="preserve">
+    <value>G-Helper가 이미 실행중입니다. 시스템 트레이에서 아이콘을 확인하십시오.</value>
+  </data>
+  <data name="ApplyFanCurve" xml:space="preserve">
+    <value>사용자 설정 팬 커브 적용</value>
+  </data>
+  <data name="ApplyPowerLimits" xml:space="preserve">
+    <value>전력 제한 적용</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>윈도우 전원 모드 자동조절</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>실행중인 Asus 서비스</value>
+  </data>
+  <data name="AuraBreathe" xml:space="preserve">
+    <value>Breathe</value>
+  </data>
+  <data name="AuraColorCycle" xml:space="preserve">
+    <value>Color Cycle</value>
+  </data>
+  <data name="AuraFast" xml:space="preserve">
+    <value>빠르게</value>
+  </data>
+  <data name="AuraNormal" xml:space="preserve">
+    <value>보통</value>
+  </data>
+  <data name="AuraRainbow" xml:space="preserve">
+    <value>Rainbow</value>
+  </data>
+  <data name="AuraSlow" xml:space="preserve">
+    <value>느리게</value>
+  </data>
+  <data name="AuraStatic" xml:space="preserve">
+    <value>Static</value>
+  </data>
+  <data name="AuraStrobe" xml:space="preserve">
+    <value>Strobe</value>
+  </data>
+  <data name="AutoMode" xml:space="preserve">
+    <value>자동</value>
+  </data>
+  <data name="AutoRefreshTooltip" xml:space="preserve">
+    <value>배터리 사용 중에만 60Hz 설정</value>
+  </data>
+  <data name="Awake" xml:space="preserve">
+    <value>Awake</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>배터리 사용 중 백라이트 자동 꺼짐</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>전원 연결 시 백라이트 자동 꺼짐 (0 - 항상 켜짐)</value>
+  </data>
+  <data name="Balanced" xml:space="preserve">
+    <value>균형</value>
+  </data>
+  <data name="BatteryChargeLimit" xml:space="preserve">
+    <value>배터리 충전 제한</value>
+  </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>바이오스/드라이버 업데이트</value>
+  </data>
+  <data name="Boot" xml:space="preserve">
+    <value>Boot</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>밝기</value>
+  </data>
+  <data name="BrightnessDown" xml:space="preserve">
+    <value>밝기 감소</value>
+  </data>
+  <data name="BrightnessUp" xml:space="preserve">
+    <value>밝기 증가</value>
+  </data>
+  <data name="Color" xml:space="preserve">
+    <value>색상</value>
+  </data>
+  <data name="CPUBoost" xml:space="preserve">
+    <value>CPU 부스트</value>
+  </data>
+  <data name="Custom" xml:space="preserve">
+    <value>사용자 설정</value>
+  </data>
+  <data name="Default" xml:space="preserve">
+    <value>기본</value>
+  </data>
+  <data name="DisableOverdrive" xml:space="preserve">
+    <value>화면 OD 끄기</value>
+  </data>
+  <data name="Discharging" xml:space="preserve">
+    <value>방전 중</value>
+  </data>
+  <data name="DownloadUpdate" xml:space="preserve">
+    <value>업데이트 다운로드</value>
+  </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>드라이버와 소프트웨어</value>
+  </data>
+  <data name="EcoGPUTooltip" xml:space="preserve">
+    <value>배터리 절약을 위해 dGPU 비활성화</value>
+  </data>
+  <data name="EcoMode" xml:space="preserve">
+    <value>Eco</value>
+  </data>
+  <data name="Extra" xml:space="preserve">
+    <value>추가 설정</value>
+  </data>
+  <data name="ExtraSettings" xml:space="preserve">
+    <value>추가 설정</value>
+  </data>
+  <data name="FactoryDefaults" xml:space="preserve">
+    <value>공장 설정</value>
+  </data>
+  <data name="FanCurves" xml:space="preserve">
+    <value>팬 커브</value>
+  </data>
+  <data name="FanProfileCPU" xml:space="preserve">
+    <value>CPU 팬 프로필</value>
+  </data>
+  <data name="FanProfileGPU" xml:space="preserve">
+    <value>GPU 팬 프로필</value>
+  </data>
+  <data name="FanProfileMid" xml:space="preserve">
+    <value>중간 팬 프로필</value>
+  </data>
+  <data name="FanProfiles" xml:space="preserve">
+    <value>팬 프로필</value>
+  </data>
+  <data name="FansAndPower" xml:space="preserve">
+    <value>팬 속도/전력</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>팬: </value>
+  </data>
+  <data name="FansPower" xml:space="preserve">
+    <value>팬 + 전력</value>
+  </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Fn 키를 누르지 않고 Fn+F 핫키 작동</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>다이나믹 부스트</value>
+  </data>
+  <data name="GPUChanging" xml:space="preserve">
+    <value>충전 중</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>코어 클럭 오프셋</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>메모리 클럭 오프셋</value>
+  </data>
+  <data name="GPUMode" xml:space="preserve">
+    <value>GPU 모드</value>
+  </data>
+  <data name="GPUModeEco" xml:space="preserve">
+    <value>iGPU만 사용</value>
+  </data>
+  <data name="GPUModeStandard" xml:space="preserve">
+    <value>iGPU + dGPU</value>
+  </data>
+  <data name="GPUModeUltimate" xml:space="preserve">
+    <value>dGPU만 사용</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>GPU 설정</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>목표 온도</value>
+  </data>
+  <data name="KeyBindings" xml:space="preserve">
+    <value>키 설정</value>
+  </data>
+  <data name="Keyboard" xml:space="preserve">
+    <value>키보드</value>
+  </data>
+  <data name="KeyboardAuto" xml:space="preserve">
+    <value>배터리 사용 중에만 백라이트 밝기 낮추기</value>
+  </data>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Eco 모드로 전환 시 GPU를 사용하는 모든 앱 중지</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>백라이트</value>
+  </data>
+  <data name="LaptopKeyboard" xml:space="preserve">
+    <value>키보드</value>
+  </data>
+  <data name="LaptopScreen" xml:space="preserve">
+    <value>화면</value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>덮개</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>라이트바</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>로고</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>오디오 비주얼라이저</value>
+  </data>
+  <data name="MatrixBanner" xml:space="preserve">
+    <value>Binary Banner</value>
+  </data>
+  <data name="MatrixBright" xml:space="preserve">
+    <value>밝게</value>
+  </data>
+  <data name="MatrixClock" xml:space="preserve">
+    <value>시계</value>
+  </data>
+  <data name="MatrixDim" xml:space="preserve">
+    <value>어둡게</value>
+  </data>
+  <data name="MatrixLogo" xml:space="preserve">
+    <value>Rog 로고</value>
+  </data>
+  <data name="MatrixMedium" xml:space="preserve">
+    <value>중간</value>
+  </data>
+  <data name="MatrixOff" xml:space="preserve">
+    <value>끄기</value>
+  </data>
+  <data name="MatrixPicture" xml:space="preserve">
+    <value>사진</value>
+  </data>
+  <data name="MaxRefreshTooltip" xml:space="preserve">
+    <value>최대 주사율 설정</value>
+  </data>
+  <data name="MinRefreshTooltip" xml:space="preserve">
+    <value>60Hz 주사율 설정</value>
+  </data>
+  <data name="Multizone" xml:space="preserve">
+    <value>멀티존</value>
+  </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>마이크 음소거</value>
+  </data>
+  <data name="OpenGHelper" xml:space="preserve">
+    <value>G-Helper 열기</value>
+  </data>
+  <data name="Optimized" xml:space="preserve">
+    <value>최적화</value>
+  </data>
+  <data name="OptimizedGPUTooltip" xml:space="preserve">
+    <value>배터리 사용 중에만 Eco 모드 설정</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>최적화 모드에서 PD 충전 시 GPU 비활성화</value>
+  </data>
+  <data name="Other" xml:space="preserve">
+    <value>기타 설정</value>
+  </data>
+  <data name="Overdrive" xml:space="preserve">
+    <value>오버드라이브</value>
+  </data>
+  <data name="PerformanceMode" xml:space="preserve">
+    <value>성능 모드</value>
+  </data>
+  <data name="PictureGif" xml:space="preserve">
+    <value>사진 / Gif</value>
+  </data>
+  <data name="PlayPause" xml:space="preserve">
+    <value>재생 / 정지</value>
+  </data>
+  <data name="PowerLimits" xml:space="preserve">
+    <value>전력 제한</value>
+  </data>
+  <data name="PPTExperimental" xml:space="preserve">
+    <value>전력 제한 은 실험적인 기능입니다. 주의하여 사용하세요!</value>
+  </data>
+  <data name="PrintScreen" xml:space="preserve">
+    <value>PrintScreen</value>
+  </data>
+  <data name="Quit" xml:space="preserve">
+    <value>종료</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>dGPU가 사용중이기 때문에 Eco 모드로 전환할 수 없습니다. 장치 관리자에서 dGPU를 재시작하시겠습니까?</value>
+  </data>
+  <data name="RPM" xml:space="preserve">
+    <value>RPM</value>
+  </data>
+  <data name="RunOnStartup" xml:space="preserve">
+    <value>시스템 시작 시 실행</value>
+  </data>
+  <data name="Shutdown" xml:space="preserve">
+    <value>꺼짐</value>
+  </data>
+  <data name="Silent" xml:space="preserve">
+    <value>조용</value>
+  </data>
+  <data name="Sleep" xml:space="preserve">
+    <value>Sleep</value>
+  </data>
+  <data name="StandardGPUTooltip" xml:space="preserve">
+    <value>Standard 모드에서 dGPU 켜기</value>
+  </data>
+  <data name="StandardMode" xml:space="preserve">
+    <value>Standard</value>
+  </data>
+  <data name="Start" xml:space="preserve">
+    <value>시작</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>서비스 시작 중</value>
+  </data>
+  <data name="StartupError" xml:space="preserve">
+    <value>시작 오류</value>
+  </data>
+  <data name="Stop" xml:space="preserve">
+    <value>중지</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>서비스 중지 중</value>
+  </data>
+  <data name="ToggleAura" xml:space="preserve">
+    <value>Aura 토글 키</value>
+  </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>Fn-Lock 토글 키</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Miniled 토글 키 (지원하는 기기만)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>화면 토글 키</value>
+  </data>
+  <data name="Turbo" xml:space="preserve">
+    <value>터보</value>
+  </data>
+  <data name="TurnedOff" xml:space="preserve">
+    <value>꺼짐</value>
+  </data>
+  <data name="TurnOffOnBattery" xml:space="preserve">
+    <value>배터리 사용 중에는 끄기</value>
+  </data>
+  <data name="UltimateGPUTooltip" xml:space="preserve">
+    <value>노트북 화면을 dGPU와 연결, FPS 최대화</value>
+  </data>
+  <data name="UltimateMode" xml:space="preserve">
+    <value>Ultimate</value>
+  </data>
+  <data name="Updates" xml:space="preserve">
+    <value>업데이트</value>
+  </data>
+  <data name="VersionLabel" xml:space="preserve">
+    <value>버전</value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>볼륨 작게</value>
+  </data>
+  <data name="VolumeMute" xml:space="preserve">
+    <value>음소거</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>볼륨 크게</value>
+  </data>
+  <data name="WindowTop" xml:space="preserve">
+    <value>창을 항상 맨 위로 유지</value>
+  </data>
+</root>

app/Properties/Strings.pl.resx

@@ -0,0 +1,471 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ACPIError" xml:space="preserve">
+    <value>Nie można odnaleźć sterownika ASUS ACPI. Aplikacja nie może bez niego funkcjonować. Spróbuj zainstalować Asus System Control Interface</value>
+  </data>
+  <data name="AlertDGPU" xml:space="preserve">
+    <value>Wygląda na to, że GPU jest mocno obciążone. Wyłączyć?</value>
+  </data>
+  <data name="AlertDGPUTitle" xml:space="preserve">
+    <value>Tryb Eco</value>
+  </data>
+  <data name="AlertUltimateOff" xml:space="preserve">
+    <value>Wyłączenie trybu Ultimate wymaga ponownego uruchomienia</value>
+  </data>
+  <data name="AlertUltimateOn" xml:space="preserve">
+    <value>Tryb Ultimate wymaga ponownego uruchomienia</value>
+  </data>
+  <data name="AlertUltimateTitle" xml:space="preserve">
+    <value>Uruchomić ponownie teraz?</value>
+  </data>
+  <data name="AnimationSpeed" xml:space="preserve">
+    <value>Prędkość animacji</value>
+  </data>
+  <data name="AnimeMatrix" xml:space="preserve">
+    <value>Anime Matrix</value>
+  </data>
+  <data name="AppAlreadyRunning" xml:space="preserve">
+    <value>Aplikacja jest już uruchomiona</value>
+  </data>
+  <data name="AppAlreadyRunningText" xml:space="preserve">
+    <value>G-Helper jest już uruchomiony. Sprawdź obszar powiadomień na pasku zadań.</value>
+  </data>
+  <data name="ApplyFanCurve" xml:space="preserve">
+    <value>Zastosuj krzywe</value>
+  </data>
+  <data name="ApplyPowerLimits" xml:space="preserve">
+    <value>Zastosuj limity</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Automatycznie dostosuj Plan Zasilania Windows</value>
+  </data>
+  <data name="AuraBreathe" xml:space="preserve">
+    <value>Oddychanie</value>
+  </data>
+  <data name="AuraColorCycle" xml:space="preserve">
+    <value>Pętla kolorów</value>
+  </data>
+  <data name="AuraFast" xml:space="preserve">
+    <value>Szybka</value>
+  </data>
+  <data name="AuraNormal" xml:space="preserve">
+    <value>Normalna</value>
+  </data>
+  <data name="AuraRainbow" xml:space="preserve">
+    <value>Tęcza</value>
+  </data>
+  <data name="AuraSlow" xml:space="preserve">
+    <value>Powolna</value>
+  </data>
+  <data name="AuraStatic" xml:space="preserve">
+    <value>Statyczny</value>
+  </data>
+  <data name="AuraStrobe" xml:space="preserve">
+    <value>Stroboskop</value>
+  </data>
+  <data name="AutoMode" xml:space="preserve">
+    <value>Auto</value>
+  </data>
+  <data name="AutoRefreshTooltip" xml:space="preserve">
+    <value>Automatycznie ustaw odświeżanie 60 Hz w czasie pracy na baterii</value>
+  </data>
+  <data name="Awake" xml:space="preserve">
+    <value>Aktywność</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Wyłączenie podświetlenia na baterii</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Wyłączenie podświetlenia po podłączeniu (0 - nigdy)</value>
+  </data>
+  <data name="Balanced" xml:space="preserve">
+    <value>Balans</value>
+  </data>
+  <data name="BatteryChargeLimit" xml:space="preserve">
+    <value>Limit ładowania baterii</value>
+  </data>
+  <data name="Boot" xml:space="preserve">
+    <value>Podczas uruchamiania</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Jasność</value>
+  </data>
+  <data name="Color" xml:space="preserve">
+    <value>Kolor</value>
+  </data>
+  <data name="CPUBoost" xml:space="preserve">
+    <value>CPU Boost</value>
+  </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Niestandardowy</value>
+  </data>
+  <data name="Default" xml:space="preserve">
+    <value>Domyślny</value>
+  </data>
+  <data name="DisableOverdrive" xml:space="preserve">
+    <value>Wyłącz funkcję Overdrive monitora</value>
+  </data>
+  <data name="Discharging" xml:space="preserve">
+    <value>Zużycie mocy</value>
+  </data>
+  <data name="DownloadUpdate" xml:space="preserve">
+    <value>Pobierz aktualizację</value>
+  </data>
+  <data name="EcoGPUTooltip" xml:space="preserve">
+    <value>Wyłącza dedykowane GPU aby oszczędzić baterię</value>
+  </data>
+  <data name="EcoMode" xml:space="preserve">
+    <value>Eco</value>
+  </data>
+  <data name="Extra" xml:space="preserve">
+    <value>Ustawienia</value>
+  </data>
+  <data name="ExtraSettings" xml:space="preserve">
+    <value>Dodatkowe ustawienia</value>
+  </data>
+  <data name="FactoryDefaults" xml:space="preserve">
+    <value>Ustawienia fabryczne</value>
+  </data>
+  <data name="FanCurves" xml:space="preserve">
+    <value>Krzywe wentylatorów</value>
+  </data>
+  <data name="FanProfileCPU" xml:space="preserve">
+    <value>Krzywa wentylatora CPU</value>
+  </data>
+  <data name="FanProfileGPU" xml:space="preserve">
+    <value>Krzywa wentylatora GPU</value>
+  </data>
+  <data name="FanProfileMid" xml:space="preserve">
+    <value>Krzywa wentylatora centralnego</value>
+  </data>
+  <data name="FanProfiles" xml:space="preserve">
+    <value>Tryb krzywych</value>
+  </data>
+  <data name="FansAndPower" xml:space="preserve">
+    <value>Wentylatory i moc</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Obroty: </value>
+  </data>
+  <data name="FansPower" xml:space="preserve">
+    <value>Dostosuj</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
+  </data>
+  <data name="GPUChanging" xml:space="preserve">
+    <value>Przełączanie</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Przesunięcie zegara rdzenia</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Przesunięcie zegara pamięci</value>
+  </data>
+  <data name="GPUMode" xml:space="preserve">
+    <value>Tryb GPU</value>
+  </data>
+  <data name="GPUModeEco" xml:space="preserve">
+    <value>tylko iGPU</value>
+  </data>
+  <data name="GPUModeStandard" xml:space="preserve">
+    <value>iGPU + dGPU</value>
+  </data>
+  <data name="GPUModeUltimate" xml:space="preserve">
+    <value>tylko dGPU</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>Ustawienia GPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Temperatura docelowa</value>
+  </data>
+  <data name="KeyBindings" xml:space="preserve">
+    <value>Ustawienia klawiszy skrótów</value>
+  </data>
+  <data name="Keyboard" xml:space="preserve">
+    <value>Klawiatura</value>
+  </data>
+  <data name="KeyboardAuto" xml:space="preserve">
+    <value>Automatycznie zmniejsz jasność w czasie pracy na baterii</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Podświetlenie</value>
+  </data>
+  <data name="LaptopKeyboard" xml:space="preserve">
+    <value>Klawiatura laptopa</value>
+  </data>
+  <data name="LaptopScreen" xml:space="preserve">
+    <value>Ekran laptopa</value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Pokrywa</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Lightbar</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Wizualizer muzyki</value>
+  </data>
+  <data name="MatrixBanner" xml:space="preserve">
+    <value>Binarny</value>
+  </data>
+  <data name="MatrixBright" xml:space="preserve">
+    <value>Jasny</value>
+  </data>
+  <data name="MatrixClock" xml:space="preserve">
+    <value>Clock</value>
+  </data>
+  <data name="MatrixDim" xml:space="preserve">
+    <value>Ciemny</value>
+  </data>
+  <data name="MatrixLogo" xml:space="preserve">
+    <value>Logo ROG</value>
+  </data>
+  <data name="MatrixMedium" xml:space="preserve">
+    <value>Średni</value>
+  </data>
+  <data name="MatrixOff" xml:space="preserve">
+    <value>Wyłączony</value>
+  </data>
+  <data name="MatrixPicture" xml:space="preserve">
+    <value>Obraz</value>
+  </data>
+  <data name="MaxRefreshTooltip" xml:space="preserve">
+    <value>Maksymalna częstotliwość odświeżania dla mniejszych opóźnień</value>
+  </data>
+  <data name="MinRefreshTooltip" xml:space="preserve">
+    <value>Częstotliwość odświeżania 60 Hz dla oszczędzania baterii</value>
+  </data>
+  <data name="Multizone" xml:space="preserve">
+    <value>Multizone</value>
+  </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Wyciszenie mikrofonu</value>
+  </data>
+  <data name="OpenGHelper" xml:space="preserve">
+    <value>Otwórz okno G-Helper</value>
+  </data>
+  <data name="Optimized" xml:space="preserve">
+    <value>Optymalny</value>
+  </data>
+  <data name="OptimizedGPUTooltip" xml:space="preserve">
+    <value>Przełącza na Eco w czasie pracy na baterii i na Standard po podłączeniu</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>W trybie Optymalnym wyłącz GPU podczas ładowania przez USB-C</value>
+  </data>
+  <data name="Other" xml:space="preserve">
+    <value>Inne</value>
+  </data>
+  <data name="Overdrive" xml:space="preserve">
+    <value>Overdrive</value>
+  </data>
+  <data name="PerformanceMode" xml:space="preserve">
+    <value>Tryb zasilania</value>
+  </data>
+  <data name="PictureGif" xml:space="preserve">
+    <value>Obraz / GIF</value>
+  </data>
+  <data name="PlayPause" xml:space="preserve">
+    <value>Odtwórz / Pauza</value>
+  </data>
+  <data name="PowerLimits" xml:space="preserve">
+    <value>Limit mocy</value>
+  </data>
+  <data name="PPTExperimental" xml:space="preserve">
+    <value>Ustawienie limitu mocy jest funkcją eksperymentalną. Używaj ostrożnie, na własną odpowiedzialność!</value>
+  </data>
+  <data name="PrintScreen" xml:space="preserve">
+    <value>Zrzut ekranu</value>
+  </data>
+  <data name="Quit" xml:space="preserve">
+    <value>Zamknij</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Coś korzysta z dedykowanego GPU i uniemożliwia włączenie trybu Eco. Zresetować dedykowany GPU w Menadżerze Urządzeń? * Używaj na własną odpowiedzialność</value>
+  </data>
+  <data name="RPM" xml:space="preserve">
+    <value>RPM</value>
+  </data>
+  <data name="RunOnStartup" xml:space="preserve">
+    <value>Uruchom przy starcie systemu</value>
+  </data>
+  <data name="Shutdown" xml:space="preserve">
+    <value>Zamknij</value>
+  </data>
+  <data name="Silent" xml:space="preserve">
+    <value>Cichy</value>
+  </data>
+  <data name="Sleep" xml:space="preserve">
+    <value>Uśpij</value>
+  </data>
+  <data name="StandardGPUTooltip" xml:space="preserve">
+    <value>Enables dGPU for standard use</value>
+  </data>
+  <data name="StandardMode" xml:space="preserve">
+    <value>Standard</value>
+  </data>
+  <data name="StartupError" xml:space="preserve">
+    <value>Błąd uruchamiania</value>
+  </data>
+  <data name="ToggleAura" xml:space="preserve">
+    <value>Przełącz Aura</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Przełącz MiniLED</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Przełącz ekran</value>
+  </data>
+  <data name="Turbo" xml:space="preserve">
+    <value>Turbo</value>
+  </data>
+  <data name="TurnedOff" xml:space="preserve">
+    <value>Wyłączony</value>
+  </data>
+  <data name="TurnOffOnBattery" xml:space="preserve">
+    <value>Wyłączony na baterii</value>
+  </data>
+  <data name="UltimateGPUTooltip" xml:space="preserve">
+    <value>Podłącza ekran laptopa bezpośrednio do dedykowanego GPU</value>
+  </data>
+  <data name="UltimateMode" xml:space="preserve">
+    <value>Ultimate</value>
+  </data>
+  <data name="VersionLabel" xml:space="preserve">
+    <value>Wersja</value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Zmniejsz głośność</value>
+  </data>
+  <data name="VolumeMute" xml:space="preserve">
+    <value>Wyciszenie</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Zwiększ głośność</value>
+  </data>
+  <data name="WindowTop" xml:space="preserve">
+    <value>Zachowaj okno aplikacji zawsze na wierzchu</value>
+  </data>
+</root>

app/Properties/Strings.pt-br.resx

@@ -0,0 +1,492 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ACPIError" xml:space="preserve">
+    <value>Não foi possível conectar ao ASUS ACPI. O applicativo não pode funcionar sem isso. Tente instalar Asus System Controle Interface</value>
+  </data>
+  <data name="AlertDGPU" xml:space="preserve">
+    <value>Parece que o GPU está em uso pesado.</value>
+  </data>
+  <data name="AlertDGPUTitle" xml:space="preserve">
+    <value>Modo econômico</value>
+  </data>
+  <data name="AlertUltimateOff" xml:space="preserve">
+    <value>Passar ao Modo Final implica na reinicialização do sistema</value>
+  </data>
+  <data name="AlertUltimateOn" xml:space="preserve">
+    <value>Modo Ultimado necessita de reinicialização.</value>
+  </data>
+  <data name="AlertUltimateTitle" xml:space="preserve">
+    <value>Reiniciar agora ?</value>
+  </data>
+  <data name="AnimationSpeed" xml:space="preserve">
+    <value>Velocidade da Animação</value>
+  </data>
+  <data name="AnimeMatrix" xml:space="preserve">
+    <value>Anime Matrix</value>
+  </data>
+  <data name="AppAlreadyRunning" xml:space="preserve">
+    <value>O applicativo já está em execução</value>
+  </data>
+  <data name="AppAlreadyRunningText" xml:space="preserve">
+    <value>G-Helper já está em execução. Verifique a barra de sistema</value>
+  </data>
+  <data name="ApplyFanCurve" xml:space="preserve">
+    <value>Aplicar a curva personalizada</value>
+  </data>
+  <data name="ApplyPowerLimits" xml:space="preserve">
+    <value>Aplicar as limitações de energia</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Ajuste automático dos modos de energia do Windows</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>Serviços da Asus em execução</value>
+  </data>
+  <data name="AuraBreathe" xml:space="preserve">
+    <value>Repiração</value>
+  </data>
+  <data name="AuraColorCycle" xml:space="preserve">
+    <value>Ciclo de cores</value>
+  </data>
+  <data name="AuraFast" xml:space="preserve">
+    <value>Rápido</value>
+  </data>
+  <data name="AuraNormal" xml:space="preserve">
+    <value>Normal</value>
+  </data>
+  <data name="AuraRainbow" xml:space="preserve">
+    <value>Arco-íris</value>
+  </data>
+  <data name="AuraSlow" xml:space="preserve">
+    <value>Lento</value>
+  </data>
+  <data name="AuraStatic" xml:space="preserve">
+    <value>Estático</value>
+  </data>
+  <data name="AuraStrobe" xml:space="preserve">
+    <value>Estroboscópio</value>
+  </data>
+  <data name="AutoMode" xml:space="preserve">
+    <value>Automático</value>
+  </data>
+  <data name="AutoRefreshTooltip" xml:space="preserve">
+    <value>Menor taxa de atualização quando estiver na bateria</value>
+  </data>
+  <data name="Awake" xml:space="preserve">
+    <value>Acordado</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Tempo limite da iluminação na bateria (em segundos)</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Tempo limite da iluminação carregando (0 - sempre ligado)</value>
+  </data>
+  <data name="Balanced" xml:space="preserve">
+    <value>Equilibrado</value>
+  </data>
+  <data name="BatteryChargeLimit" xml:space="preserve">
+    <value>Limite de carga</value>
+  </data>
+  <data name="Boot" xml:space="preserve">
+    <value>Ao ligar</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Nível do brilho</value>
+  </data>
+  <data name="Color" xml:space="preserve">
+    <value>Cor</value>
+  </data>
+  <data name="CPUBoost" xml:space="preserve">
+    <value>CPU Boost</value>
+  </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Personalizado</value>
+  </data>
+  <data name="Default" xml:space="preserve">
+    <value>Padrão</value>
+  </data>
+  <data name="DisableOverdrive" xml:space="preserve">
+    <value>Desativar o overdrive da tela</value>
+  </data>
+  <data name="Discharging" xml:space="preserve">
+    <value>Descarregando</value>
+  </data>
+  <data name="DownloadUpdate" xml:space="preserve">
+    <value>Baixar a atualização</value>
+  </data>
+  <data name="EcoGPUTooltip" xml:space="preserve">
+    <value>Desativar o dGPU para economisar a energía</value>
+  </data>
+  <data name="EcoMode" xml:space="preserve">
+    <value>Econômico</value>
+  </data>
+  <data name="Extra" xml:space="preserve">
+    <value>Adicional</value>
+  </data>
+  <data name="ExtraSettings" xml:space="preserve">
+    <value>Configurações adicionais</value>
+  </data>
+  <data name="FactoryDefaults" xml:space="preserve">
+    <value>Padrão de fábrica</value>
+  </data>
+  <data name="FanCurves" xml:space="preserve">
+    <value>Curvas de ventilador</value>
+  </data>
+  <data name="FanProfileCPU" xml:space="preserve">
+    <value>Perfil de ventilador CPU</value>
+  </data>
+  <data name="FanProfileGPU" xml:space="preserve">
+    <value>Perfil de ventilador GPU</value>
+  </data>
+  <data name="FanProfileMid" xml:space="preserve">
+    <value>Perfil de ventilador central</value>
+  </data>
+  <data name="FanProfiles" xml:space="preserve">
+    <value>Perfis de ventilador</value>
+  </data>
+  <data name="FansAndPower" xml:space="preserve">
+    <value>Ventiladores e Energía</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Vent</value>
+  </data>
+  <data name="FansPower" xml:space="preserve">
+    <value>Ventiladores + Energía</value>
+  </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Processar teclas de atalho Fn+F sem pressionar Fn</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Boost dinâmico</value>
+  </data>
+  <data name="GPUChanging" xml:space="preserve">
+    <value>Carregando</value>
+  </data>
+  <data name="GPUMode" xml:space="preserve">
+    <value>Modo de GPU</value>
+  </data>
+  <data name="GPUModeEco" xml:space="preserve">
+    <value>Só iGPU</value>
+  </data>
+  <data name="GPUModeStandard" xml:space="preserve">
+    <value>iGPU + dGPU</value>
+  </data>
+  <data name="GPUModeUltimate" xml:space="preserve">
+    <value>Exclusivamente dGPU</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>Parâmetros de GPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Alvo de temperatura</value>
+  </data>
+  <data name="Keyboard" xml:space="preserve">
+    <value>Teclado</value>
+  </data>
+  <data name="KeyboardAuto" xml:space="preserve">
+    <value>Abaixar a luz de fundo na bateria e voltar quando carregando</value>
+  </data>
+  <data name="KeyboardBacklight" xml:space="preserve">
+    <value>Luz de fundo do teclado</value>
+  </data>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Parar todos os aplicativos que usam a GPU ao alternar para o modo Eco</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Configurações de iluminação</value>
+  </data>
+  <data name="LaptopKeyboard" xml:space="preserve">
+    <value>Teclado</value>
+  </data>
+  <data name="LaptopScreen" xml:space="preserve">
+    <value>Tela</value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Tampa</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixBanner" xml:space="preserve">
+    <value>Bandeira Binária</value>
+  </data>
+  <data name="MatrixBright" xml:space="preserve">
+    <value>Brilho</value>
+  </data>
+  <data name="MatrixClock" xml:space="preserve">
+    <value>Relógio</value>
+  </data>
+  <data name="MatrixDim" xml:space="preserve">
+    <value>Escuro</value>
+  </data>
+  <data name="MatrixLogo" xml:space="preserve">
+    <value>Logo ROG</value>
+  </data>
+  <data name="MatrixMedium" xml:space="preserve">
+    <value>Médio</value>
+  </data>
+  <data name="MatrixOff" xml:space="preserve">
+    <value>Desligado</value>
+  </data>
+  <data name="MatrixPicture" xml:space="preserve">
+    <value>Imagem</value>
+  </data>
+  <data name="MaxRefreshTooltip" xml:space="preserve">
+    <value>Taxa de atualização máxima e menor latência</value>
+  </data>
+  <data name="MinRefreshTooltip" xml:space="preserve">
+    <value>Taxa de atualização à 60Hz para economizar bateria</value>
+  </data>
+  <data name="Multizone" xml:space="preserve">
+    <value>Multizona</value>
+  </data>
+    <data name="MuteMic" xml:space="preserve">
+    <value>Desligar microfone</value>
+  </data>
+  <data name="OpenGHelper" xml:space="preserve">
+    <value>Abrir G-Helper</value>
+  </data>
+  <data name="Optimized" xml:space="preserve">
+    <value>Otimizado</value>
+  </data>
+  <data name="OptimizedGPUTooltip" xml:space="preserve">
+    <value>Passar ao Ecônomico em bateria e voltar quando carregando</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Manter a GPU desativada ao usar um carregador USB-C no modo Otimizado</value>
+  </data>
+  <data name="Other" xml:space="preserve">
+    <value>Outro</value>
+  </data>
+  <data name="Overdrive" xml:space="preserve">
+    <value>Overdrive</value>
+  </data>
+  <data name="PerformanceMode" xml:space="preserve">
+    <value>Modo</value>
+  </data>
+  <data name="PictureGif" xml:space="preserve">
+    <value>Imagem / Gif</value>
+  </data>
+  <data name="PlayPause" xml:space="preserve">
+    <value>Reproduzir / Pausar</value>
+  </data>
+  <data name="PowerLimits" xml:space="preserve">
+    <value>Limitações de Energia</value>
+  </data>
+  <data name="PPTExperimental" xml:space="preserve">
+    <value>Limitações de Energia é uma funcionalidade experimental. Use com cuidado.</value>
+  </data>
+  <data name="PrintScreen" xml:space="preserve">
+    <value>Captura de tela</value>
+  </data>
+  <data name="Quit" xml:space="preserve">
+    <value>Sair</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Aumento da frequência básica</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Aumento da frequência da memória</value>
+  </data>
+  <data name="KeyBindings" xml:space="preserve">
+    <value>Combinações de teclas</value>
+  </data>
+  <data name="RPM" xml:space="preserve">
+    <value>RPM</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Algum processo está usando o dGPU e impedindo o modo Econômico. Reinicialize o dGPU no gerenciador de dispositivos. Por favor, proceda por sua conta e risco. </value>
+  </data>
+  <data name="RunOnStartup" xml:space="preserve">
+    <value>Executar ao iniciar</value>
+  </data>
+  <data name="Shutdown" xml:space="preserve">
+    <value>Desligar</value>
+  </data>
+  <data name="Silent" xml:space="preserve">
+    <value>Silencioso</value>
+  </data>
+  <data name="Sleep" xml:space="preserve">
+    <value>Hibernação</value>
+  </data>
+  <data name="StandardGPUTooltip" xml:space="preserve">
+    <value>Liga o dGPU para uso padrão</value>
+  </data>
+  <data name="StandardMode" xml:space="preserve">
+    <value>Padrão</value>
+  </data>
+  <data name="StartupError" xml:space="preserve">
+    <value>Erro de inicialização</value>
+  </data>
+  <data name="Start" xml:space="preserve">
+    <value>Iniciar</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>Iniciando os serviços</value>
+  </data>
+  <data name="Stop" xml:space="preserve">
+    <value>Parar</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>Parando os serviços</value>
+  </data>
+  <data name="ToggleAura" xml:space="preserve">
+    <value>Alternar Aura</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Alternar Miniled (se suportado) </value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Alternar Tela</value>
+  </data>
+  <data name="Turbo" xml:space="preserve">
+    <value>Turbo</value>
+  </data>
+  <data name="TurnedOff" xml:space="preserve">
+    <value>Desligado</value>
+  </data>
+  <data name="TurnOffOnBattery" xml:space="preserve">
+    <value>Desligar em bateria</value>
+  </data>
+  <data name="UltimateGPUTooltip" xml:space="preserve">
+    <value>Direciona a tela do computador ao dGPU</value>
+  </data>
+  <data name="UltimateMode" xml:space="preserve">
+    <value>Ultimate</value>
+  </data>
+  <data name="Updates" xml:space="preserve">
+    <value>Atualizações</value>
+  </data>
+  <data name="VersionLabel" xml:space="preserve">
+    <value>Versão</value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Abaixar o volume</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Aumentar o volume</value>
+  </data>
+    <data name="VolumeMute" xml:space="preserve">
+    <value>Mudo</value>
+  </data>
+  <data name="WindowTop" xml:space="preserve">
+    <value>Manter a janela do aplicativo sempre no topo</value>
+  </data>
+</root>

app/Properties/Strings.resx

@@ -1,5 +1,64 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -94,6 +153,12 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Apply Power Limits</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Auto adjust Windows Power Modes</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>Asus Services Running</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Breathe</value>
   </data>
@@ -127,15 +192,33 @@
   <data name="Awake" xml:space="preserve">
     <value>Awake</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Backlight timeout on battery</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Backlight timeout when plugged (0 - always on)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>Balanced</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Battery Charge Limit</value>
   </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>BIOS and Driver Updates</value>
+  </data>
   <data name="Boot" xml:space="preserve">
     <value>Boot</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Brightness</value>
+  </data>
+  <data name="BrightnessDown" xml:space="preserve">
+    <value>Brightness Down</value>
+  </data>
+  <data name="BrightnessUp" xml:space="preserve">
+    <value>Brightness Up</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Color</value>
   </data>
@@ -157,12 +240,23 @@
   <data name="DownloadUpdate" xml:space="preserve">
     <value>Download Update</value>
   </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>Drivers and Software</value>
+  </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
     <value>Disables dGPU for battery savings</value>
   </data>
   <data name="EcoMode" xml:space="preserve">
     <value>Eco</value>
   </data>
+  <data name="EnableOptimusText" xml:space="preserve">
+    <value>Disabling the dGPU by going to Eco mode while Display Mode in NVIDIA Control Panel is not set to Optimus might cause problems with brightness controls until after the next reboot. 
+
+Do you still want to continue?</value>
+  </data>
+  <data name="EnableOptimusTitle" xml:space="preserve">
+    <value>NVIDIA Display Mode is not set to Optimus</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
   </data>
@@ -190,12 +284,27 @@
   <data name="FansAndPower" xml:space="preserve">
     <value>Fans and Power</value>
   </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Fan: </value>
+  </data>
   <data name="FansPower" xml:space="preserve">
     <value>Fans + Power</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Process Fn+F hotkeys without Fn</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>Changing</value>
   </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Core Clock Offset</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Memory Clock Offset</value>
+  </data>
   <data name="GPUMode" xml:space="preserve">
     <value>GPU Mode</value>
   </data>
@@ -208,6 +317,12 @@
   <data name="GPUModeUltimate" xml:space="preserve">
     <value>dGPU exclusive</value>
   </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>GPU Settings</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Temperature Target</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Key Bindings</value>
   </data>
@@ -217,8 +332,11 @@
   <data name="KeyboardAuto" xml:space="preserve">
     <value>Lower backlight brightness on battery and back when plugged</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Keyboard Backlight</value>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Stop all apps using GPU when switching to Eco</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Laptop Backlight</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>Laptop Keyboard</value>
@@ -226,6 +344,18 @@
   <data name="LaptopScreen" xml:space="preserve">
     <value>Laptop Screen</value>
   </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Lid</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Lightbar</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Audio Visualizer</value>
+  </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>Binary Banner</value>
   </data>
@@ -259,6 +389,15 @@
   <data name="Multizone" xml:space="preserve">
     <value>Multizone</value>
   </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Mute Mic</value>
+  </data>
+  <data name="NewUpdates" xml:space="preserve">
+    <value>New updates</value>
+  </data>
+  <data name="NoNewUpdates" xml:space="preserve">
+    <value>No new updates</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Open G-Helper window</value>
   </data>
@@ -268,6 +407,9 @@
   <data name="OptimizedGPUTooltip" xml:space="preserve">
     <value>Switch to Eco on battery and to Standard when plugged</value>
   </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Keep GPU disabled on USB-C charger in Optimized mode</value>
+  </data>
   <data name="Other" xml:space="preserve">
     <value>Other</value>
   </data>
@@ -275,7 +417,7 @@
     <value>Overdrive</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Performance Mode</value>
+    <value>Mode</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Picture / Gif</value>
@@ -284,10 +426,10 @@
     <value>Play / Pause</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Power Limits (PPT)</value>
+    <value>Power Limits</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Power Limits (PPT) is experimental feature. Use carefully and on your own risk!</value>
+    <value>Power Limits is experimental feature. Use carefully and on your own risk!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
@@ -295,6 +437,9 @@
   <data name="Quit" xml:space="preserve">
     <value>Quit</value>
   </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Something is using dGPU and preventing Eco mode. Restart dGPU in device manager? * Please proceed on your own risk.</value>
+  </data>
   <data name="RPM" xml:space="preserve">
     <value>RPM</value>
   </data>
@@ -316,12 +461,36 @@
   <data name="StandardMode" xml:space="preserve">
     <value>Standard</value>
   </data>
+  <data name="Start" xml:space="preserve">
+    <value>Start</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>Starting Services</value>
+  </data>
   <data name="StartupError" xml:space="preserve">
     <value>Startup Error</value>
   </data>
+  <data name="Stop" xml:space="preserve">
+    <value>Stop</value>
+  </data>
+  <data name="StopGPUApps" xml:space="preserve">
+    <value>Stop GPU Applications</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>Stopping Services</value>
+  </data>
   <data name="ToggleAura" xml:space="preserve">
     <value>Toggle Aura</value>
   </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>Toggle Fn-Lock</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Toggle Miniled (if supported)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Toggle Screen</value>
+  </data>
   <data name="Turbo" xml:space="preserve">
     <value>Turbo</value>
   </data>
@@ -337,12 +506,24 @@
   <data name="UltimateMode" xml:space="preserve">
     <value>Ultimate</value>
   </data>
+  <data name="UndervoltingRisky" xml:space="preserve">
+    <value>Undervolting is experimental and risky feature. If applied values are too low for your hardware, it can become unstable, shut down or cause data corruption. If you want to try - start from small values first, click Apply and test what works for you.</value>
+  </data>
+  <data name="Updates" xml:space="preserve">
+    <value>Updates</value>
+  </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>Version</value>
   </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Volume Down</value>
+  </data>
   <data name="VolumeMute" xml:space="preserve">
     <value>Volume Mute</value>
   </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Volume Up</value>
+  </data>
   <data name="WindowTop" xml:space="preserve">
     <value>Keep app window always on top</value>
   </data>

app/Properties/Strings.tr.resx

@@ -153,6 +153,9 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Güç Sınırlarını Uygula</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Windows Güç Modunu otomatik ayarla</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Nefes</value>
   </data>
@@ -186,6 +189,12 @@
   <data name="Awake" xml:space="preserve">
     <value>Uyanık</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Pildeyken klavye ışığının kapanma süresi</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Şarjdayken klavye ışığının kapanma süresi (0 her zaman açık)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>Dengeli</value>
   </data>
@@ -195,6 +204,9 @@
   <data name="Boot" xml:space="preserve">
     <value>Önyükleme</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Parlaklığı</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Renk</value>
   </data>
@@ -252,6 +264,9 @@
   <data name="FansPower" xml:space="preserve">
     <value>Fanlar + Güç</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Fn+F kısayol tuşlarını FN tuşuna basmadan çalıştır</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>Değiştiriliyor</value>
   </data>
@@ -276,8 +291,11 @@
   <data name="KeyboardAuto" xml:space="preserve">
     <value>Pille çalışırken klavye aydınlatmasını kıs, şarjdayken eski haline dön</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Klavye Aydınlatması</value>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Eco'ya geçerken dGPU kullanan tüm uygulamaları durdur</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Aydınlatması</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>Laptop Klavyesi</value>
@@ -327,6 +345,9 @@
   <data name="OptimizedGPUTooltip" xml:space="preserve">
     <value>Pille çalışırken Eko moda ve şarjdayken Standart moda geçiş yapın</value>
   </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Optimize edilmiş modda USB-c şarj cihazında GPU'yu devre dışı bırak</value>
+  </data>
   <data name="Other" xml:space="preserve">
     <value>Diğer</value>
   </data>
@@ -343,10 +364,10 @@
     <value>Oynat / Duraklat</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Güç Sınırları (PPT)</value>
+    <value>Güç Sınırları</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Güç Sınırları (PPT) deneysel bir özelliktir. Riski göze alarak dikkatli kullanın!</value>
+    <value>Güç Sınırları deneysel bir özelliktir. Riski göze alarak dikkatli kullanın!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>Ekran Görüntüsü Al</value>

app/Properties/Strings.uk.resx

@@ -153,6 +153,12 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Застосувати потужність</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Автоматично застосовувати Windows Power Modes</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>Кількість запущених сервісів Asus</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Дихання</value>
   </data>
@@ -186,15 +192,33 @@
   <data name="Awake" xml:space="preserve">
     <value>Робота</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Тайм-аут підсвітки на батареї</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>Тайм-аут підсвітки на зарядці (0 - завжди ввімкнено)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>Баланс</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Ліміт заряду батареї</value>
   </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>Оновлення BIOS та драйверів</value>
+  </data>
   <data name="Boot" xml:space="preserve">
     <value>Старт</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Яскравість</value>
+  </data>
+  <data name="BrightnessDown" xml:space="preserve">
+    <value>Зменшити яскравість</value>
+  </data>
+  <data name="BrightnessUp" xml:space="preserve">
+    <value>Підвищити яскравість</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Колір</value>
   </data>
@@ -216,6 +240,9 @@
   <data name="DownloadUpdate" xml:space="preserve">
     <value>Завантажити</value>
   </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>Драйвери та програми</value>
+  </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
     <value>Вимикає dGPU, щоб зберегти заряд</value>
   </data>
@@ -252,6 +279,9 @@
   <data name="FansPower" xml:space="preserve">
     <value>Кулери та Потужність</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Гарячі клавіші Fn+F працюють без натискання Fn</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>Зміна</value>
   </data>
@@ -276,8 +306,11 @@
   <data name="KeyboardAuto" xml:space="preserve">
     <value>Вимкнути підсвітку на батареї та увімкнути на зарядці</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>Підсвітка клавіатури</value>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Закривати додатки, що використовують GPU, під час переходу в режим Eco</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Підсвітка</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>Клавіатура</value>
@@ -285,6 +318,9 @@
   <data name="LaptopScreen" xml:space="preserve">
     <value>Дисплей</value>
   </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Аудіо візуалізатор</value>
+  </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>Бінарний банер</value>
   </data>
@@ -318,6 +354,9 @@
   <data name="Multizone" xml:space="preserve">
     <value>Мультизони</value>
   </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Вимкнути мікрофон</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Відкрити вікно G-Helper</value>
   </data>
@@ -327,6 +366,9 @@
   <data name="OptimizedGPUTooltip" xml:space="preserve">
     <value>Вмикає Еко на батареї та Стандартний на зарядці</value>
   </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Вимикати GPU на зарядці від USB-C в режимі Авто</value>
+  </data>
   <data name="Other" xml:space="preserve">
     <value>Інше</value>
   </data>
@@ -334,7 +376,7 @@
     <value>Овердрайв</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Режим Роботи</value>
+    <value>Режим</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Картинка / GIF</value>
@@ -343,10 +385,10 @@
     <value>Відтворення / Пауза</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Ліміти Потужності (PPT)</value>
+    <value>Ліміти Потужності</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Налаштування лімітів потужності (PPT) є експериментальною функцією. Використовуйте обережно та на свій страх і ризик!</value>
+    <value>Налаштування лімітів потужності є експериментальною функцією. Використовуйте обережно та на свій страх і ризик!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>Print Screen</value>
@@ -375,12 +417,33 @@
   <data name="StandardMode" xml:space="preserve">
     <value>Стандартний</value>
   </data>
+  <data name="Start" xml:space="preserve">
+    <value>Запустити</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>Запускаються сервіси</value>
+  </data>
   <data name="StartupError" xml:space="preserve">
     <value>Помилка запуску</value>
   </data>
+  <data name="Stop" xml:space="preserve">
+    <value>Зупинити</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>Зупиняються сервіси</value>
+  </data>
   <data name="ToggleAura" xml:space="preserve">
     <value>Аура</value>
   </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>Fn-Lock</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Міні-лед (якщо є)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Вимкнути екран</value>
+  </data>
   <data name="Turbo" xml:space="preserve">
     <value>Турбо</value>
   </data>
@@ -396,12 +459,21 @@
   <data name="UltimateMode" xml:space="preserve">
     <value>Ультімейт</value>
   </data>
+  <data name="Updates" xml:space="preserve">
+    <value>Оновлення</value>
+  </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>Версія</value>
   </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Зменшення гучності</value>
+  </data>
   <data name="VolumeMute" xml:space="preserve">
     <value>Вимкнення звуку</value>
   </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Збільшення гучності</value>
+  </data>
   <data name="WindowTop" xml:space="preserve">
     <value>Тримати вікно завжди зверху</value>
   </data>

app/Properties/Strings.vi.resx

@@ -0,0 +1,468 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ACPIError" xml:space="preserve">
+    <value>Không thể kết nối đến ASUS ACPI. Chương trình cần nó để có thể hoạt động. Hãy thử cài lại Asus System Control Interface</value>
+  </data>
+  <data name="AlertDGPU" xml:space="preserve">
+    <value>Có vẻ như GPU rời đang được sử dụng nhiều, tắt nó?</value>
+  </data>
+  <data name="AlertDGPUTitle" xml:space="preserve">
+    <value>Chế độ Tiết kiệm</value>
+  </data>
+  <data name="AlertUltimateOff" xml:space="preserve">
+    <value>Chuyển sang Chế độ Tối thượng cần phải khởi động lại</value>
+  </data>
+  <data name="AlertUltimateOn" xml:space="preserve">
+    <value>Chế độ Tối thượng yêu cầu phải khởi động lại</value>
+  </data>
+  <data name="AlertUltimateTitle" xml:space="preserve">
+    <value>Khởi động lại ngay?</value>
+  </data>
+  <data name="AnimationSpeed" xml:space="preserve">
+    <value>Tốc độ</value>
+  </data>
+  <data name="AnimeMatrix" xml:space="preserve">
+    <value>AniMe Matrix</value>
+  </data>
+  <data name="AppAlreadyRunning" xml:space="preserve">
+    <value>Chương trình đã chạy</value>
+  </data>
+  <data name="AppAlreadyRunningText" xml:space="preserve">
+    <value>G-Helper đã chạy. Hãy kiểm tra khay hệ thống</value>
+  </data>
+  <data name="ApplyFanCurve" xml:space="preserve">
+    <value>Áp dụng Đường cong quạt tuỳ chỉnh</value>
+  </data>
+  <data name="ApplyPowerLimits" xml:space="preserve">
+    <value>Áp dụng Giới hạn công suất</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Tự động điều chỉnh Kế hoạch nguồn của Windows</value>
+  </data>
+  <data name="AuraBreathe" xml:space="preserve">
+    <value>Hơi thở</value>
+  </data>
+  <data name="AuraColorCycle" xml:space="preserve">
+    <value>Chuyển màu</value>
+  </data>
+  <data name="AuraFast" xml:space="preserve">
+    <value>Nhanh</value>
+  </data>
+  <data name="AuraNormal" xml:space="preserve">
+    <value>Bình thường</value>
+  </data>
+  <data name="AuraRainbow" xml:space="preserve">
+    <value>Cầu vồng</value>
+  </data>
+  <data name="AuraSlow" xml:space="preserve">
+    <value>Chậm</value>
+  </data>
+  <data name="AuraStatic" xml:space="preserve">
+    <value>Tĩnh</value>
+  </data>
+  <data name="AuraStrobe" xml:space="preserve">
+    <value>Nhấp nháy</value>
+  </data>
+  <data name="AutoMode" xml:space="preserve">
+    <value>Tự động</value>
+  </data>
+  <data name="AutoRefreshTooltip" xml:space="preserve">
+    <value>Chuyển về 60Hz khi không cắm sạc và 120Hz khi cắm sạc</value>
+  </data>
+  <data name="Awake" xml:space="preserve">
+    <value>Đang bật</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Số giây để tắt đèn nền bàn phím(khi dùng pin)</value>
+  </data>
+  <data name="Balanced" xml:space="preserve">
+    <value>Cân bằng</value>
+  </data>
+  <data name="BatteryChargeLimit" xml:space="preserve">
+    <value>Giới hạn sạc</value>
+  </data>
+  <data name="Boot" xml:space="preserve">
+    <value>Khởi động</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Độ sáng</value>
+  </data>
+  <data name="Color" xml:space="preserve">
+    <value>Màu</value>
+  </data>
+  <data name="CPUBoost" xml:space="preserve">
+    <value>Tăng tốc CPU</value>
+  </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Tuỳ chỉnh</value>
+  </data>
+  <data name="Default" xml:space="preserve">
+    <value>Mặc định</value>
+  </data>
+  <data name="DisableOverdrive" xml:space="preserve">
+    <value>Tắt Overdrive</value>
+  </data>
+  <data name="Discharging" xml:space="preserve">
+    <value>Đang không sạc</value>
+  </data>
+  <data name="DownloadUpdate" xml:space="preserve">
+    <value>Tải xuống bản cập nhật</value>
+  </data>
+  <data name="EcoGPUTooltip" xml:space="preserve">
+    <value>Tắt GPU rời để tiết kiệm pin</value>
+  </data>
+  <data name="EcoMode" xml:space="preserve">
+    <value>Tiết kiệm</value>
+  </data>
+  <data name="Extra" xml:space="preserve">
+    <value>Thêm</value>
+  </data>
+  <data name="ExtraSettings" xml:space="preserve">
+    <value>Cài đặt bổ sung</value>
+  </data>
+  <data name="FactoryDefaults" xml:space="preserve">
+    <value>Đặt về mặc định</value>
+  </data>
+  <data name="FanCurves" xml:space="preserve">
+    <value>Chế độ Quạt</value>
+  </data>
+  <data name="FanProfileCPU" xml:space="preserve">
+    <value>Cấu hình Quạt CPU</value>
+  </data>
+  <data name="FanProfileGPU" xml:space="preserve">
+    <value>Cấu hình Quạt GPU</value>
+  </data>
+  <data name="FanProfileMid" xml:space="preserve">
+    <value>Cấu hình Quạt giữa</value>
+  </data>
+  <data name="FanProfiles" xml:space="preserve">
+    <value>Cấu hình Quạt</value>
+  </data>
+  <data name="FansAndPower" xml:space="preserve">
+    <value>Quạt và Công suất</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Quạt: </value>
+  </data>
+  <data name="FansPower" xml:space="preserve">
+    <value>Quạt + Công suất</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Tăng tốc năng động</value>
+  </data>
+  <data name="GPUChanging" xml:space="preserve">
+    <value>Đang đổi GPU</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Bù trừ Tốc độ Nhân GPU</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Bù trừ Tốc độ RAM GPU</value>
+  </data>
+  <data name="GPUMode" xml:space="preserve">
+    <value>Chế độ GPU</value>
+  </data>
+  <data name="GPUModeEco" xml:space="preserve">
+    <value>Chỉ dùng GPU tích hợp</value>
+  </data>
+  <data name="GPUModeStandard" xml:space="preserve">
+    <value>GPU tích hợp + GPU rời</value>
+  </data>
+  <data name="GPUModeUltimate" xml:space="preserve">
+    <value>Chỉ dùng GPU rời</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>Cài đặt GPU</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Nhiệt độ đích</value>
+  </data>
+  <data name="KeyBindings" xml:space="preserve">
+    <value>Tổ hợp phím</value>
+  </data>
+  <data name="Keyboard" xml:space="preserve">
+    <value>Bàn phím</value>
+  </data>
+  <data name="KeyboardAuto" xml:space="preserve">
+    <value>Giảm độ sáng bàn phím khi không cắm sạc</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Độ sáng đèn nền</value>
+  </data>
+  <data name="LaptopKeyboard" xml:space="preserve">
+    <value>Bàn phím Laptop</value>
+  </data>
+  <data name="LaptopScreen" xml:space="preserve">
+    <value>Màn hình Laptop</value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Màn gập</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Thanh sáng</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Sóng nhạc</value>
+  </data>
+  <data name="MatrixBanner" xml:space="preserve">
+    <value>Nhị phân</value>
+  </data>
+  <data name="MatrixBright" xml:space="preserve">
+    <value>Sáng</value>
+  </data>
+  <data name="MatrixClock" xml:space="preserve">
+    <value>Đồng hồ</value>
+  </data>
+  <data name="MatrixDim" xml:space="preserve">
+    <value>Sáng mờ</value>
+  </data>
+  <data name="MatrixLogo" xml:space="preserve">
+    <value>Logo ROG</value>
+  </data>
+  <data name="MatrixMedium" xml:space="preserve">
+    <value>Vừa phải</value>
+  </data>
+  <data name="MatrixOff" xml:space="preserve">
+    <value>Tắt</value>
+  </data>
+  <data name="MatrixPicture" xml:space="preserve">
+    <value>Hình ảnh</value>
+  </data>
+  <data name="MaxRefreshTooltip" xml:space="preserve">
+    <value>Tần số quét tối đa để có độ trễ thấp</value>
+  </data>
+  <data name="MinRefreshTooltip" xml:space="preserve">
+    <value>Tần số quét 60Hz để tiết kiệm pin</value>
+  </data>
+  <data name="Multizone" xml:space="preserve">
+    <value>Đèn nền Đa vùng(Multi-Zone)</value>
+  </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Tắt Mic</value>
+  </data>
+  <data name="OpenGHelper" xml:space="preserve">
+    <value>Mở cửa sổ G-Helper</value>
+  </data>
+  <data name="Optimized" xml:space="preserve">
+    <value>Tối ưu</value>
+  </data>
+  <data name="OptimizedGPUTooltip" xml:space="preserve">
+    <value>Chuyển về Tiết kiệm khi dùng pin và Tiêu chuẩn khi cắm sạc</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Tắt GPU khi dùng sạc Type-C ở Chế độ Tối ưu</value>
+  </data>
+  <data name="Other" xml:space="preserve">
+    <value>Khác</value>
+  </data>
+  <data name="Overdrive" xml:space="preserve">
+    <value>Overdrive</value>
+  </data>
+  <data name="PerformanceMode" xml:space="preserve">
+    <value>Chế độ Hiệu suất</value>
+  </data>
+  <data name="PictureGif" xml:space="preserve">
+    <value>Ảnh tĩnh / Ảnh động</value>
+  </data>
+  <data name="PlayPause" xml:space="preserve">
+    <value>Phát / Dừng</value>
+  </data>
+  <data name="PowerLimits" xml:space="preserve">
+    <value>Giới hạn công suất</value>
+  </data>
+  <data name="PPTExperimental" xml:space="preserve">
+    <value>Giới hạn công suất là tính năng thử nghiệm. Sử dụng nó cẩn thận và tự chịu mọi rủi ro!</value>
+  </data>
+  <data name="PrintScreen" xml:space="preserve">
+    <value>Chụp màn hình</value>
+  </data>
+  <data name="Quit" xml:space="preserve">
+    <value>Thoát</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Không thể chuyển về Chế độ Tiết kiệm do có gì đó đang dùng GPU rời. Khởi động lại GPU rời trong Quản lý Thiết bị? * Bạn sẽ chịu mọi rủi ro.</value>
+  </data>
+  <data name="RPM" xml:space="preserve">
+    <value>VTP</value>
+  </data>
+  <data name="RunOnStartup" xml:space="preserve">
+    <value>Chạy khi khởi động</value>
+  </data>
+  <data name="Shutdown" xml:space="preserve">
+    <value>Tắt nguồn</value>
+  </data>
+  <data name="Silent" xml:space="preserve">
+    <value>Im lặng</value>
+  </data>
+  <data name="Sleep" xml:space="preserve">
+    <value>Ngủ</value>
+  </data>
+  <data name="StandardGPUTooltip" xml:space="preserve">
+    <value>Bật GPU rời song song với GPU tích hợp</value>
+  </data>
+  <data name="StandardMode" xml:space="preserve">
+    <value>Tiêu chuẩn</value>
+  </data>
+  <data name="StartupError" xml:space="preserve">
+    <value>Khởi động lỗi</value>
+  </data>
+  <data name="ToggleAura" xml:space="preserve">
+    <value>Bật tắt Aura</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Bật tắt Miniled(Nếu có hỗ trợ)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Bật tắt màn hình</value>
+  </data>
+  <data name="Turbo" xml:space="preserve">
+    <value>Turbo</value>
+  </data>
+  <data name="TurnedOff" xml:space="preserve">
+    <value>Đã tắt</value>
+  </data>
+  <data name="TurnOffOnBattery" xml:space="preserve">
+    <value>Tắt khi không cắm sạc</value>
+  </data>
+  <data name="UltimateGPUTooltip" xml:space="preserve">
+    <value>Chỉ dùng GPU rời, tối đa hóa FPS</value>
+  </data>
+  <data name="UltimateMode" xml:space="preserve">
+    <value>Tối thượng</value>
+  </data>
+  <data name="VersionLabel" xml:space="preserve">
+    <value>Phiên bản</value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Giảm âm lượng</value>
+  </data>
+  <data name="VolumeMute" xml:space="preserve">
+    <value>Tắt âm lượng</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Tăng âm lượng</value>
+  </data>
+  <data name="WindowTop" xml:space="preserve">
+    <value>Giữ cửa sổ ở trên cùng</value>
+  </data>
+</root>

app/Properties/Strings.zh-CN.resx

@@ -153,6 +153,9 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>应用功率限制</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>自动调整Windows电源模式</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>呼吸</value>
   </data>
@@ -186,6 +189,12 @@
   <data name="Awake" xml:space="preserve">
     <value>唤醒时</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>使用电池时的背光超时时间</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>插入电源时的背光超时时间 (0 - 始终开启)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>平衡模式</value>
   </data>
@@ -195,6 +204,9 @@
   <data name="Boot" xml:space="preserve">
     <value>开机时</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>亮度</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>颜色</value>
   </data>
@@ -252,6 +264,9 @@
   <data name="FansPower" xml:space="preserve">
     <value>风扇与电源设置</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>打开FnLock (无需按下FN使用FN+(F1-F12)热键)</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>切换中...</value>
   </data>
@@ -276,8 +291,11 @@
   <data name="KeyboardAuto" xml:space="preserve">
     <value>电池模式下降低键盘亮度以省电，并在插上电源时恢复</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>键盘背光</value>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>当切换到集显模式时，停止所有正在使用独显的应用</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>背光</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>笔记本键盘</value>
@@ -318,6 +336,9 @@
   <data name="Multizone" xml:space="preserve">
     <value>多区域设置</value>
   </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>静音麦克风</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>打开G-Helper窗口</value>
   </data>
@@ -325,7 +346,10 @@
     <value>自动切换</value>
   </data>
   <data name="OptimizedGPUTooltip" xml:space="preserve">
-    <value>使用电池时关闭独显(集显模式)，并在插上电源后重新启用独显(混合输出)</value>
+    <value>使用电池时切换到集显模式，并在插上电源后重新启用标准模式</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>在自动切换模式下，使用USB-C为笔记本供电时禁用GPU</value>
   </data>
   <data name="Other" xml:space="preserve">
     <value>其他</value>
@@ -343,10 +367,10 @@
     <value>播放/暂停</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>功率限制 (PPT)</value>
+    <value>功率限制</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>功率限制 (PPT) 是实验性功能。 谨慎使用，风险自负！</value>
+    <value>功率限制 是实验性功能。 谨慎使用，风险自负！</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>截图</value>
@@ -399,10 +423,16 @@
   <data name="VersionLabel" xml:space="preserve">
     <value>版本</value>
   </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>音量降低</value>
+  </data>
   <data name="VolumeMute" xml:space="preserve">
     <value>静音</value>
   </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>音量增加</value>
+  </data>
   <data name="WindowTop" xml:space="preserve">
     <value>窗口置顶</value>
   </data>
-</root>
+</root>

app/Properties/Strings.zh-TW.resx

@@ -153,6 +153,9 @@
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>套用功率限制</value>
   </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>自動調整Windows電源模式</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>呼吸</value>
   </data>
@@ -186,15 +189,27 @@
   <data name="Awake" xml:space="preserve">
     <value>喚醒時</value>
   </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>電池模式下自動關閉鍵盤背光的秒數(0 = 不關閉)</value>
+  </data>
+  <data name="BacklightTimeoutPlugged" xml:space="preserve">
+    <value>插電模式下自動關閉鍵盤背光的秒數(0 = 不關閉)</value>
+  </data>
   <data name="Balanced" xml:space="preserve">
     <value>平衡模式</value>
   </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>電池充電上限</value>
   </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>BIOS與驅動程式更新 Updates</value>
+  </data>
   <data name="Boot" xml:space="preserve">
     <value>開機時</value>
   </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>亮度</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>顏色</value>
   </data>
@@ -216,6 +231,9 @@
   <data name="DownloadUpdate" xml:space="preserve">
     <value>下載更新</value>
   </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>驅動程式與軟體</value>
+  </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
     <value>禁用獨顯以節省電池電量</value>
   </data>
@@ -235,10 +253,10 @@
     <value>風扇曲線</value>
   </data>
   <data name="FanProfileCPU" xml:space="preserve">
-    <value>CPU 風扇設置文件</value>
+    <value>CPU 風扇設定檔</value>
   </data>
   <data name="FanProfileGPU" xml:space="preserve">
-    <value>GPU 風扇設置文件</value>
+    <value>GPU 風扇設定檔</value>
   </data>
   <data name="FanProfileMid" xml:space="preserve">
     <value>中等風扇設置</value>
@@ -249,12 +267,27 @@
   <data name="FansAndPower" xml:space="preserve">
     <value>風扇和電源</value>
   </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value> 風扇: </value>
+  </data>
   <data name="FansPower" xml:space="preserve">
     <value>自定義設置</value>
   </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>使用Fn+F1~F12功能時免按下Fn鍵</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dynamic Boost</value>
+  </data>
   <data name="GPUChanging" xml:space="preserve">
     <value>切換中...</value>
   </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>核心時脈偏移量(Offset)</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>顯示卡記憶體偏移量(Offset)</value>
+  </data>
   <data name="GPUMode" xml:space="preserve">
     <value>GPU 模式</value>
   </data>
@@ -267,6 +300,12 @@
   <data name="GPUModeUltimate" xml:space="preserve">
     <value>獨立顯卡</value>
   </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>顯卡設定</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>GPU溫度上限</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>按鍵綁定</value>
   </data>
@@ -274,10 +313,13 @@
     <value>鍵盤</value>
   </data>
   <data name="KeyboardAuto" xml:space="preserve">
-    <value>電池模式時自動降低鍵盤背光亮度以省電</value>
+    <value>電池模式時自動降低鍵盤背光亮度以節省電量</value>
   </data>
-  <data name="KeyboardBacklight" xml:space="preserve">
-    <value>鍵盤背光</value>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>背光</value>
+  </data>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>切換至節能模式時，關閉所有正在使用獨顯的程式</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>鍵盤背光:</value>
@@ -285,6 +327,18 @@
   <data name="LaptopScreen" xml:space="preserve">
     <value>螢幕顯示</value>
   </data>
+  <data name="Lid" xml:space="preserve">
+    <value>螢幕背蓋</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>燈條</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>音效視覺化</value>
+  </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>横幅</value>
   </data>
@@ -318,8 +372,11 @@
   <data name="Multizone" xml:space="preserve">
     <value>多區域</value>
   </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>麥克風開關</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
-    <value>打開G-Helper視窗</value>
+    <value>開啟G-Helper視窗</value>
   </data>
   <data name="Optimized" xml:space="preserve">
     <value>自動模式</value>
@@ -327,6 +384,9 @@
   <data name="OptimizedGPUTooltip" xml:space="preserve">
     <value>使用電池切換到節能模式，插入電源時切換到標準模式</value>
   </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>自動模式下，使用USB-C充電時持續關閉獨顯</value>
+  </data>
   <data name="Other" xml:space="preserve">
     <value>其他</value>
   </data>
@@ -343,10 +403,10 @@
     <value>播放/暫停</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>功率限制 (PPT)</value>
+    <value>功率限制</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>功率限制 (PPT) 是實驗性功能。 謹慎使用，風險自負！</value>
+    <value>功率限制是實驗性功能。謹慎使用,風險自負!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>截圖</value>
@@ -354,6 +414,9 @@
   <data name="Quit" xml:space="preserve">
     <value>退出</value>
   </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>有其他程式正在使用獨顯導致無法切換至節能模式. 是否在裝置管理員中重啟獨顯? * 請自行評估風險</value>
+  </data>
   <data name="RPM" xml:space="preserve">
     <value>每分鐘轉數</value>
   </data>
@@ -364,7 +427,7 @@
     <value>關機時</value>
   </data>
   <data name="Silent" xml:space="preserve">
-    <value>安静模式</value>
+    <value>安靜模式</value>
   </data>
   <data name="Sleep" xml:space="preserve">
     <value>睡眠時</value>
@@ -381,6 +444,15 @@
   <data name="ToggleAura" xml:space="preserve">
     <value>切換Aura</value>
   </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>免按Fn鍵使用Fn+F1~F12功能</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>切換Miniled(若有支援)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>切換螢幕</value>
+  </data>
   <data name="Turbo" xml:space="preserve">
     <value>極速模式</value>
   </data>
@@ -396,13 +468,22 @@
   <data name="UltimateMode" xml:space="preserve">
     <value>獨顯直連</value>
   </data>
+  <data name="Updates" xml:space="preserve">
+    <value>更新驅動</value>
+  </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>版本</value>
   </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>音量降低</value>
+  </data>
   <data name="VolumeMute" xml:space="preserve">
     <value>靜音</value>
   </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>音量增加</value>
+  </data>
   <data name="WindowTop" xml:space="preserve">
     <value>視窗置頂</value>
   </data>
-</root>
+</root>

app/Ryzen/OpenLibSys.cs

@@ -0,0 +1,446 @@
+//-----------------------------------------------------------------------------
+//     Author : hiyohiyo
+//       Mail : hiyohiyo@crystalmark.info
+//        Web : http://openlibsys.org/
+//    License : The modified BSD license
+//
+//                     Copyright 2007-2009 OpenLibSys.org. All rights reserved.
+//-----------------------------------------------------------------------------
+// This is support library for WinRing0 1.3.x.
+
+using System.Runtime.InteropServices;
+
+namespace Ryzen
+{
+    public class Ols : IDisposable
+    {
+        const string dllNameX64 = "WinRing0x64.dll";
+        const string dllName = "WinRing0.dll";
+
+        // for this support library
+        public enum Status
+        {
+            NO_ERROR = 0,
+            DLL_NOT_FOUND = 1,
+            DLL_INCORRECT_VERSION = 2,
+            DLL_INITIALIZE_ERROR = 3,
+        }
+
+        // for WinRing0
+        public enum OlsDllStatus
+        {
+            OLS_DLL_NO_ERROR = 0,
+            OLS_DLL_UNSUPPORTED_PLATFORM = 1,
+            OLS_DLL_DRIVER_NOT_LOADED = 2,
+            OLS_DLL_DRIVER_NOT_FOUND = 3,
+            OLS_DLL_DRIVER_UNLOADED = 4,
+            OLS_DLL_DRIVER_NOT_LOADED_ON_NETWORK = 5,
+            OLS_DLL_UNKNOWN_ERROR = 9
+        }
+
+        // for WinRing0
+        public enum OlsDriverType
+        {
+            OLS_DRIVER_TYPE_UNKNOWN = 0,
+            OLS_DRIVER_TYPE_WIN_9X = 1,
+            OLS_DRIVER_TYPE_WIN_NT = 2,
+            OLS_DRIVER_TYPE_WIN_NT4 = 3,    // Obsolete
+            OLS_DRIVER_TYPE_WIN_NT_X64 = 4,
+            OLS_DRIVER_TYPE_WIN_NT_IA64 = 5
+        }
+
+        // for WinRing0
+        public enum OlsErrorPci : uint
+        {
+            OLS_ERROR_PCI_BUS_NOT_EXIST = 0xE0000001,
+            OLS_ERROR_PCI_NO_DEVICE = 0xE0000002,
+            OLS_ERROR_PCI_WRITE_CONFIG = 0xE0000003,
+            OLS_ERROR_PCI_READ_CONFIG = 0xE0000004
+        }
+
+        // Bus Number, Device Number and Function Number to PCI Device Address
+        public uint PciBusDevFunc(uint bus, uint dev, uint func)
+        {
+            return (bus & 0xFF) << 8 | (dev & 0x1F) << 3 | func & 7;
+        }
+
+        // PCI Device Address to Bus Number
+        public uint PciGetBus(uint address)
+        {
+            return address >> 8 & 0xFF;
+        }
+
+        // PCI Device Address to Device Number
+        public uint PciGetDev(uint address)
+        {
+            return address >> 3 & 0x1F;
+        }
+
+        // PCI Device Address to Function Number
+        public uint PciGetFunc(uint address)
+        {
+            return address & 7;
+        }
+
+        [DllImport("kernel32")]
+        public extern static nint LoadLibrary(string lpFileName);
+
+
+        [DllImport("kernel32", SetLastError = true)]
+        private static extern bool FreeLibrary(nint hModule);
+
+        [DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = false)]
+        private static extern nint GetProcAddress(nint hModule, [MarshalAs(UnmanagedType.LPStr)] string lpProcName);
+
+        private nint module = nint.Zero;
+        private uint status = (uint)Status.NO_ERROR;
+
+        public Ols()
+        {
+            string fileName;
+
+            if (nint.Size == 8)
+            {
+                fileName = dllNameX64;
+            }
+            else
+            {
+                fileName = dllName;
+            }
+
+            module = LoadLibrary(fileName);
+            if (module == nint.Zero)
+            {
+                status = (uint)Status.DLL_NOT_FOUND;
+            }
+            else
+            {
+
+                GetDllStatus = (_GetDllStatus)GetDelegate("GetDllStatus", typeof(_GetDllStatus));
+                GetDllVersion = (_GetDllVersion)GetDelegate("GetDllVersion", typeof(_GetDllVersion));
+                GetDriverVersion = (_GetDriverVersion)GetDelegate("GetDriverVersion", typeof(_GetDriverVersion));
+                GetDriverType = (_GetDriverType)GetDelegate("GetDriverType", typeof(_GetDriverType));
+
+                InitializeOls = (_InitializeOls)GetDelegate("InitializeOls", typeof(_InitializeOls));
+                DeinitializeOls = (_DeinitializeOls)GetDelegate("DeinitializeOls", typeof(_DeinitializeOls));
+
+                IsCpuid = (_IsCpuid)GetDelegate("IsCpuid", typeof(_IsCpuid));
+                IsMsr = (_IsMsr)GetDelegate("IsMsr", typeof(_IsMsr));
+                IsTsc = (_IsTsc)GetDelegate("IsTsc", typeof(_IsTsc));
+                Hlt = (_Hlt)GetDelegate("Hlt", typeof(_Hlt));
+                HltTx = (_HltTx)GetDelegate("HltTx", typeof(_HltTx));
+                HltPx = (_HltPx)GetDelegate("HltPx", typeof(_HltPx));
+                Rdmsr = (_Rdmsr)GetDelegate("Rdmsr", typeof(_Rdmsr));
+                RdmsrTx = (_RdmsrTx)GetDelegate("RdmsrTx", typeof(_RdmsrTx));
+                RdmsrPx = (_RdmsrPx)GetDelegate("RdmsrPx", typeof(_RdmsrPx));
+                Wrmsr = (_Wrmsr)GetDelegate("Wrmsr", typeof(_Wrmsr));
+                WrmsrTx = (_WrmsrTx)GetDelegate("WrmsrTx", typeof(_WrmsrTx));
+                WrmsrPx = (_WrmsrPx)GetDelegate("WrmsrPx", typeof(_WrmsrPx));
+                Rdpmc = (_Rdpmc)GetDelegate("Rdpmc", typeof(_Rdpmc));
+                RdpmcTx = (_RdpmcTx)GetDelegate("RdpmcTx", typeof(_RdpmcTx));
+                RdpmcPx = (_RdpmcPx)GetDelegate("RdpmcPx", typeof(_RdpmcPx));
+                Cpuid = (_Cpuid)GetDelegate("Cpuid", typeof(_Cpuid));
+                CpuidTx = (_CpuidTx)GetDelegate("CpuidTx", typeof(_CpuidTx));
+                CpuidPx = (_CpuidPx)GetDelegate("CpuidPx", typeof(_CpuidPx));
+                Rdtsc = (_Rdtsc)GetDelegate("Rdtsc", typeof(_Rdtsc));
+                RdtscTx = (_RdtscTx)GetDelegate("RdtscTx", typeof(_RdtscTx));
+                RdtscPx = (_RdtscPx)GetDelegate("RdtscPx", typeof(_RdtscPx));
+
+                ReadIoPortByte = (_ReadIoPortByte)GetDelegate("ReadIoPortByte", typeof(_ReadIoPortByte));
+                ReadIoPortWord = (_ReadIoPortWord)GetDelegate("ReadIoPortWord", typeof(_ReadIoPortWord));
+                ReadIoPortDword = (_ReadIoPortDword)GetDelegate("ReadIoPortDword", typeof(_ReadIoPortDword));
+                ReadIoPortByteEx = (_ReadIoPortByteEx)GetDelegate("ReadIoPortByteEx", typeof(_ReadIoPortByteEx));
+                ReadIoPortWordEx = (_ReadIoPortWordEx)GetDelegate("ReadIoPortWordEx", typeof(_ReadIoPortWordEx));
+                ReadIoPortDwordEx = (_ReadIoPortDwordEx)GetDelegate("ReadIoPortDwordEx", typeof(_ReadIoPortDwordEx));
+
+                WriteIoPortByte = (_WriteIoPortByte)GetDelegate("WriteIoPortByte", typeof(_WriteIoPortByte));
+                WriteIoPortWord = (_WriteIoPortWord)GetDelegate("WriteIoPortWord", typeof(_WriteIoPortWord));
+                WriteIoPortDword = (_WriteIoPortDword)GetDelegate("WriteIoPortDword", typeof(_WriteIoPortDword));
+                WriteIoPortByteEx = (_WriteIoPortByteEx)GetDelegate("WriteIoPortByteEx", typeof(_WriteIoPortByteEx));
+                WriteIoPortWordEx = (_WriteIoPortWordEx)GetDelegate("WriteIoPortWordEx", typeof(_WriteIoPortWordEx));
+                WriteIoPortDwordEx = (_WriteIoPortDwordEx)GetDelegate("WriteIoPortDwordEx", typeof(_WriteIoPortDwordEx));
+
+                SetPciMaxBusIndex = (_SetPciMaxBusIndex)GetDelegate("SetPciMaxBusIndex", typeof(_SetPciMaxBusIndex));
+                ReadPciConfigByte = (_ReadPciConfigByte)GetDelegate("ReadPciConfigByte", typeof(_ReadPciConfigByte));
+                ReadPciConfigWord = (_ReadPciConfigWord)GetDelegate("ReadPciConfigWord", typeof(_ReadPciConfigWord));
+                ReadPciConfigDword = (_ReadPciConfigDword)GetDelegate("ReadPciConfigDword", typeof(_ReadPciConfigDword));
+                ReadPciConfigByteEx = (_ReadPciConfigByteEx)GetDelegate("ReadPciConfigByteEx", typeof(_ReadPciConfigByteEx));
+                ReadPciConfigWordEx = (_ReadPciConfigWordEx)GetDelegate("ReadPciConfigWordEx", typeof(_ReadPciConfigWordEx));
+                ReadPciConfigDwordEx = (_ReadPciConfigDwordEx)GetDelegate("ReadPciConfigDwordEx", typeof(_ReadPciConfigDwordEx));
+                ReadPciConfigDwordEx64 = (_ReadPciConfigDwordEx64)GetDelegate("ReadPciConfigDwordEx", typeof(_ReadPciConfigDwordEx64));
+                WritePciConfigByte = (_WritePciConfigByte)GetDelegate("WritePciConfigByte", typeof(_WritePciConfigByte));
+                WritePciConfigWord = (_WritePciConfigWord)GetDelegate("WritePciConfigWord", typeof(_WritePciConfigWord));
+                WritePciConfigDword = (_WritePciConfigDword)GetDelegate("WritePciConfigDword", typeof(_WritePciConfigDword));
+                WritePciConfigByteEx = (_WritePciConfigByteEx)GetDelegate("WritePciConfigByteEx", typeof(_WritePciConfigByteEx));
+                WritePciConfigWordEx = (_WritePciConfigWordEx)GetDelegate("WritePciConfigWordEx", typeof(_WritePciConfigWordEx));
+                WritePciConfigDwordEx = (_WritePciConfigDwordEx)GetDelegate("WritePciConfigDwordEx", typeof(_WritePciConfigDwordEx));
+                WritePciConfigDwordEx64 = (_WritePciConfigDwordEx64)GetDelegate("WritePciConfigDwordEx", typeof(_WritePciConfigDwordEx64));
+                FindPciDeviceById = (_FindPciDeviceById)GetDelegate("FindPciDeviceById", typeof(_FindPciDeviceById));
+                FindPciDeviceByClass = (_FindPciDeviceByClass)GetDelegate("FindPciDeviceByClass", typeof(_FindPciDeviceByClass));
+
+                /*
+                ReadDmiMemory = (_ReadDmiMemory)GetDelegate("ReadDmiMemory", typeof(_ReadDmiMemory));
+                ReadPhysicalMemory = (_ReadPhysicalMemory)GetDelegate("ReadPhysicalMemory", typeof(_ReadPhysicalMemory));
+                WritePhysicalMemory = (_WritePhysicalMemory)GetDelegate("WritePhysicalMemory", typeof(_WritePhysicalMemory));
+				*/
+
+                if (!(
+                   GetDllStatus != null
+                && GetDllVersion != null
+                && GetDriverVersion != null
+                && GetDriverType != null
+                && InitializeOls != null
+                && DeinitializeOls != null
+                && IsCpuid != null
+                && IsMsr != null
+                && IsTsc != null
+                && Hlt != null
+                && HltTx != null
+                && HltPx != null
+                && Rdmsr != null
+                && RdmsrTx != null
+                && RdmsrPx != null
+                && Wrmsr != null
+                && WrmsrTx != null
+                && WrmsrPx != null
+                && Rdpmc != null
+                && RdpmcTx != null
+                && RdpmcPx != null
+                && Cpuid != null
+                && CpuidTx != null
+                && CpuidPx != null
+                && Rdtsc != null
+                && RdtscTx != null
+                && RdtscPx != null
+                && ReadIoPortByte != null
+                && ReadIoPortWord != null
+                && ReadIoPortDword != null
+                && ReadIoPortByteEx != null
+                && ReadIoPortWordEx != null
+                && ReadIoPortDwordEx != null
+                && WriteIoPortByte != null
+                && WriteIoPortWord != null
+                && WriteIoPortDword != null
+                && WriteIoPortByteEx != null
+                && WriteIoPortWordEx != null
+                && WriteIoPortDwordEx != null
+                && SetPciMaxBusIndex != null
+                && ReadPciConfigByte != null
+                && ReadPciConfigWord != null
+                && ReadPciConfigDword != null
+                && ReadPciConfigByteEx != null
+                && ReadPciConfigWordEx != null
+                && ReadPciConfigDwordEx != null
+                && ReadPciConfigDwordEx64 != null
+                && WritePciConfigByte != null
+                && WritePciConfigWord != null
+                && WritePciConfigDword != null
+                && WritePciConfigByteEx != null
+                && WritePciConfigWordEx != null
+                && WritePciConfigDwordEx != null
+                && WritePciConfigDwordEx64 != null
+                && FindPciDeviceById != null
+                && FindPciDeviceByClass != null
+                /*&& ReadDmiMemory != null
+                && ReadPhysicalMemory != null
+                && WritePhysicalMemory != null
+				*/
+                ))
+                {
+                    status = (uint)Status.DLL_INCORRECT_VERSION;
+                }
+
+                if (InitializeOls() == 0)
+                {
+                    status = (uint)Status.DLL_INITIALIZE_ERROR;
+                }
+            }
+        }
+
+        public uint GetStatus()
+        {
+            return status;
+        }
+
+        public void Dispose()
+        {
+            if (module != nint.Zero)
+            {
+                DeinitializeOls();
+                FreeLibrary(module);
+                module = nint.Zero;
+            }
+        }
+
+        public Delegate GetDelegate(string procName, Type delegateType)
+        {
+            nint ptr = GetProcAddress(module, procName);
+            if (ptr != nint.Zero)
+            {
+                Delegate d = Marshal.GetDelegateForFunctionPointer(ptr, delegateType);
+                return d;
+            }
+
+            int result = Marshal.GetHRForLastWin32Error();
+            throw Marshal.GetExceptionForHR(result);
+        }
+
+        //-----------------------------------------------------------------------------
+        // DLL Information
+        //-----------------------------------------------------------------------------
+        public delegate uint _GetDllStatus();
+        public delegate uint _GetDllVersion(ref byte major, ref byte minor, ref byte revision, ref byte release);
+        public delegate uint _GetDriverVersion(ref byte major, ref byte minor, ref byte revision, ref byte release);
+        public delegate uint _GetDriverType();
+
+        public delegate int _InitializeOls();
+        public delegate void _DeinitializeOls();
+
+        public _GetDllStatus GetDllStatus = null;
+        public _GetDriverType GetDriverType = null;
+        public _GetDllVersion GetDllVersion = null;
+        public _GetDriverVersion GetDriverVersion = null;
+
+        public _InitializeOls InitializeOls = null;
+        public _DeinitializeOls DeinitializeOls = null;
+
+        //-----------------------------------------------------------------------------
+        // CPU
+        //-----------------------------------------------------------------------------
+        public delegate int _IsCpuid();
+        public delegate int _IsMsr();
+        public delegate int _IsTsc();
+        public delegate int _Hlt();
+        public delegate int _HltTx(nuint threadAffinityMask);
+        public delegate int _HltPx(nuint processAffinityMask);
+        public delegate int _Rdmsr(uint index, ref uint eax, ref uint edx);
+        public delegate int _RdmsrTx(uint index, ref uint eax, ref uint edx, nuint threadAffinityMask);
+        public delegate int _RdmsrPx(uint index, ref uint eax, ref uint edx, nuint processAffinityMask);
+        public delegate int _Wrmsr(uint index, uint eax, uint edx);
+        public delegate int _WrmsrTx(uint index, uint eax, uint edx, nuint threadAffinityMask);
+        public delegate int _WrmsrPx(uint index, uint eax, uint edx, nuint processAffinityMask);
+        public delegate int _Rdpmc(uint index, ref uint eax, ref uint edx);
+        public delegate int _RdpmcTx(uint index, ref uint eax, ref uint edx, nuint threadAffinityMask);
+        public delegate int _RdpmcPx(uint index, ref uint eax, ref uint edx, nuint processAffinityMask);
+        public delegate int _Cpuid(uint index, ref uint eax, ref uint ebx, ref uint ecx, ref uint edx);
+        public delegate int _CpuidTx(uint index, ref uint eax, ref uint ebx, ref uint ecx, ref uint edx, nuint threadAffinityMask);
+        public delegate int _CpuidPx(uint index, ref uint eax, ref uint ebx, ref uint ecx, ref uint edx, nuint processAffinityMask);
+        public delegate int _Rdtsc(ref uint eax, ref uint edx);
+        public delegate int _RdtscTx(ref uint eax, ref uint edx, nuint threadAffinityMask);
+        public delegate int _RdtscPx(ref uint eax, ref uint edx, nuint processAffinityMask);
+
+        public _IsCpuid IsCpuid = null;
+        public _IsMsr IsMsr = null;
+        public _IsTsc IsTsc = null;
+        public _Hlt Hlt = null;
+        public _HltTx HltTx = null;
+        public _HltPx HltPx = null;
+        public _Rdmsr Rdmsr = null;
+        public _RdmsrTx RdmsrTx = null;
+        public _RdmsrPx RdmsrPx = null;
+        public _Wrmsr Wrmsr = null;
+        public _WrmsrTx WrmsrTx = null;
+        public _WrmsrPx WrmsrPx = null;
+        public _Rdpmc Rdpmc = null;
+        public _RdpmcTx RdpmcTx = null;
+        public _RdpmcPx RdpmcPx = null;
+        public _Cpuid Cpuid = null;
+        public _CpuidTx CpuidTx = null;
+        public _CpuidPx CpuidPx = null;
+        public _Rdtsc Rdtsc = null;
+        public _RdtscTx RdtscTx = null;
+        public _RdtscPx RdtscPx = null;
+
+        //-----------------------------------------------------------------------------
+        // I/O
+        //-----------------------------------------------------------------------------
+        public delegate byte _ReadIoPortByte(ushort port);
+        public delegate ushort _ReadIoPortWord(ushort port);
+        public delegate uint _ReadIoPortDword(ushort port);
+        public _ReadIoPortByte ReadIoPortByte;
+        public _ReadIoPortWord ReadIoPortWord;
+        public _ReadIoPortDword ReadIoPortDword;
+
+        public delegate int _ReadIoPortByteEx(ushort port, ref byte value);
+        public delegate int _ReadIoPortWordEx(ushort port, ref ushort value);
+        public delegate int _ReadIoPortDwordEx(ushort port, ref uint value);
+        public _ReadIoPortByteEx ReadIoPortByteEx;
+        public _ReadIoPortWordEx ReadIoPortWordEx;
+        public _ReadIoPortDwordEx ReadIoPortDwordEx;
+
+        public delegate void _WriteIoPortByte(ushort port, byte value);
+        public delegate void _WriteIoPortWord(ushort port, ushort value);
+        public delegate void _WriteIoPortDword(ushort port, uint value);
+        public _WriteIoPortByte WriteIoPortByte;
+        public _WriteIoPortWord WriteIoPortWord;
+        public _WriteIoPortDword WriteIoPortDword;
+
+        public delegate int _WriteIoPortByteEx(ushort port, byte value);
+        public delegate int _WriteIoPortWordEx(ushort port, ushort value);
+        public delegate int _WriteIoPortDwordEx(ushort port, uint value);
+        public _WriteIoPortByteEx WriteIoPortByteEx;
+        public _WriteIoPortWordEx WriteIoPortWordEx;
+        public _WriteIoPortDwordEx WriteIoPortDwordEx;
+
+        //-----------------------------------------------------------------------------
+        // PCI
+        //-----------------------------------------------------------------------------
+        public delegate void _SetPciMaxBusIndex(byte max);
+        public _SetPciMaxBusIndex SetPciMaxBusIndex;
+
+        public delegate byte _ReadPciConfigByte(uint pciAddress, byte regAddress);
+        public delegate ushort _ReadPciConfigWord(uint pciAddress, byte regAddress);
+        public delegate uint _ReadPciConfigDword(uint pciAddress, byte regAddress);
+        public _ReadPciConfigByte ReadPciConfigByte;
+        public _ReadPciConfigWord ReadPciConfigWord;
+        public _ReadPciConfigDword ReadPciConfigDword;
+
+        public delegate int _ReadPciConfigByteEx(uint pciAddress, uint regAddress, ref byte value);
+        public delegate int _ReadPciConfigWordEx(uint pciAddress, uint regAddress, ref ushort value);
+        public delegate int _ReadPciConfigDwordEx(uint pciAddress, uint regAddress, ref uint value);
+        public _ReadPciConfigByteEx ReadPciConfigByteEx;
+        public _ReadPciConfigWordEx ReadPciConfigWordEx;
+        public _ReadPciConfigDwordEx ReadPciConfigDwordEx;
+
+
+        public delegate int _ReadPciConfigDwordEx64(uint pciAddress, uint regAddress, ref ulong value);
+        public _ReadPciConfigDwordEx64 ReadPciConfigDwordEx64;
+
+        public delegate void _WritePciConfigByte(uint pciAddress, byte regAddress, byte value);
+        public delegate void _WritePciConfigWord(uint pciAddress, byte regAddress, ushort value);
+        public delegate void _WritePciConfigDword(uint pciAddress, byte regAddress, uint value);
+        public _WritePciConfigByte WritePciConfigByte;
+        public _WritePciConfigWord WritePciConfigWord;
+        public _WritePciConfigDword WritePciConfigDword;
+
+        public delegate int _WritePciConfigByteEx(uint pciAddress, uint regAddress, byte value);
+        public delegate int _WritePciConfigWordEx(uint pciAddress, uint regAddress, ushort value);
+        public delegate int _WritePciConfigDwordEx(uint pciAddress, uint regAddress, uint value);
+        public _WritePciConfigByteEx WritePciConfigByteEx;
+        public _WritePciConfigWordEx WritePciConfigWordEx;
+        public _WritePciConfigDwordEx WritePciConfigDwordEx;
+
+        public delegate int _WritePciConfigDwordEx64(uint pciAddress, uint regAddress, ulong value);
+        public _WritePciConfigDwordEx64 WritePciConfigDwordEx64;
+
+        public delegate uint _FindPciDeviceById(ushort vendorId, ushort deviceId, byte index);
+        public delegate uint _FindPciDeviceByClass(byte baseClass, byte subClass, byte programIf, byte index);
+        public _FindPciDeviceById FindPciDeviceById;
+        public _FindPciDeviceByClass FindPciDeviceByClass;
+
+        //-----------------------------------------------------------------------------
+        // Physical Memory (unsafe)
+        //-----------------------------------------------------------------------------
+
+        /*public unsafe delegate uint _ReadDmiMemory(byte* buffer, uint count, uint unitSize);
+        public _ReadDmiMemory ReadDmiMemory;
+
+        public unsafe delegate uint _ReadPhysicalMemory(UIntPtr address, byte* buffer, uint count, uint unitSize);
+        public unsafe delegate uint _WritePhysicalMemory(UIntPtr address, byte* buffer, uint count, uint unitSize);
+
+        public _ReadPhysicalMemory ReadPhysicalMemory;
+        public _WritePhysicalMemory WritePhysicalMemory;
+		*/
+    }
+}
+

app/Ryzen/RyzenControl.cs

@@ -0,0 +1,212 @@
+//
+// This is a optimised/simplified version of Ryzen System Management Unit from https://github.com/JamesCJ60/Universal-x86-Tuning-Utility
+// I do not take credit for the full functionality of the code (c)
+//
+
+
+using System.Management;
+
+namespace Ryzen
+{
+    internal class RyzenControl
+    {
+
+        public const int MinCPUUV = -30;
+        public const int MaxCPUUV = 0;
+
+        public const int MinIGPUUV = -20;
+        public const int MaxIGPUUV = 0;
+
+        public const int MinTemp = 75;
+        public const int MaxTemp = 98;
+
+        public static string[] FAM = { "RAVEN", "PICASSO", "DALI", "RENOIR/LUCIENNE", "MATISSE", "VANGOGH", "VERMEER", "CEZANNE/BARCELO", "REMBRANDT", "PHOENIX", "RAPHAEL/DRAGON RANGE" };
+        public static int FAMID { get; protected set; }
+
+        public static string CPUModel = "";
+        public static string CPUName = "";
+
+        //Zen1/+ - -1
+        //RAVEN - 0
+        //PICASSO - 1
+        //DALI - 2
+        //RENOIR/LUCIENNE - 3
+        //MATISSE - 4
+        //VANGOGH - 5
+        //VERMEER - 6
+        //CEZANNE/BARCELO - 7
+        //REMBRANDT - 8
+        //PHEONIX - 9
+        //RAPHAEL/DRAGON RANGE - 10
+        //MENDOCINO - 11
+
+        public static void Init()
+        {
+            //Get CPU name
+
+            try
+            {
+                ManagementObjectSearcher myProcessorObject = new ManagementObjectSearcher("select * from Win32_Processor");
+                foreach (ManagementObject obj in myProcessorObject.Get())
+                {
+                    CPUName = obj["Name"].ToString();
+                    CPUModel = obj["Caption"].ToString();
+                }
+            } catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
+
+            FAMID = 99999;
+
+            if (CPUModel.Contains("Model " + Convert.ToString(1)) || CPUModel.Contains("Model " + Convert.ToString(8)))
+            {
+                FAMID = -1; //Zen1/+ DT
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(17)))
+            {
+                FAMID = 0; //RAVEN
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(24)))
+            {
+                FAMID = 1; //PICASSO
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(32)))
+            {
+                FAMID = 2; //DALI
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(33)))
+            {
+                FAMID = 6; //VERMEER
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(96)) || CPUModel.Contains("Model " + Convert.ToString(104)))
+            {
+                FAMID = 3; //RENOIR/LUCIENNE
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(144)))
+            {
+                FAMID = 5; //VANGOGH
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(80)))
+            {
+                FAMID = 7; //CEZANNE/BARCELO
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(64)) || CPUModel.Contains("Model " + Convert.ToString(68)))
+            {
+                FAMID = 8; //REMBRANDT
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(116)))
+            {
+                FAMID = 9; //PHEONIX 
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(97)))
+            {
+                FAMID = 10; //RAPHAEL/DRAGON RANGE
+            }
+
+            if (CPUModel.Contains("Model " + Convert.ToString(160)))
+            {
+                FAMID = 11; //MENDOCINO 
+            }
+
+            Logger.WriteLine($"CPU: {FAMID} - {CPUName} - {CPUModel}");
+
+            SetAddresses();
+        }
+
+        public static bool IsAMD()
+        {
+            if (CPUName.Length == 0) Init();
+            return CPUName.Contains("AMD") || CPUName.Contains("Ryzen") || CPUName.Contains("Athlon") || CPUName.Contains("Radeon") || CPUName.Contains("AMD Custom APU 0405");
+        }
+
+        public static bool IsRyzen9()
+        {
+            if (CPUName.Length == 0) Init();
+            return CPUName.Contains("Ryzen 9");
+        }
+
+        public static void SetAddresses()
+        {
+
+            Smu.SMU_PCI_ADDR = 0x00000000;
+            Smu.SMU_OFFSET_ADDR = 0xB8;
+            Smu.SMU_OFFSET_DATA = 0xBC;
+
+            if (FAMID == -1)
+            {
+                Smu.MP1_ADDR_MSG = 0X3B10528;
+                Smu.MP1_ADDR_RSP = 0X3B10564;
+                Smu.MP1_ADDR_ARG = 0X3B10598;
+
+                Smu.PSMU_ADDR_MSG = 0x3B1051C;
+                Smu.PSMU_ADDR_RSP = 0X3B10568;
+                Smu.PSMU_ADDR_ARG = 0X3B10590;
+            }
+
+
+            if (FAMID == 0 || FAMID == 1 || FAMID == 2 || FAMID == 3 || FAMID == 7)
+            {
+                Smu.MP1_ADDR_MSG = 0x3B10528;
+                Smu.MP1_ADDR_RSP = 0x3B10564;
+                Smu.MP1_ADDR_ARG = 0x3B10998;
+
+                Smu.PSMU_ADDR_MSG = 0x3B10A20;
+                Smu.PSMU_ADDR_RSP = 0x3B10A80;
+                Smu.PSMU_ADDR_ARG = 0x3B10A88;
+            }
+            else if (FAMID == 5 || FAMID == 8 || FAMID == 9 || FAMID == 11)
+            {
+                Smu.MP1_ADDR_MSG = 0x3B10528;
+                Smu.MP1_ADDR_RSP = 0x3B10578;
+                Smu.MP1_ADDR_ARG = 0x3B10998;
+
+                Smu.PSMU_ADDR_MSG = 0x3B10a20;
+                Smu.PSMU_ADDR_RSP = 0x3B10a80;
+                Smu.PSMU_ADDR_ARG = 0x3B10a88;
+            }
+            else if (FAMID == 4 || FAMID == 6)
+            {
+                Smu.MP1_ADDR_MSG = 0x3B10530;
+                Smu.MP1_ADDR_RSP = 0x3B1057C;
+                Smu.MP1_ADDR_ARG = 0x3B109C4;
+
+                Smu.PSMU_ADDR_MSG = 0x3B10524;
+                Smu.PSMU_ADDR_RSP = 0x3B10570;
+                Smu.PSMU_ADDR_ARG = 0x3B10A40;
+            }
+            else if (FAMID == 10)
+            {
+                Smu.MP1_ADDR_MSG = 0x3010508;
+                Smu.MP1_ADDR_RSP = 0x3010988;
+                Smu.MP1_ADDR_ARG = 0x3010984;
+
+                Smu.PSMU_ADDR_MSG = 0x3B10524;
+                Smu.PSMU_ADDR_RSP = 0x3B10570;
+                Smu.PSMU_ADDR_ARG = 0x3B10A40;
+            }
+            else
+            {
+                Smu.MP1_ADDR_MSG = 0;
+                Smu.MP1_ADDR_RSP = 0;
+                Smu.MP1_ADDR_ARG = 0;
+
+                Smu.PSMU_ADDR_MSG = 0;
+                Smu.PSMU_ADDR_RSP = 0;
+                Smu.PSMU_ADDR_ARG = 0;
+            }
+
+
+        }
+    }
+}

app/Ryzen/RyzenSmu.cs

@@ -0,0 +1,243 @@
+//
+// This is a optimised/simplified version of Ryzen System Management Unit from https://github.com/JamesCJ60/Universal-x86-Tuning-Utility
+// I do not take credit for the full functionality of the code (c)
+//
+
+[assembly: CLSCompliant(false)]
+
+
+namespace Ryzen
+{
+    class Smu
+    {
+
+        public enum Status : int
+        {
+            BAD = 0x0,
+            OK = 0x1,
+            FAILED = 0xFF,
+            UNKNOWN_CMD = 0xFE,
+            CMD_REJECTED_PREREQ = 0xFD,
+            CMD_REJECTED_BUSY = 0xFC
+        }
+
+        private static readonly Dictionary<Status, string> status = new Dictionary<Status, string>()
+        {
+            { Status.BAD, "BAD" },
+            { Status.OK, "OK" },
+            { Status.FAILED, "Failed" },
+            { Status.UNKNOWN_CMD, "Unknown Command" },
+            { Status.CMD_REJECTED_PREREQ, "CMD Rejected Prereq" },
+            { Status.CMD_REJECTED_BUSY, "CMD Rejected Busy" }
+        };
+
+
+
+        Ols RyzenNbAccesss;
+
+
+        public Smu(bool EnableDebug)
+        {
+            ShowDebug = EnableDebug;
+            RyzenNbAccesss = new Ols();
+
+            // Check WinRing0 status
+            switch (RyzenNbAccesss.GetDllStatus())
+            {
+                case (uint)Ols.OlsDllStatus.OLS_DLL_NO_ERROR:
+                    if (ShowDebug)
+                    {
+                        //MessageBox.Show("Ols Dll is OK.", "Ols.OlsDllStatus:");
+                    }
+                    break;
+                case (uint)Ols.OlsDllStatus.OLS_DLL_DRIVER_NOT_LOADED:
+                    //MessageBox.Show("WinRing OLS_DRIVER_NOT_LOADED", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing OLS_DRIVER_NOT_LOADED");
+
+                case (uint)Ols.OlsDllStatus.OLS_DLL_UNSUPPORTED_PLATFORM:
+                    //MessageBox.Show("WinRing OLS_UNSUPPORTED_PLATFORM", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing OLS_UNSUPPORTED_PLATFORM");
+
+                case (uint)Ols.OlsDllStatus.OLS_DLL_DRIVER_NOT_FOUND:
+                    //MessageBox.Show("WinRing OLS_DLL_DRIVER_NOT_FOUND", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing OLS_DLL_DRIVER_NOT_FOUND");
+
+                case (uint)Ols.OlsDllStatus.OLS_DLL_DRIVER_UNLOADED:
+                    //MessageBox.Show("WinRing OLS_DLL_DRIVER_UNLOADED", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing OLS_DLL_DRIVER_UNLOADED");
+
+                case (uint)Ols.OlsDllStatus.OLS_DLL_DRIVER_NOT_LOADED_ON_NETWORK:
+                    //MessageBox.Show("WinRing DRIVER_NOT_LOADED_ON_NETWORK", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing DRIVER_NOT_LOADED_ON_NETWORK");
+
+                case (uint)Ols.OlsDllStatus.OLS_DLL_UNKNOWN_ERROR:
+                    //MessageBox.Show("WinRing OLS_DLL_UNKNOWN_ERROR", "Ols.OlsDllStatus:");
+                    throw new ApplicationException("WinRing OLS_DLL_UNKNOWN_ERROR");
+            }
+
+        }
+
+        public void Initialize()
+        {
+            amdSmuMutex = new Mutex();
+            RyzenNbAccesss.InitializeOls();
+
+            // Check WinRing0 status
+            switch (RyzenNbAccesss.GetStatus())
+            {
+                case (uint)Ols.Status.NO_ERROR:
+                    if (ShowDebug)
+                    {
+                        //MessageBox.Show("Ols is OK.", "Ols.Status:");
+                        ShowDebug = false;
+                    }
+                    break;
+                case (uint)Ols.Status.DLL_NOT_FOUND:
+                    //MessageBox.Show("WinRing Status: DLL_NOT_FOUND", "Ols.Status:");
+                    throw new ApplicationException("WinRing DLL_NOT_FOUND");
+                    break;
+                case (uint)Ols.Status.DLL_INCORRECT_VERSION:
+                    //MessageBox.Show("WinRing Status: DLL_INCORRECT_VERSION", "Ols.Status:");
+                    throw new ApplicationException("WinRing DLL_INCORRECT_VERSION");
+                    break;
+                case (uint)Ols.Status.DLL_INITIALIZE_ERROR:
+                    //MessageBox.Show("WinRing Status: DLL_INITIALIZE_ERROR", "Ols.Status:");
+                    throw new ApplicationException("WinRing DLL_INITIALIZE_ERROR");
+                    break;
+                default:
+                    break;
+            }
+        }
+
+
+        public void Deinitialize()
+        {
+            RyzenNbAccesss.DeinitializeOls();
+        }
+
+        public static uint SMU_PCI_ADDR { get; set; }
+        public static uint SMU_OFFSET_ADDR { get; set; }
+        public static uint SMU_OFFSET_DATA { get; set; }
+
+        public static uint MP1_ADDR_MSG { get; set; }
+        public static uint MP1_ADDR_RSP { get; set; }
+        public static uint MP1_ADDR_ARG { get; set; }
+
+        public static uint PSMU_ADDR_MSG { get; set; }
+        public static uint PSMU_ADDR_RSP { get; set; }
+        public static uint PSMU_ADDR_ARG { get; set; }
+        public static uint[] args { get; set; }
+
+        public bool ShowDebug { get; set; }
+
+        private static Mutex amdSmuMutex;
+        private const ushort SMU_TIMEOUT = 8192;
+
+        public Status SendMp1(uint message, ref uint[] arguments)
+        {
+            var result = SendMsg(MP1_ADDR_MSG, MP1_ADDR_RSP, MP1_ADDR_ARG, message, ref arguments);
+            //Logger.WriteLine($"RyzenMP1:{message} {arguments[0]} {result}");
+            return result;
+        }
+
+        public Status SendPsmu(uint message, ref uint[] arguments)
+        {
+            var result =  SendMsg(PSMU_ADDR_MSG, PSMU_ADDR_RSP, PSMU_ADDR_ARG, message, ref arguments);
+            //Logger.WriteLine($"RyzenPSMU:{message} {arguments[0]} {result}");
+            return result;
+        }
+
+
+        public Status SendMsg(uint SMU_ADDR_MSG, uint SMU_ADDR_RSP, uint SMU_ADDR_ARG, uint msg, ref uint[] args)
+        {
+            ushort timeout = SMU_TIMEOUT;
+            uint[] cmdArgs = new uint[6];
+            int argsLength = args.Length;
+            uint status = 0;
+
+            if (argsLength > cmdArgs.Length)
+                argsLength = cmdArgs.Length;
+
+            for (int i = 0; i < argsLength; ++i)
+                cmdArgs[i] = args[i];
+
+            if (amdSmuMutex.WaitOne(5000))
+            {
+                // Clear response register
+                bool temp;
+                do
+                    temp = SmuWriteReg(SMU_ADDR_RSP, 0);
+                while (!temp && --timeout > 0);
+
+                if (timeout == 0)
+                {
+                    amdSmuMutex.ReleaseMutex();
+                    SmuReadReg(SMU_ADDR_RSP, ref status);
+                    return (Status)status;
+                }
+
+                // Write data
+                for (int i = 0; i < cmdArgs.Length; ++i)
+                    SmuWriteReg(SMU_ADDR_ARG + (uint)(i * 4), cmdArgs[i]);
+
+                // Send message
+                SmuWriteReg(SMU_ADDR_MSG, msg);
+
+                // Wait done
+                if (!SmuWaitDone(SMU_ADDR_RSP))
+                {
+                    amdSmuMutex.ReleaseMutex();
+                    SmuReadReg(SMU_ADDR_RSP, ref status);
+                    return (Status)status;
+                }
+
+                // Read back args
+                for (int i = 0; i < args.Length; ++i)
+                    SmuReadReg(SMU_ADDR_ARG + (uint)(i * 4), ref args[i]);
+            }
+
+            amdSmuMutex.ReleaseMutex();
+            SmuReadReg(SMU_ADDR_RSP, ref status);
+
+            return (Status)status;
+        }
+
+
+        public bool SmuWaitDone(uint SMU_ADDR_RSP)
+        {
+            bool res;
+            ushort timeout = SMU_TIMEOUT;
+            uint data = 0;
+
+            do
+                res = SmuReadReg(SMU_ADDR_RSP, ref data);
+            while ((!res || data != 1) && --timeout > 0);
+
+            if (timeout == 0 || data != 1) res = false;
+
+            return res;
+        }
+
+
+        private bool SmuWriteReg(uint addr, uint data)
+        {
+            if (RyzenNbAccesss.WritePciConfigDwordEx(SMU_PCI_ADDR, SMU_OFFSET_ADDR, addr) == 1)
+            {
+                return RyzenNbAccesss.WritePciConfigDwordEx(SMU_PCI_ADDR, SMU_OFFSET_DATA, data) == 1;
+            }
+            return false;
+        }
+
+        private bool SmuReadReg(uint addr, ref uint data)
+        {
+            if (RyzenNbAccesss.WritePciConfigDwordEx(SMU_PCI_ADDR, SMU_OFFSET_ADDR, addr) == 1)
+            {
+                return RyzenNbAccesss.ReadPciConfigDwordEx(SMU_PCI_ADDR, SMU_OFFSET_DATA, ref data) == 1;
+            }
+            return false;
+        }
+
+
+
+    }
+}

app/Settings.resx

@@ -1,4 +1,64 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">

app/ToastForm.cs

@@ -1,94 +0,0 @@
-using System.Drawing.Drawing2D;
-using OSD;
-
-
-namespace GHelper
-{
-
-    static class Drawing
-    {
-
-        public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
-        {
-            int diameter = radius * 2;
-            Size size = new Size(diameter, diameter);
-            Rectangle arc = new Rectangle(bounds.Location, size);
-            GraphicsPath path = new GraphicsPath();
-
-            if (radius == 0)
-            {
-                path.AddRectangle(bounds);
-                return path;
-            }
-
-            path.AddArc(arc, 180, 90);
-            arc.X = bounds.Right - diameter;
-            path.AddArc(arc, 270, 90);
-            arc.Y = bounds.Bottom - diameter;
-            path.AddArc(arc, 0, 90);
-            arc.X = bounds.Left;
-            path.AddArc(arc, 90, 90);
-            path.CloseFigure();
-            return path;
-        }
-
-        public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
-        {
-            using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
-            {
-                graphics.FillPath(brush, path);
-            }
-        }
-    }
-
-    class  ToastForm : OSDNativeForm
-    {
-
-        protected static string toastText = "Balanced";
-        protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
-
-        protected override void PerformPaint(PaintEventArgs e)
-        {
-            Brush brush = new SolidBrush(Color.FromArgb(150,Color.Black));
-            Drawing.FillRoundedRectangle(e.Graphics, brush, this.Bound, 10);
-
-            StringFormat format = new StringFormat();
-            format.LineAlignment = StringAlignment.Center;
-            format.Alignment = StringAlignment.Center;
-
-            e.Graphics.DrawString(toastText, 
-                new Font("Segoe UI", 16f, FontStyle.Bold), 
-                new SolidBrush(Color.White), 
-                new PointF(this.Bound.Width/2, this.Bound.Height / 2), 
-                format);
-        }
-
-        public void RunToast(string text)
-        {
-
-            toastText = text;
-            Screen screen1 = Screen.FromHandle(base.Handle);
-
-            Width = 300;
-            Height = 100;
-            X = (screen1.Bounds.Width - this.Width)/2;
-            Y = screen1.Bounds.Height - 300 - this.Height;
-
-            Show();
-
-            timer.Stop();
-            timer.Tick -= timer_Tick;
-
-            timer.Tick += timer_Tick;
-            timer.Enabled = true;
-            timer.Interval = 2000;
-            timer.Start();
-        }
-
-        private void timer_Tick(object? sender, EventArgs e)
-        {
-            timer.Stop();
-            Hide();
-        }
-    }
-}

app/UI/ControlHelper.cs

@@ -1,5 +1,4 @@
-using CustomControls;
-using WinFormsSliderBar;
+using GHelper.UI;
 using System.Drawing.Drawing2D;
 using System.Windows.Forms.DataVisualization.Charting;
 
@@ -86,13 +85,13 @@ public static class ControlHelper
             }
 
             var sl = control as Slider;
-            if (sl != null) 
+            if (sl != null)
             {
                 sl.borderColor = RForm.buttonMain;
             }
 
             var chk = control as CheckBox;
-            if (chk != null && chk.Padding.Left > 5)
+            if (chk != null && chk.Padding.Right > 5)
             {
                 chk.BackColor = RForm.buttonSecond;
             }

app/UI/CustomContextMenu.cs

@@ -0,0 +1,35 @@
+using System.Runtime.InteropServices;
+
+namespace GHelper.UI
+{
+    class CustomContextMenu : ContextMenuStrip
+    {
+        [DllImport("dwmapi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern long DwmSetWindowAttribute(nint hwnd,
+                                                            DWMWINDOWATTRIBUTE attribute,
+                                                            ref DWM_WINDOW_CORNER_PREFERENCE pvAttribute,
+                                                            uint cbAttribute);
+
+        public CustomContextMenu()
+        {
+            var preference = DWM_WINDOW_CORNER_PREFERENCE.DWMWCP_ROUNDSMALL;     //change as you want
+            DwmSetWindowAttribute(Handle,
+                                  DWMWINDOWATTRIBUTE.DWMWA_WINDOW_CORNER_PREFERENCE,
+                                  ref preference,
+                                  sizeof(uint));
+        }
+
+        public enum DWMWINDOWATTRIBUTE
+        {
+            DWMWA_WINDOW_CORNER_PREFERENCE = 33
+        }
+        public enum DWM_WINDOW_CORNER_PREFERENCE
+        {
+            DWMWA_DEFAULT = 0,
+            DWMWCP_DONOTROUND = 1,
+            DWMWCP_ROUND = 2,
+            DWMWCP_ROUNDSMALL = 3,
+        }
+    }
+
+}

app/UI/CustomControls.cs

@@ -3,7 +3,7 @@ using System.ComponentModel;
 using System.Drawing.Drawing2D;
 using System.Runtime.InteropServices;
 
-namespace CustomControls
+namespace GHelper.UI
 {
 
     public class RForm : Form
@@ -12,6 +12,8 @@ namespace CustomControls
         public static Color colorEco = Color.FromArgb(255, 6, 180, 138);
         public static Color colorStandard = Color.FromArgb(255, 58, 174, 239);
         public static Color colorTurbo = Color.FromArgb(255, 255, 32, 32);
+        public static Color colorCustom = Color.FromArgb(255, 255, 128, 0);
+
 
         public static Color buttonMain;
         public static Color buttonSecond;
@@ -26,7 +28,7 @@ namespace CustomControls
         public static extern bool CheckSystemDarkModeStatus();
 
         [DllImport("DwmApi")] //System.Runtime.InteropServices
-        private static extern int DwmSetWindowAttribute(IntPtr hwnd, int attr, int[] attrValue, int attrSize);
+        private static extern int DwmSetWindowAttribute(nint hwnd, int attr, int[] attrValue, int attrSize);
 
         public bool darkTheme = false;
 
@@ -70,7 +72,7 @@ namespace CustomControls
         public bool InitTheme(bool setDPI = false)
         {
             bool newDarkTheme = CheckSystemDarkModeStatus();
-            bool changed = (darkTheme != newDarkTheme);
+            bool changed = darkTheme != newDarkTheme;
             darkTheme = newDarkTheme;
 
             InitColors(darkTheme);
@@ -80,7 +82,7 @@ namespace CustomControls
 
             if (changed)
             {
-                DwmSetWindowAttribute(this.Handle, 20, new[] { darkTheme ? 1 : 0 }, 4);
+                DwmSetWindowAttribute(Handle, 20, new[] { darkTheme ? 1 : 0 }, 4);
                 ControlHelper.Adjust(this, changed);
             }
 
@@ -97,7 +99,7 @@ namespace CustomControls
     }
 
 
-        public class RComboBox : ComboBox
+    public class RComboBox : ComboBox
     {
         private Color borderColor = Color.Gray;
         [DefaultValue(typeof(Color), "Gray")]
@@ -180,8 +182,8 @@ namespace CustomControls
                 };
                 var ps = new PAINTSTRUCT();
                 bool shoulEndPaint = false;
-                IntPtr dc;
-                if (m.WParam == IntPtr.Zero)
+                nint dc;
+                if (m.WParam == nint.Zero)
                 {
                     dc = BeginPaint(Handle, ref ps);
                     m.WParam = dc;
@@ -194,7 +196,7 @@ namespace CustomControls
 
                 var rgn = CreateRectRgn(innerInnerBorder.Left, innerInnerBorder.Top,
                     innerInnerBorder.Right, innerInnerBorder.Bottom);
-                
+
                 SelectClipRgn(dc, rgn);
                 DefWndProc(ref m);
                 DeleteObject(rgn);
@@ -238,7 +240,7 @@ namespace CustomControls
         [StructLayout(LayoutKind.Sequential)]
         public struct PAINTSTRUCT
         {
-            public IntPtr hdc;
+            public nint hdc;
             public bool fErase;
             public int rcPaint_left;
             public int rcPaint_top;
@@ -256,17 +258,17 @@ namespace CustomControls
             public int reserved8;
         }
         [DllImport("user32.dll")]
-        private static extern IntPtr BeginPaint(IntPtr hWnd,
+        private static extern nint BeginPaint(nint hWnd,
             [In, Out] ref PAINTSTRUCT lpPaint);
 
         [DllImport("user32.dll")]
-        private static extern bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT lpPaint);
+        private static extern bool EndPaint(nint hWnd, ref PAINTSTRUCT lpPaint);
 
         [DllImport("gdi32.dll")]
-        public static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
+        public static extern int SelectClipRgn(nint hDC, nint hRgn);
 
         [DllImport("user32.dll")]
-        public static extern int GetUpdateRgn(IntPtr hwnd, IntPtr hrgn, bool fErase);
+        public static extern int GetUpdateRgn(nint hwnd, nint hrgn, bool fErase);
         public enum RegionFlags
         {
             ERROR = 0,
@@ -275,10 +277,10 @@ namespace CustomControls
             COMPLEXREGION = 3,
         }
         [DllImport("gdi32.dll")]
-        internal static extern bool DeleteObject(IntPtr hObject);
+        internal static extern bool DeleteObject(nint hObject);
 
         [DllImport("gdi32.dll")]
-        private static extern IntPtr CreateRectRgn(int x1, int y1, int x2, int y2);
+        private static extern nint CreateRectRgn(int x1, int y1, int x2, int y2);
     }
 
     public class RButton : Button
@@ -314,7 +316,7 @@ namespace CustomControls
             set
             {
                 if (activated != value)
-                    this.Invalidate();
+                    Invalidate();
                 activated = value;
 
             }
@@ -332,8 +334,9 @@ namespace CustomControls
 
         public RButton()
         {
-            this.FlatStyle = FlatStyle.Flat;
-            this.FlatAppearance.BorderSize = 0;
+            DoubleBuffered = true;
+            FlatStyle = FlatStyle.Flat;
+            FlatAppearance.BorderSize = 0;
         }
 
         private GraphicsPath GetFigurePath(Rectangle rect, int radius)
@@ -359,19 +362,19 @@ namespace CustomControls
             float ratio = pevent.Graphics.DpiX / 192.0f;
             int border = (int)(ratio * borderSize);
 
-            Rectangle rectSurface = this.ClientRectangle;
+            Rectangle rectSurface = ClientRectangle;
             Rectangle rectBorder = Rectangle.Inflate(rectSurface, -border, -border);
 
             Color borderDrawColor = activated ? borderColor : Color.Transparent;
 
             using (GraphicsPath pathSurface = GetFigurePath(rectSurface, borderRadius + border))
             using (GraphicsPath pathBorder = GetFigurePath(rectBorder, borderRadius))
-            using (Pen penSurface = new Pen(this.Parent.BackColor, border))
+            using (Pen penSurface = new Pen(Parent.BackColor, border))
             using (Pen penBorder = new Pen(borderDrawColor, border))
             {
                 penBorder.Alignment = PenAlignment.Outset;
                 pevent.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
-                this.Region = new Region(pathSurface);
+                Region = new Region(pathSurface);
                 pevent.Graphics.DrawPath(penSurface, pathSurface);
                 pevent.Graphics.DrawPath(penBorder, pathBorder);
             }
@@ -385,7 +388,7 @@ namespace CustomControls
                     rect.Height -= Image.Height;
                 }
                 TextFormatFlags flags = TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.WordBreak;
-                TextRenderer.DrawText(pevent.Graphics, this.Text, this.Font, rect, Color.Gray, flags);
+                TextRenderer.DrawText(pevent.Graphics, Text, Font, rect, Color.Gray, flags);
             }
 
 

app/UI/Slider.cs

@@ -1,6 +1,6 @@
 using System.Drawing.Drawing2D;
 
-namespace WinFormsSliderBar
+namespace GHelper.UI
 {
     public static class GraphicsExtensions
     {
@@ -106,7 +106,7 @@ namespace WinFormsSliderBar
         private void RecalculateParameters()
         {
             _radius = 0.4F * ClientSize.Height;
-            _barSize = new SizeF(ClientSize.Width - 4 * _radius, ClientSize.Height * 0.15F);
+            _barSize = new SizeF(ClientSize.Width - 2 * _radius, ClientSize.Height * 0.15F);
             _barPos = new PointF(_radius, (ClientSize.Height - _barSize.Height) / 2);
             _thumbPos = new PointF(
                 _barSize.Width / (Max - Min) * (Value - Min) + _barPos.X,

app/Updates.Designer.cs

@@ -0,0 +1,250 @@
+using GHelper.UI;
+
+namespace GHelper
+{
+    partial class Updates
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Updates));
+            tableBios = new TableLayoutPanel();
+            labelBIOS = new Label();
+            pictureBios = new PictureBox();
+            panelBiosTitle = new Panel();
+            labelUpdates = new Label();
+            buttonRefresh = new RButton();
+            panelBios = new Panel();
+            panelDrivers = new Panel();
+            tableDrivers = new TableLayoutPanel();
+            panelDriversTitle = new Panel();
+            labelDrivers = new Label();
+            pictureDrivers = new PictureBox();
+            ((System.ComponentModel.ISupportInitialize)pictureBios).BeginInit();
+            panelBiosTitle.SuspendLayout();
+            panelBios.SuspendLayout();
+            panelDrivers.SuspendLayout();
+            panelDriversTitle.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureDrivers).BeginInit();
+            SuspendLayout();
+            // 
+            // tableBios
+            // 
+            tableBios.AutoSize = true;
+            tableBios.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            tableBios.ColumnCount = 3;
+            tableBios.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBios.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
+            tableBios.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBios.Dock = DockStyle.Top;
+            tableBios.Location = new Point(20, 20);
+            tableBios.Margin = new Padding(4);
+            tableBios.MinimumSize = new Size(1100, 0);
+            tableBios.Name = "tableBios";
+            tableBios.Size = new Size(1216, 0);
+            tableBios.TabIndex = 0;
+            // 
+            // labelBIOS
+            // 
+            labelBIOS.AutoSize = true;
+            labelBIOS.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelBIOS.Location = new Point(68, 23);
+            labelBIOS.Margin = new Padding(4, 0, 4, 0);
+            labelBIOS.Name = "labelBIOS";
+            labelBIOS.Size = new Size(68, 32);
+            labelBIOS.TabIndex = 1;
+            labelBIOS.Text = "BIOS";
+            // 
+            // pictureBios
+            // 
+            pictureBios.BackgroundImage = (Image)resources.GetObject("pictureBios.BackgroundImage");
+            pictureBios.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureBios.Location = new Point(28, 23);
+            pictureBios.Margin = new Padding(4);
+            pictureBios.Name = "pictureBios";
+            pictureBios.Size = new Size(32, 32);
+            pictureBios.TabIndex = 2;
+            pictureBios.TabStop = false;
+            // 
+            // panelBiosTitle
+            // 
+            panelBiosTitle.Controls.Add(labelUpdates);
+            panelBiosTitle.Controls.Add(buttonRefresh);
+            panelBiosTitle.Controls.Add(labelBIOS);
+            panelBiosTitle.Controls.Add(pictureBios);
+            panelBiosTitle.Dock = DockStyle.Top;
+            panelBiosTitle.Location = new Point(0, 0);
+            panelBiosTitle.Margin = new Padding(4);
+            panelBiosTitle.Name = "panelBiosTitle";
+            panelBiosTitle.Size = new Size(1256, 62);
+            panelBiosTitle.TabIndex = 3;
+            // 
+            // labelUpdates
+            // 
+            labelUpdates.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelUpdates.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelUpdates.Location = new Point(941, 23);
+            labelUpdates.Name = "labelUpdates";
+            labelUpdates.Size = new Size(245, 32);
+            labelUpdates.TabIndex = 4;
+            labelUpdates.Text = "Updates Available";
+            // 
+            // buttonRefresh
+            // 
+            buttonRefresh.Activated = false;
+            buttonRefresh.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            buttonRefresh.BackColor = SystemColors.ControlLight;
+            buttonRefresh.BorderColor = Color.Transparent;
+            buttonRefresh.BorderRadius = 5;
+            buttonRefresh.FlatAppearance.BorderSize = 0;
+            buttonRefresh.FlatStyle = FlatStyle.Flat;
+            buttonRefresh.Image = Properties.Resources.icons8_refresh_32;
+            buttonRefresh.Location = new Point(1183, 14);
+            buttonRefresh.Name = "buttonRefresh";
+            buttonRefresh.Secondary = true;
+            buttonRefresh.Size = new Size(52, 46);
+            buttonRefresh.TabIndex = 3;
+            buttonRefresh.UseVisualStyleBackColor = false;
+            // 
+            // panelBios
+            // 
+            panelBios.AutoSize = true;
+            panelBios.Controls.Add(tableBios);
+            panelBios.Dock = DockStyle.Top;
+            panelBios.Location = new Point(0, 62);
+            panelBios.Margin = new Padding(4);
+            panelBios.Name = "panelBios";
+            panelBios.Padding = new Padding(20);
+            panelBios.Size = new Size(1256, 40);
+            panelBios.TabIndex = 4;
+            // 
+            // panelDrivers
+            // 
+            panelDrivers.AutoSize = true;
+            panelDrivers.Controls.Add(tableDrivers);
+            panelDrivers.Dock = DockStyle.Top;
+            panelDrivers.Location = new Point(0, 146);
+            panelDrivers.Margin = new Padding(4);
+            panelDrivers.Name = "panelDrivers";
+            panelDrivers.Padding = new Padding(20);
+            panelDrivers.Size = new Size(1256, 40);
+            panelDrivers.TabIndex = 6;
+            // 
+            // tableDrivers
+            // 
+            tableDrivers.AutoSize = true;
+            tableDrivers.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            tableDrivers.ColumnCount = 3;
+            tableDrivers.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableDrivers.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
+            tableDrivers.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableDrivers.Dock = DockStyle.Top;
+            tableDrivers.Location = new Point(20, 20);
+            tableDrivers.Margin = new Padding(4);
+            tableDrivers.MinimumSize = new Size(1100, 0);
+            tableDrivers.Name = "tableDrivers";
+            tableDrivers.Size = new Size(1216, 0);
+            tableDrivers.TabIndex = 0;
+            // 
+            // panelDriversTitle
+            // 
+            panelDriversTitle.Controls.Add(labelDrivers);
+            panelDriversTitle.Controls.Add(pictureDrivers);
+            panelDriversTitle.Dock = DockStyle.Top;
+            panelDriversTitle.Location = new Point(0, 102);
+            panelDriversTitle.Margin = new Padding(4);
+            panelDriversTitle.Name = "panelDriversTitle";
+            panelDriversTitle.Size = new Size(1256, 44);
+            panelDriversTitle.TabIndex = 5;
+            // 
+            // labelDrivers
+            // 
+            labelDrivers.AutoSize = true;
+            labelDrivers.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelDrivers.Location = new Point(68, 6);
+            labelDrivers.Margin = new Padding(4, 0, 4, 0);
+            labelDrivers.Name = "labelDrivers";
+            labelDrivers.Size = new Size(254, 32);
+            labelDrivers.TabIndex = 1;
+            labelDrivers.Text = "Drivers and Software";
+            // 
+            // pictureDrivers
+            // 
+            pictureDrivers.BackgroundImage = (Image)resources.GetObject("pictureDrivers.BackgroundImage");
+            pictureDrivers.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureDrivers.Location = new Point(28, 6);
+            pictureDrivers.Margin = new Padding(4);
+            pictureDrivers.Name = "pictureDrivers";
+            pictureDrivers.Size = new Size(32, 32);
+            pictureDrivers.TabIndex = 2;
+            pictureDrivers.TabStop = false;
+            // 
+            // Updates
+            // 
+            AutoScaleDimensions = new SizeF(192F, 192F);
+            AutoScaleMode = AutoScaleMode.Dpi;
+            AutoScroll = true;
+            ClientSize = new Size(1256, 690);
+            Controls.Add(panelDrivers);
+            Controls.Add(panelDriversTitle);
+            Controls.Add(panelBios);
+            Controls.Add(panelBiosTitle);
+            Margin = new Padding(4);
+            MinimizeBox = false;
+            Name = "Updates";
+            ShowIcon = false;
+            ShowInTaskbar = false;
+            Text = "BIOS and Driver Updates";
+            ((System.ComponentModel.ISupportInitialize)pictureBios).EndInit();
+            panelBiosTitle.ResumeLayout(false);
+            panelBiosTitle.PerformLayout();
+            panelBios.ResumeLayout(false);
+            panelBios.PerformLayout();
+            panelDrivers.ResumeLayout(false);
+            panelDrivers.PerformLayout();
+            panelDriversTitle.ResumeLayout(false);
+            panelDriversTitle.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureDrivers).EndInit();
+            ResumeLayout(false);
+            PerformLayout();
+        }
+
+        #endregion
+
+        private TableLayoutPanel tableBios;
+        private Label labelBIOS;
+        private PictureBox pictureBios;
+        private Panel panelBiosTitle;
+        private Panel panelBios;
+        private Panel panelDrivers;
+        private TableLayoutPanel tableDrivers;
+        private Panel panelDriversTitle;
+        private Label labelDrivers;
+        private PictureBox pictureDrivers;
+        private RButton buttonRefresh;
+        private Label labelUpdates;
+    }
+}