Merge pull request #391 from seerge/revert-385-windows-power-plan-changes-optional

Revert "Adjustment of Windows Power Overlay is now optional"

.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/ISSUE_TEMPLATE/bug_report.md

@@ -4,6 +4,12 @@ about: Create a report to help us improve
 
 ---
 
+
+## NOTE
+Bug reports without clear information or scenario to reproduce and logs from ``%AppData%\GHelper`` will be closed without answer. 
+Please respect time of the developer. Thanks.
+
+
 **Describe the bug**
 A clear and concise description of what the bug is.
 
@@ -34,7 +40,3 @@ If applicable, add screenshots to help explain your problem.
 
 **Additional context**
 Add any other context about the problem here.
-
-## NOTE
-Bug reports without clear information or scenario to reproduce will be closed without answer. 
-Please respect time of the developer. Thanks.

.github/ISSUE_TEMPLATE/custom.md

@@ -1,10 +0,0 @@
----
-name: Custom issue template
-about: Describe this issue template's purpose here.
-title: ''
-labels: ''
-assignees: ''
-
----
-
-

app/ASUSWmi.cs

@@ -1,4 +1,6 @@
-using System.Management;
+using System.Globalization;
+using System.IO.Pipes;
+using System.Management;
 using System.Runtime.InteropServices;
 
 public class ASUSWmi
@@ -13,6 +15,12 @@ public class ASUSWmi
     public const uint UniversalControl = 0x00100021;
     public const int KB_Light_Up = 0xc4;
     public const int KB_Light_Down = 0xc5;
+    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;
@@ -21,6 +29,8 @@ public class ASUSWmi
     public const uint PerformanceMode = 0x00120075; // Thermal Control
 
     public const uint GPUEco = 0x00090020;
+    public const uint GPUXGConnected = 0x00090018;
+    public const uint GPUXG = 0x00090019;
     public const uint GPUMux = 0x00090016;
 
     public const uint BatteryLimit = 0x00120057;
@@ -34,21 +44,29 @@ 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 and CPU PPT on 2021
+    public const int PPT_TotalA0 = 0x001200A0;  // Total PPT on 2022 (PPT_LIMIT_SLOW ) and CPU PPT on 2021
     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_CPUB0 = 0x001200B0;  // CPU PPT on 2022
-    public const int PPT_CPUB1 = 0x001200B1;  // APU PPT on 2022
+    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_APUC1 = 0x001200C1;
-    public const int PPT_APUC2 = 0x001200C2;
+    public const int PPT_GPUC0 = 0x001200C0;  // NVIDIA GPU Boost
+    public const int PPT_APUC1 = 0x001200C1;  // Actual Power Limit (PPT_LIMIT_FAST) AND Sustained Power Limit (STAPM_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 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;
@@ -58,14 +76,20 @@ public class ASUSWmi
     public const int GPUModeUltimate = 2;
 
 
-    public const int MaxTotal = 150;
+    public const int MaxTotal = 250;
     public const int MinTotal = 5;
     public const int DefaultTotal = 125;
 
-    public const int MaxCPU = 90;
+    public const int MaxCPU = 130;
     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(
@@ -190,7 +214,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;
 
     }
@@ -200,10 +224,24 @@ 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;
+
+        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(int device, byte[] curve)
     {
@@ -214,9 +252,7 @@ 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)
         {
@@ -258,11 +294,58 @@ public class ASUSWmi
 
     }
 
+
+    public static bool IsEmptyCurve(byte[] curve) {
+        return curve.Length != 16 || 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 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)
     {
 
         byte[] setting = new byte[12];
-        setting[0] = (byte)1;
+        setting[0] = (byte)0xB4;
         setting[1] = (byte)mode;
         setting[2] = color.R;
         setting[3] = color.G;
@@ -301,10 +384,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/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,6 +90,8 @@ 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;
@@ -107,15 +110,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 +187,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 +201,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 +225,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 +242,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,11 +344,17 @@ 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 = "")
@@ -380,17 +366,17 @@ namespace Starlight.AnimeMatrix
                     g.CompositingQuality = CompositingQuality.HighQuality;
                     g.SmoothingMode = SmoothingMode.AntiAlias;
 
-                    using (Font font = new Font("Arial", 12F))
+                    using (Font font = new Font("Consolas", 24F, FontStyle.Regular, GraphicsUnit.Pixel))
                     {
                         SizeF textSize = g.MeasureString(text1, font);
-                        g.DrawString(text1, font, Brushes.White, (MaxColumns*3 - textSize.Width)+3, -5);
+                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
                     }
 
                     if (text2.Length > 0)
-                        using (Font font = new Font("Arial", 9F))
+                        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 +390,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 +417,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 +428,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,4 +1,5 @@
-using System.Management;
+using System.Diagnostics;
+using System.Management;
 using System.Text.Json;
 
 public class AppConfig
@@ -91,14 +92,27 @@ public class AppConfig
     {
         config[name] = value;
         string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(configFile, jsonString);
+        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 });
-        File.WriteAllText(configFile, jsonString);
+        try
+        {
+            File.WriteAllText(configFile, jsonString);
+        }
+        catch (Exception e)
+        {
+            Debug.Write(e.ToString());
+        }
     }
 
     public string getParamName(int device, string paramName = "fan_profile")
@@ -172,6 +186,12 @@ public class AppConfig
         return curve;
     }
 
+    public string getConfigPerfString(string name)
+    {
+        int mode = getConfig("performance_mode");
+        return getConfigString(name + "_" + mode);
+    }
+
     public int getConfigPerf(string name)
     {
         int mode = getConfig("performance_mode");

app/Aura.cs

@@ -1,8 +1,6 @@
 using HidLibrary;
-using System.Data;
+using Microsoft.Win32;
 using System.Diagnostics;
-using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;
-using System.Security.Policy;
 
 namespace GHelper
 {
@@ -57,7 +55,7 @@ namespace GHelper
         static byte[] MESSAGE_SET = { 0x5d, 0xb5, 0, 0, 0 };
         static byte[] MESSAGE_APPLY = { 0x5d, 0xb4 };
 
-        static int[] deviceIds = { 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0 };
+        static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6 };
 
         private static int mode = 0;
         private static int speed = 1;
@@ -69,33 +67,33 @@ namespace GHelper
         {
             return new Dictionary<int, string>
             {
-                { 0, "Slow" },
-                { 1, "Normal" },
-                { 2, "Fast" }
+                { 0, Properties.Strings.AuraSlow },
+                { 1, Properties.Strings.AuraNormal },
+                { 2, Properties.Strings.AuraFast }
             };
         }
 
-        static  Dictionary<int, string> _modes = new Dictionary<int, string>
+        static Dictionary<int, string> _modes = new Dictionary<int, string>
             {
-                { 0, "Static" },
-                { 1, "Breathe" },
-                { 2, "Color Cycle" },
-                { 3, "Rainbow" },
-                { 10, "Strobe" },
+                { 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, "Static" },
-                { 1, "Breathe" },
-                { 2, "Color Cycle" },
-                { 3, "Rainbow" },
+                { 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, "Strobe" },
+                { 10, Properties.Strings.AuraStrobe},
                 { 11, "Comet" },
                 { 12, "Flash" },
             };
@@ -163,6 +161,17 @@ namespace GHelper
             Color2 = Color.FromArgb(colorCode);
         }
 
+
+        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minInput = 18)
+        {
+            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
+            foreach (HidDevice device in HidDeviceList)
+                if (device.IsConnected
+                    && device.Capabilities.FeatureReportByteLength > 0
+                    && device.Capabilities.InputReportByteLength >= minInput) // 
+                    yield return device;
+        }
+
         public static byte[] AuraMessage(int mode, Color color, Color color2, int speed)
         {
 
@@ -185,54 +194,70 @@ namespace GHelper
 
         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();
-                }
+            var devices = GetHidDevices(deviceIds);
+            //Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
 
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                device.Write(msg);
+                Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                device.CloseDevice();
+            }
+
+            if (Program.config.ContainsModel("TUF"))
+                Program.wmi.TUFKeyboardBrightness(brightness);
         }
 
 
-        public static void ApplyAuraPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
+        public static void ApplyAuraPower(List<AuraDev19b6> flags)
         {
-            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();
-                }
+            var devices = GetHidDevices(deviceIds);
+            //Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                device.Write(msg);
+                Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                device.CloseDevice();
+            }
 
             if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardPower(awake, boot, sleep, shutdown);
+                Program.wmi.TUFKeyboardPower(
+                    flags.Contains(AuraDev19b6.AwakeKeyb),
+                    flags.Contains(AuraDev19b6.BootKeyb),
+                    flags.Contains(AuraDev19b6.SleepKeyb),
+                    flags.Contains(AuraDev19b6.ShutdownKeyb));
 
         }
 
+        public static void ApplyXGMLight(bool status)
+        {
+            byte value = status ? (byte)0x50 : (byte)0;
+            var msg = new byte[] { 0x5e, 0xc5, value };
+
+            foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }))
+            {
+                device.OpenDevice();
+                var message = new byte[300];
+                Array.Copy(msg, message, msg.Length);
+                Debug.WriteLine(BitConverter.ToString(message));
+                device.WriteFeatureData(message);
+                device.CloseDevice();
+            }
+        }
+
+
         public static void ApplyAura()
         {
 
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
-
             int _speed;
 
             switch (Speed)
@@ -248,22 +273,48 @@ namespace GHelper
                     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();
-                }
+
+            var devices = GetHidDevices(deviceIds);
+            if (devices.Count() == 0)
+            {
+                Logger.WriteLine("USB-KB : not found");
+                GetHidDevices(deviceIds, 0);
+            }
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                device.Write(msg);
+                device.Write(MESSAGE_SET);
+                device.Write(MESSAGE_APPLY);
+                device.CloseDevice();
+                Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+            }
 
             if (Program.config.ContainsModel("TUF"))
                 Program.wmi.TUFKeyboardRGB(Mode, Color1, _speed);
 
         }
+
+        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);
+            }
+        }
+
+
     }
 
 }

app/ControlHelper.cs

@@ -1,50 +1,19 @@
 using CustomControls;
-using WinFormsSliderBar;
 using System.Drawing.Drawing2D;
 using System.Windows.Forms.DataVisualization.Charting;
+using WinFormsSliderBar;
 
 public static class ControlHelper
 {
 
     static bool _invert = false;
-    static bool _darkTheme = false;
-
-
     static float _scale = 1;
 
-    static Color formBack;
-    static Color backMain;
-    static Color foreMain;
-    static Color foreAccent;
-    static Color borderMain;
-    static Color buttonMain;
-
-    public static void Adjust(RForm container, bool darkTheme = false, bool invert = false)
+    public static void Adjust(RForm container, bool invert = false)
     {
 
-        _darkTheme = darkTheme;
-
-        if (darkTheme)
-        {
-            formBack = Color.FromArgb(255, 35, 35, 35);
-            backMain = Color.FromArgb(255, 50, 50, 50);
-            foreMain = Color.FromArgb(255, 240, 240, 240);
-            foreAccent = Color.FromArgb(255, 100, 100, 100);
-            borderMain = Color.FromArgb(255, 50, 50, 50);
-            buttonMain = Color.FromArgb(255, 80, 80, 80);
-        }
-        else
-        {
-            formBack = SystemColors.Control;
-            backMain = SystemColors.ControlLightLight;
-            foreMain = SystemColors.ControlText;
-            foreAccent = Color.LightGray;
-            borderMain = Color.LightGray;
-            buttonMain = Color.FromArgb(255, 230, 230, 230);
-        }
-
-        container.BackColor = formBack;
-        container.ForeColor = foreMain;
+        container.BackColor = RForm.formBack;
+        container.ForeColor = RForm.foreMain;
 
         _invert = invert;
         AdjustControls(container.Controls);
@@ -85,11 +54,11 @@ public static class ControlHelper
             var button = control as RButton;
             if (button != null)
             {
-                button.BackColor = button.Secondary ? buttonMain : backMain;
-                button.ForeColor = foreMain;
+                button.BackColor = button.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+                button.ForeColor = RForm.foreMain;
 
                 button.FlatStyle = FlatStyle.Flat;
-                button.FlatAppearance.BorderColor = borderMain;
+                button.FlatAppearance.BorderColor = RForm.borderMain;
 
                 if (button.Image is not null)
                     button.Image = AdjustImage(button.Image);
@@ -103,46 +72,52 @@ public static class ControlHelper
             var combo = control as RComboBox;
             if (combo != null)
             {
-                combo.BackColor = backMain;
-                combo.ForeColor = foreMain;
-                combo.BorderColor = backMain;
-                combo.ButtonColor = backMain;
-                combo.ArrowColor = foreMain;
+                combo.BackColor = RForm.buttonMain;
+                combo.ForeColor = RForm.foreMain;
+                combo.BorderColor = RForm.buttonMain;
+                combo.ButtonColor = RForm.buttonMain;
+                combo.ArrowColor = RForm.foreMain;
             }
 
             var gb = control as GroupBox;
             if (gb != null)
             {
-                gb.ForeColor = foreMain;
+                gb.ForeColor = RForm.foreMain;
             }
 
             var sl = control as Slider;
             if (sl != null)
             {
-                sl.borderColor = buttonMain;
+                sl.borderColor = RForm.buttonMain;
+            }
+
+            var chk = control as CheckBox;
+            if (chk != null && chk.Padding.Right > 5)
+            {
+                chk.BackColor = RForm.buttonSecond;
             }
 
             var chart = control as Chart;
             if (chart != null)
             {
-                chart.BackColor = backMain;
-                chart.ChartAreas[0].BackColor = backMain;
+                chart.BackColor = RForm.chartMain;
+                chart.ChartAreas[0].BackColor = RForm.chartMain;
 
-                chart.ChartAreas[0].AxisX.TitleForeColor = foreMain;
-                chart.ChartAreas[0].AxisY.TitleForeColor = foreMain;
+                chart.ChartAreas[0].AxisX.TitleForeColor = RForm.foreMain;
+                chart.ChartAreas[0].AxisY.TitleForeColor = RForm.foreMain;
 
-                chart.ChartAreas[0].AxisX.LabelStyle.ForeColor = foreMain;
-                chart.ChartAreas[0].AxisY.LabelStyle.ForeColor = foreMain;
+                chart.ChartAreas[0].AxisX.LabelStyle.ForeColor = RForm.foreMain;
+                chart.ChartAreas[0].AxisY.LabelStyle.ForeColor = RForm.foreMain;
 
-                chart.ChartAreas[0].AxisX.MajorTickMark.LineColor = foreMain;
-                chart.ChartAreas[0].AxisY.MajorTickMark.LineColor = foreMain;
+                chart.ChartAreas[0].AxisX.MajorTickMark.LineColor = RForm.foreMain;
+                chart.ChartAreas[0].AxisY.MajorTickMark.LineColor = RForm.foreMain;
 
-                chart.ChartAreas[0].AxisX.MajorGrid.LineColor = foreAccent;
-                chart.ChartAreas[0].AxisY.MajorGrid.LineColor = foreAccent;
-                chart.ChartAreas[0].AxisX.LineColor = foreAccent;
-                chart.ChartAreas[0].AxisY.LineColor = foreAccent;
+                chart.ChartAreas[0].AxisX.MajorGrid.LineColor = RForm.chartGrid;
+                chart.ChartAreas[0].AxisY.MajorGrid.LineColor = RForm.chartGrid;
+                chart.ChartAreas[0].AxisX.LineColor = RForm.chartGrid;
+                chart.ChartAreas[0].AxisY.LineColor = RForm.chartGrid;
 
-                chart.Titles[0].ForeColor = foreMain;
+                chart.Titles[0].ForeColor = RForm.foreMain;
 
             }
 

app/CustomContextMenu.cs

@@ -0,0 +1,35 @@
+using System.Runtime.InteropServices;
+
+namespace GHelper
+{
+    class CustomContextMenu : ContextMenuStrip
+    {
+        [DllImport("dwmapi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern long DwmSetWindowAttribute(IntPtr 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/CustomControls.cs

@@ -1,6 +1,5 @@
 using Microsoft.Win32;
 using System.ComponentModel;
-using System.Diagnostics;
 using System.Drawing.Drawing2D;
 using System.Runtime.InteropServices;
 
@@ -10,9 +9,18 @@ namespace CustomControls
     public class RForm : Form
     {
 
-        protected static Color colorEco = Color.FromArgb(255, 6, 180, 138);
-        protected static Color colorStandard = Color.FromArgb(255, 58, 174, 239);
-        protected static Color colorTurbo = Color.FromArgb(255, 255, 32, 32);
+        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 buttonMain;
+        public static Color buttonSecond;
+
+        public static Color formBack;
+        public static Color foreMain;
+        public static Color borderMain;
+        public static Color chartMain;
+        public static Color chartGrid;
 
         [DllImport("UXTheme.dll", SetLastError = true, EntryPoint = "#138")]
         public static extern bool CheckSystemDarkModeStatus();
@@ -20,7 +28,40 @@ namespace CustomControls
         [DllImport("DwmApi")] //System.Runtime.InteropServices
         private static extern int DwmSetWindowAttribute(IntPtr hwnd, int attr, int[] attrValue, int attrSize);
 
-        public bool darkTheme;
+        public bool darkTheme = false;
+
+        public RForm()
+        {
+            DoubleBuffered = true;
+        }
+
+        public static void InitColors(bool darkTheme)
+        {
+            if (darkTheme)
+            {
+                buttonMain = Color.FromArgb(255, 55, 55, 55);
+                buttonSecond = Color.FromArgb(255, 38, 38, 38);
+
+                formBack = Color.FromArgb(255, 28, 28, 28);
+                foreMain = Color.FromArgb(255, 240, 240, 240);
+                borderMain = Color.FromArgb(255, 50, 50, 50);
+
+                chartMain = Color.FromArgb(255, 35, 35, 35);
+                chartGrid = Color.FromArgb(255, 70, 70, 70);
+            }
+            else
+            {
+                buttonMain = SystemColors.ControlLightLight;
+                buttonSecond = SystemColors.ControlLight;
+
+                formBack = SystemColors.Control;
+                foreMain = SystemColors.ControlText;
+                borderMain = Color.LightGray;
+
+                chartMain = SystemColors.ControlLightLight;
+                chartGrid = Color.LightGray;
+            }
+        }
 
         private static bool IsDarkTheme()
         {
@@ -37,13 +78,15 @@ namespace CustomControls
             bool changed = (darkTheme != newDarkTheme);
             darkTheme = newDarkTheme;
 
+            InitColors(darkTheme);
+
             if (setDPI)
                 ControlHelper.Resize(this);
 
             if (changed)
             {
                 DwmSetWindowAttribute(this.Handle, 20, new[] { darkTheme ? 1 : 0 }, 4);
-                ControlHelper.Adjust(this, darkTheme, changed);
+                ControlHelper.Adjust(this, changed);
             }
 
             return changed;
@@ -53,6 +96,12 @@ namespace CustomControls
     }
 
 
+    public class RCheckBox : CheckBox
+    {
+
+    }
+
+
     public class RComboBox : ComboBox
     {
         private Color borderColor = Color.Gray;
@@ -147,8 +196,10 @@ namespace CustomControls
                 {
                     dc = m.WParam;
                 }
+
                 var rgn = CreateRectRgn(innerInnerBorder.Left, innerInnerBorder.Top,
                     innerInnerBorder.Right, innerInnerBorder.Bottom);
+                
                 SelectClipRgn(dc, rgn);
                 DefWndProc(ref m);
                 DeleteObject(rgn);
@@ -286,8 +337,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)

app/Extra.Designer.cs

@@ -0,0 +1,718 @@
+using CustomControls;
+using GHelper.Properties;
+
+namespace GHelper
+{
+    partial class Extra
+    {
+        /// <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()
+        {
+            groupBindings = new GroupBox();
+            pictureHelp = new PictureBox();
+            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();
+            panelBacklightExtra = new Panel();
+            numericBacklightTime = new NumericUpDown();
+            labelBacklightTimeout = new Label();
+            labelBrightness = new Label();
+            trackBrightness = new TrackBar();
+            labelSpeed = new Label();
+            comboKeyboardSpeed = new RComboBox();
+            panelXMG = new Panel();
+            checkXMG = new CheckBox();
+            tableBacklight = new TableLayoutPanel();
+            labelBacklight = new Label();
+            checkAwake = new CheckBox();
+            checkBoot = new CheckBox();
+            checkSleep = new CheckBox();
+            checkShutdown = new CheckBox();
+            labelBacklightLogo = new Label();
+            checkAwakeLogo = new CheckBox();
+            checkBootLogo = new CheckBox();
+            checkSleepLogo = new CheckBox();
+            checkShutdownLogo = new CheckBox();
+            labelBacklightBar = new Label();
+            checkAwakeBar = new CheckBox();
+            checkBootBar = new CheckBox();
+            checkSleepBar = new CheckBox();
+            checkShutdownBar = new CheckBox();
+            labelBacklightLid = new Label();
+            checkAwakeLid = new CheckBox();
+            checkBootLid = new CheckBox();
+            checkSleepLid = new CheckBox();
+            checkShutdownLid = new CheckBox();
+            groupOther = new GroupBox();
+            checkKeyboardAuto = new CheckBox();
+            checkUSBC = new CheckBox();
+            checkNoOverdrive = new CheckBox();
+            checkTopmost = new CheckBox();
+            groupBindings.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureHelp).BeginInit();
+            groupLight.SuspendLayout();
+            panelBacklightExtra.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)numericBacklightTime).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)trackBrightness).BeginInit();
+            panelXMG.SuspendLayout();
+            tableBacklight.SuspendLayout();
+            groupOther.SuspendLayout();
+            SuspendLayout();
+            // 
+            // groupBindings
+            // 
+            groupBindings.Controls.Add(pictureHelp);
+            groupBindings.Controls.Add(textFNF4);
+            groupBindings.Controls.Add(comboFNF4);
+            groupBindings.Controls.Add(labelFNF4);
+            groupBindings.Controls.Add(textM4);
+            groupBindings.Controls.Add(textM3);
+            groupBindings.Controls.Add(comboM4);
+            groupBindings.Controls.Add(labelM4);
+            groupBindings.Controls.Add(comboM3);
+            groupBindings.Controls.Add(labelM3);
+            groupBindings.Dock = DockStyle.Top;
+            groupBindings.Location = new Point(10, 10);
+            groupBindings.Name = "groupBindings";
+            groupBindings.Size = new Size(954, 242);
+            groupBindings.TabIndex = 0;
+            groupBindings.TabStop = false;
+            groupBindings.Text = "Key Bindings";
+            // 
+            // pictureHelp
+            // 
+            pictureHelp.BackgroundImage = Resources.icons8_help_64;
+            pictureHelp.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureHelp.Cursor = Cursors.Hand;
+            pictureHelp.Location = new Point(884, 58);
+            pictureHelp.Name = "pictureHelp";
+            pictureHelp.Size = new Size(32, 32);
+            pictureHelp.TabIndex = 9;
+            pictureHelp.TabStop = false;
+            // 
+            // textFNF4
+            // 
+            textFNF4.Location = new Point(415, 176);
+            textFNF4.Name = "textFNF4";
+            textFNF4.PlaceholderText = "action";
+            textFNF4.Size = new Size(448, 39);
+            textFNF4.TabIndex = 8;
+            // 
+            // comboFNF4
+            // 
+            comboFNF4.BorderColor = Color.White;
+            comboFNF4.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboFNF4.FormattingEnabled = true;
+            comboFNF4.Location = new Point(93, 175);
+            comboFNF4.Name = "comboFNF4";
+            comboFNF4.Size = new Size(312, 40);
+            comboFNF4.TabIndex = 7;
+            // 
+            // 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(448, 39);
+            textM4.TabIndex = 5;
+            // 
+            // textM3
+            // 
+            textM3.Location = new Point(415, 54);
+            textM3.Name = "textM3";
+            textM3.PlaceholderText = "notepad /p \"file.txt\"";
+            textM3.Size = new Size(448, 39);
+            textM3.TabIndex = 4;
+            // 
+            // comboM4
+            // 
+            comboM4.BorderColor = Color.White;
+            comboM4.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboM4.FormattingEnabled = true;
+            comboM4.Items.AddRange(new object[] { Strings.PerformanceMode, Strings.OpenGHelper, Strings.Custom });
+            comboM4.Location = new Point(93, 112);
+            comboM4.Name = "comboM4";
+            comboM4.Size = new Size(312, 40);
+            comboM4.TabIndex = 3;
+            // 
+            // 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.BorderColor = Color.White;
+            comboM3.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboM3.FormattingEnabled = true;
+            comboM3.Items.AddRange(new object[] { Strings.Default, Strings.VolumeMute, Strings.PlayPause, Strings.PrintScreen, Strings.ToggleAura, Strings.Custom });
+            comboM3.Location = new Point(93, 54);
+            comboM3.Name = "comboM3";
+            comboM3.Size = new Size(312, 40);
+            comboM3.TabIndex = 1;
+            // 
+            // 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.AutoSize = true;
+            groupLight.Controls.Add(panelBacklightExtra);
+            groupLight.Controls.Add(panelXMG);
+            groupLight.Controls.Add(tableBacklight);
+            groupLight.Dock = DockStyle.Top;
+            groupLight.Location = new Point(10, 252);
+            groupLight.Name = "groupLight";
+            groupLight.Size = new Size(954, 516);
+            groupLight.TabIndex = 1;
+            groupLight.TabStop = false;
+            groupLight.Text = "Keyboard Backlight";
+            // 
+            // panelBacklightExtra
+            // 
+            panelBacklightExtra.Controls.Add(numericBacklightTime);
+            panelBacklightExtra.Controls.Add(labelBacklightTimeout);
+            panelBacklightExtra.Controls.Add(labelBrightness);
+            panelBacklightExtra.Controls.Add(trackBrightness);
+            panelBacklightExtra.Controls.Add(labelSpeed);
+            panelBacklightExtra.Controls.Add(comboKeyboardSpeed);
+            panelBacklightExtra.Dock = DockStyle.Top;
+            panelBacklightExtra.Location = new Point(3, 319);
+            panelBacklightExtra.Name = "panelBacklightExtra";
+            panelBacklightExtra.Size = new Size(948, 194);
+            panelBacklightExtra.TabIndex = 43;
+            // 
+            // numericBacklightTime
+            // 
+            numericBacklightTime.Location = new Point(477, 131);
+            numericBacklightTime.Maximum = new decimal(new int[] { 3600, 0, 0, 0 });
+            numericBacklightTime.Name = "numericBacklightTime";
+            numericBacklightTime.Size = new Size(240, 39);
+            numericBacklightTime.TabIndex = 47;
+            // 
+            // labelBacklightTimeout
+            // 
+            labelBacklightTimeout.Location = new Point(13, 133);
+            labelBacklightTimeout.Name = "labelBacklightTimeout";
+            labelBacklightTimeout.Size = new Size(489, 45);
+            labelBacklightTimeout.TabIndex = 46;
+            labelBacklightTimeout.Text = "Seconds to turn off backlight on battery";
+            // 
+            // labelBrightness
+            // 
+            labelBrightness.Location = new Point(13, 76);
+            labelBrightness.Name = "labelBrightness";
+            labelBrightness.Size = new Size(197, 49);
+            labelBrightness.TabIndex = 41;
+            labelBrightness.Text = "Brightness";
+            // 
+            // trackBrightness
+            // 
+            trackBrightness.LargeChange = 1;
+            trackBrightness.Location = new Point(216, 60);
+            trackBrightness.Maximum = 3;
+            trackBrightness.Name = "trackBrightness";
+            trackBrightness.Size = new Size(600, 90);
+            trackBrightness.TabIndex = 42;
+            trackBrightness.TickStyle = TickStyle.TopLeft;
+            // 
+            // labelSpeed
+            // 
+            labelSpeed.AutoSize = true;
+            labelSpeed.Location = new Point(13, 15);
+            labelSpeed.MaximumSize = new Size(200, 0);
+            labelSpeed.Name = "labelSpeed";
+            labelSpeed.Size = new Size(198, 32);
+            labelSpeed.TabIndex = 44;
+            labelSpeed.Text = "Animation Speed";
+            // 
+            // 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(220, 12);
+            comboKeyboardSpeed.Margin = new Padding(4, 10, 4, 8);
+            comboKeyboardSpeed.Name = "comboKeyboardSpeed";
+            comboKeyboardSpeed.Size = new Size(291, 40);
+            comboKeyboardSpeed.TabIndex = 43;
+            comboKeyboardSpeed.TabStop = false;
+            // 
+            // panelXMG
+            // 
+            panelXMG.Controls.Add(checkXMG);
+            panelXMG.Dock = DockStyle.Top;
+            panelXMG.Location = new Point(3, 261);
+            panelXMG.Name = "panelXMG";
+            panelXMG.Size = new Size(948, 58);
+            panelXMG.TabIndex = 42;
+            // 
+            // checkXMG
+            // 
+            checkXMG.AutoSize = true;
+            checkXMG.Location = new Point(3, 10);
+            checkXMG.Name = "checkXMG";
+            checkXMG.Padding = new Padding(15, 2, 5, 2);
+            checkXMG.Size = new Size(178, 40);
+            checkXMG.TabIndex = 2;
+            checkXMG.Text = "XG Mobile";
+            checkXMG.UseVisualStyleBackColor = true;
+            // 
+            // tableBacklight
+            // 
+            tableBacklight.AutoSize = true;
+            tableBacklight.ColumnCount = 4;
+            tableBacklight.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBacklight.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBacklight.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBacklight.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 25F));
+            tableBacklight.Controls.Add(labelBacklight, 0, 0);
+            tableBacklight.Controls.Add(checkAwake, 0, 1);
+            tableBacklight.Controls.Add(checkBoot, 0, 2);
+            tableBacklight.Controls.Add(checkSleep, 0, 3);
+            tableBacklight.Controls.Add(checkShutdown, 0, 4);
+            tableBacklight.Controls.Add(labelBacklightLogo, 1, 0);
+            tableBacklight.Controls.Add(checkAwakeLogo, 1, 1);
+            tableBacklight.Controls.Add(checkBootLogo, 1, 2);
+            tableBacklight.Controls.Add(checkSleepLogo, 1, 3);
+            tableBacklight.Controls.Add(checkShutdownLogo, 1, 4);
+            tableBacklight.Controls.Add(labelBacklightBar, 2, 0);
+            tableBacklight.Controls.Add(checkAwakeBar, 2, 1);
+            tableBacklight.Controls.Add(checkBootBar, 2, 2);
+            tableBacklight.Controls.Add(checkSleepBar, 2, 3);
+            tableBacklight.Controls.Add(checkShutdownBar, 2, 4);
+            tableBacklight.Controls.Add(labelBacklightLid, 3, 0);
+            tableBacklight.Controls.Add(checkAwakeLid, 3, 1);
+            tableBacklight.Controls.Add(checkBootLid, 3, 2);
+            tableBacklight.Controls.Add(checkSleepLid, 3, 3);
+            tableBacklight.Controls.Add(checkShutdownLid, 3, 4);
+            tableBacklight.Dock = DockStyle.Top;
+            tableBacklight.Location = new Point(3, 35);
+            tableBacklight.Margin = new Padding(0);
+            tableBacklight.Name = "tableBacklight";
+            tableBacklight.RowCount = 5;
+            tableBacklight.RowStyles.Add(new RowStyle());
+            tableBacklight.RowStyles.Add(new RowStyle());
+            tableBacklight.RowStyles.Add(new RowStyle());
+            tableBacklight.RowStyles.Add(new RowStyle());
+            tableBacklight.RowStyles.Add(new RowStyle());
+            tableBacklight.Size = new Size(948, 226);
+            tableBacklight.TabIndex = 41;
+            // 
+            // labelBacklight
+            // 
+            labelBacklight.Dock = DockStyle.Fill;
+            labelBacklight.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelBacklight.Location = new Point(3, 0);
+            labelBacklight.Name = "labelBacklight";
+            labelBacklight.Padding = new Padding(10, 5, 5, 5);
+            labelBacklight.Size = new Size(231, 42);
+            labelBacklight.TabIndex = 6;
+            labelBacklight.Text = "Keyboard";
+            // 
+            // checkAwake
+            // 
+            checkAwake.Dock = DockStyle.Fill;
+            checkAwake.Location = new Point(3, 45);
+            checkAwake.Name = "checkAwake";
+            checkAwake.Padding = new Padding(15, 2, 5, 2);
+            checkAwake.Size = new Size(231, 40);
+            checkAwake.TabIndex = 1;
+            checkAwake.Text = Strings.Awake;
+            checkAwake.UseVisualStyleBackColor = true;
+            // 
+            // checkBoot
+            // 
+            checkBoot.Dock = DockStyle.Fill;
+            checkBoot.Location = new Point(3, 91);
+            checkBoot.Name = "checkBoot";
+            checkBoot.Padding = new Padding(15, 2, 5, 2);
+            checkBoot.Size = new Size(231, 40);
+            checkBoot.TabIndex = 2;
+            checkBoot.Text = Strings.Boot;
+            checkBoot.UseVisualStyleBackColor = true;
+            // 
+            // checkSleep
+            // 
+            checkSleep.Dock = DockStyle.Fill;
+            checkSleep.Location = new Point(3, 137);
+            checkSleep.Name = "checkSleep";
+            checkSleep.Padding = new Padding(15, 2, 5, 2);
+            checkSleep.Size = new Size(231, 40);
+            checkSleep.TabIndex = 3;
+            checkSleep.Text = "Sleep";
+            checkSleep.UseVisualStyleBackColor = true;
+            // 
+            // checkShutdown
+            // 
+            checkShutdown.Dock = DockStyle.Fill;
+            checkShutdown.Location = new Point(3, 183);
+            checkShutdown.Name = "checkShutdown";
+            checkShutdown.Padding = new Padding(15, 2, 5, 2);
+            checkShutdown.Size = new Size(231, 40);
+            checkShutdown.TabIndex = 4;
+            checkShutdown.Text = Strings.Shutdown;
+            checkShutdown.UseVisualStyleBackColor = true;
+            // 
+            // labelBacklightLogo
+            // 
+            labelBacklightLogo.Dock = DockStyle.Fill;
+            labelBacklightLogo.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelBacklightLogo.Location = new Point(240, 0);
+            labelBacklightLogo.Name = "labelBacklightLogo";
+            labelBacklightLogo.Padding = new Padding(10, 5, 5, 5);
+            labelBacklightLogo.Size = new Size(231, 42);
+            labelBacklightLogo.TabIndex = 21;
+            labelBacklightLogo.Text = "Logo";
+            // 
+            // checkAwakeLogo
+            // 
+            checkAwakeLogo.Dock = DockStyle.Fill;
+            checkAwakeLogo.Location = new Point(240, 45);
+            checkAwakeLogo.Name = "checkAwakeLogo";
+            checkAwakeLogo.Padding = new Padding(15, 2, 5, 2);
+            checkAwakeLogo.Size = new Size(231, 40);
+            checkAwakeLogo.TabIndex = 17;
+            checkAwakeLogo.Text = Strings.Awake;
+            checkAwakeLogo.UseVisualStyleBackColor = true;
+            // 
+            // checkBootLogo
+            // 
+            checkBootLogo.Dock = DockStyle.Fill;
+            checkBootLogo.Location = new Point(240, 91);
+            checkBootLogo.Name = "checkBootLogo";
+            checkBootLogo.Padding = new Padding(15, 2, 5, 2);
+            checkBootLogo.Size = new Size(231, 40);
+            checkBootLogo.TabIndex = 18;
+            checkBootLogo.Text = Strings.Boot;
+            checkBootLogo.UseVisualStyleBackColor = true;
+            // 
+            // checkSleepLogo
+            // 
+            checkSleepLogo.Dock = DockStyle.Fill;
+            checkSleepLogo.Location = new Point(240, 137);
+            checkSleepLogo.Name = "checkSleepLogo";
+            checkSleepLogo.Padding = new Padding(15, 2, 5, 2);
+            checkSleepLogo.Size = new Size(231, 40);
+            checkSleepLogo.TabIndex = 19;
+            checkSleepLogo.Text = Strings.Sleep;
+            checkSleepLogo.UseVisualStyleBackColor = true;
+            // 
+            // checkShutdownLogo
+            // 
+            checkShutdownLogo.Dock = DockStyle.Fill;
+            checkShutdownLogo.Location = new Point(240, 183);
+            checkShutdownLogo.Name = "checkShutdownLogo";
+            checkShutdownLogo.Padding = new Padding(15, 2, 5, 2);
+            checkShutdownLogo.Size = new Size(231, 40);
+            checkShutdownLogo.TabIndex = 20;
+            checkShutdownLogo.Text = Strings.Shutdown;
+            checkShutdownLogo.UseVisualStyleBackColor = true;
+            // 
+            // labelBacklightBar
+            // 
+            labelBacklightBar.Dock = DockStyle.Fill;
+            labelBacklightBar.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelBacklightBar.Location = new Point(477, 0);
+            labelBacklightBar.Name = "labelBacklightBar";
+            labelBacklightBar.Padding = new Padding(10, 5, 5, 5);
+            labelBacklightBar.Size = new Size(231, 42);
+            labelBacklightBar.TabIndex = 11;
+            labelBacklightBar.Text = "Lightbar";
+            // 
+            // checkAwakeBar
+            // 
+            checkAwakeBar.Dock = DockStyle.Fill;
+            checkAwakeBar.Location = new Point(477, 45);
+            checkAwakeBar.Name = "checkAwakeBar";
+            checkAwakeBar.Padding = new Padding(15, 2, 5, 2);
+            checkAwakeBar.Size = new Size(231, 40);
+            checkAwakeBar.TabIndex = 7;
+            checkAwakeBar.Text = Strings.Awake;
+            checkAwakeBar.UseVisualStyleBackColor = true;
+            // 
+            // checkBootBar
+            // 
+            checkBootBar.Dock = DockStyle.Fill;
+            checkBootBar.Location = new Point(477, 91);
+            checkBootBar.Name = "checkBootBar";
+            checkBootBar.Padding = new Padding(15, 2, 5, 2);
+            checkBootBar.Size = new Size(231, 40);
+            checkBootBar.TabIndex = 8;
+            checkBootBar.Text = Strings.Boot;
+            checkBootBar.UseVisualStyleBackColor = true;
+            // 
+            // checkSleepBar
+            // 
+            checkSleepBar.Dock = DockStyle.Fill;
+            checkSleepBar.Location = new Point(477, 137);
+            checkSleepBar.Name = "checkSleepBar";
+            checkSleepBar.Padding = new Padding(15, 2, 5, 2);
+            checkSleepBar.Size = new Size(231, 40);
+            checkSleepBar.TabIndex = 9;
+            checkSleepBar.Text = Strings.Sleep;
+            checkSleepBar.UseVisualStyleBackColor = true;
+            // 
+            // checkShutdownBar
+            // 
+            checkShutdownBar.Dock = DockStyle.Fill;
+            checkShutdownBar.Location = new Point(477, 183);
+            checkShutdownBar.Name = "checkShutdownBar";
+            checkShutdownBar.Padding = new Padding(15, 2, 5, 2);
+            checkShutdownBar.Size = new Size(231, 40);
+            checkShutdownBar.TabIndex = 10;
+            checkShutdownBar.Text = Strings.Shutdown;
+            checkShutdownBar.UseVisualStyleBackColor = true;
+            // 
+            // labelBacklightLid
+            // 
+            labelBacklightLid.Dock = DockStyle.Fill;
+            labelBacklightLid.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelBacklightLid.Location = new Point(714, 0);
+            labelBacklightLid.Name = "labelBacklightLid";
+            labelBacklightLid.Padding = new Padding(10, 5, 5, 5);
+            labelBacklightLid.Size = new Size(231, 42);
+            labelBacklightLid.TabIndex = 16;
+            labelBacklightLid.Text = "Lid";
+            // 
+            // checkAwakeLid
+            // 
+            checkAwakeLid.Dock = DockStyle.Fill;
+            checkAwakeLid.Location = new Point(714, 45);
+            checkAwakeLid.Name = "checkAwakeLid";
+            checkAwakeLid.Padding = new Padding(15, 2, 5, 2);
+            checkAwakeLid.Size = new Size(231, 40);
+            checkAwakeLid.TabIndex = 12;
+            checkAwakeLid.Text = Strings.Awake;
+            checkAwakeLid.UseVisualStyleBackColor = true;
+            // 
+            // checkBootLid
+            // 
+            checkBootLid.Dock = DockStyle.Fill;
+            checkBootLid.Location = new Point(714, 91);
+            checkBootLid.Name = "checkBootLid";
+            checkBootLid.Padding = new Padding(15, 2, 5, 2);
+            checkBootLid.Size = new Size(231, 40);
+            checkBootLid.TabIndex = 13;
+            checkBootLid.Text = Strings.Boot;
+            checkBootLid.UseVisualStyleBackColor = true;
+            // 
+            // checkSleepLid
+            // 
+            checkSleepLid.Dock = DockStyle.Fill;
+            checkSleepLid.Location = new Point(714, 137);
+            checkSleepLid.Name = "checkSleepLid";
+            checkSleepLid.Padding = new Padding(15, 2, 5, 2);
+            checkSleepLid.Size = new Size(231, 40);
+            checkSleepLid.TabIndex = 14;
+            checkSleepLid.Text = Strings.Sleep;
+            checkSleepLid.UseVisualStyleBackColor = true;
+            // 
+            // checkShutdownLid
+            // 
+            checkShutdownLid.Dock = DockStyle.Fill;
+            checkShutdownLid.Location = new Point(714, 183);
+            checkShutdownLid.Name = "checkShutdownLid";
+            checkShutdownLid.Padding = new Padding(15, 2, 5, 2);
+            checkShutdownLid.Size = new Size(231, 40);
+            checkShutdownLid.TabIndex = 15;
+            checkShutdownLid.Text = Strings.Shutdown;
+            checkShutdownLid.UseVisualStyleBackColor = true;
+            // 
+            // groupOther
+            // 
+            groupOther.Controls.Add(checkKeyboardAuto);
+            groupOther.Controls.Add(checkUSBC);
+            groupOther.Controls.Add(checkNoOverdrive);
+            groupOther.Controls.Add(checkTopmost);
+            groupOther.Dock = DockStyle.Top;
+            groupOther.Location = new Point(10, 768);
+            groupOther.Name = "groupOther";
+            groupOther.Size = new Size(954, 276);
+            groupOther.TabIndex = 2;
+            groupOther.TabStop = false;
+            groupOther.Text = "Other";
+            // 
+            // checkKeyboardAuto
+            // 
+            checkKeyboardAuto.AutoSize = true;
+            checkKeyboardAuto.Location = new Point(25, 53);
+            checkKeyboardAuto.MaximumSize = new Size(780, 0);
+            checkKeyboardAuto.Name = "checkKeyboardAuto";
+            checkKeyboardAuto.Size = new Size(712, 36);
+            checkKeyboardAuto.TabIndex = 46;
+            checkKeyboardAuto.Text = Strings.KeyboardAuto;
+            checkKeyboardAuto.UseVisualStyleBackColor = true;
+            // 
+            // checkUSBC
+            // 
+            checkUSBC.AutoSize = true;
+            checkUSBC.Location = new Point(25, 210);
+            checkUSBC.Name = "checkUSBC";
+            checkUSBC.Size = new Size(659, 36);
+            checkUSBC.TabIndex = 4;
+            checkUSBC.Text = "Keep GPU disabled on USB-C charger in Optimized mode";
+            checkUSBC.UseVisualStyleBackColor = true;
+            // 
+            // checkNoOverdrive
+            // 
+            checkNoOverdrive.AutoSize = true;
+            checkNoOverdrive.Location = new Point(25, 156);
+            checkNoOverdrive.Name = "checkNoOverdrive";
+            checkNoOverdrive.Size = new Size(307, 36);
+            checkNoOverdrive.TabIndex = 3;
+            checkNoOverdrive.Text = Strings.DisableOverdrive;
+            checkNoOverdrive.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 = Strings.WindowTop;
+            checkTopmost.UseVisualStyleBackColor = true;
+            // 
+            // Extra
+            // 
+            AutoScaleDimensions = new SizeF(13F, 32F);
+            AutoScaleMode = AutoScaleMode.Font;
+            AutoSize = true;
+            AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            ClientSize = new Size(974, 1059);
+            Controls.Add(groupOther);
+            Controls.Add(groupLight);
+            Controls.Add(groupBindings);
+            FormBorderStyle = FormBorderStyle.FixedSingle;
+            MaximizeBox = false;
+            MdiChildrenMinimizedAnchorBottom = false;
+            MinimizeBox = false;
+            MinimumSize = new Size(1000, 0);
+            Name = "Extra";
+            Padding = new Padding(10);
+            ShowIcon = false;
+            ShowInTaskbar = false;
+            Text = "Extra Settings";
+            groupBindings.ResumeLayout(false);
+            groupBindings.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureHelp).EndInit();
+            groupLight.ResumeLayout(false);
+            groupLight.PerformLayout();
+            panelBacklightExtra.ResumeLayout(false);
+            panelBacklightExtra.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)numericBacklightTime).EndInit();
+            ((System.ComponentModel.ISupportInitialize)trackBrightness).EndInit();
+            panelXMG.ResumeLayout(false);
+            panelXMG.PerformLayout();
+            tableBacklight.ResumeLayout(false);
+            groupOther.ResumeLayout(false);
+            groupOther.PerformLayout();
+            ResumeLayout(false);
+            PerformLayout();
+        }
+
+        #endregion
+
+        private GroupBox groupBindings;
+        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 GroupBox groupOther;
+        private CheckBox checkTopmost;
+        private CheckBox checkNoOverdrive;
+        private PictureBox pictureHelp;
+        private CheckBox checkUSBC;
+        private TableLayoutPanel tableBacklight;
+        private CheckBox checkShutdown;
+        private CheckBox checkAwake;
+        private CheckBox checkBoot;
+        private CheckBox checkSleep;
+        private CheckBox checkBootLid;
+        private Label labelBacklight;
+        private CheckBox checkSleepBar;
+        private CheckBox checkShutdownBar;
+        private Label labelBacklightBar;
+        private CheckBox checkAwakeBar;
+        private CheckBox checkBootBar;
+        private CheckBox checkSleepLid;
+        private CheckBox checkShutdownLid;
+        private Label labelBacklightLid;
+        private CheckBox checkAwakeLid;
+        private Label labelBacklightLogo;
+        private CheckBox checkAwakeLogo;
+        private CheckBox checkBootLogo;
+        private CheckBox checkSleepLogo;
+        private CheckBox checkShutdownLogo;
+        private Panel panelBacklightExtra;
+        private Label labelBrightness;
+        private TrackBar trackBrightness;
+        private Label labelSpeed;
+        private RComboBox comboKeyboardSpeed;
+        private Panel panelXMG;
+        private CheckBox checkXMG;
+        private Label labelBacklightTimeout;
+        private NumericUpDown numericBacklightTime;
+        private CheckBox checkKeyboardAuto;
+    }
+}

app/Extra.cs

@@ -0,0 +1,303 @@
+using CustomControls;
+using System.Diagnostics;
+
+namespace GHelper
+{
+    public partial class Extra : 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},
+          {"performance", Properties.Strings.PerformanceMode},
+          {"screen", Properties.Strings.ToggleScreen},
+          {"miniled", Properties.Strings.ToggleMiniled},
+          {"custom", Properties.Strings.Custom}
+        };
+
+        private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
+        {
+            if (name == "m4")
+                customActions[""] = Properties.Strings.OpenGHelper;
+
+            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 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;
+
+            checkKeyboardAuto.Text = Properties.Strings.KeyboardAuto;
+            checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
+            checkTopmost.Text = Properties.Strings.WindowTop;
+            checkUSBC.Text = Properties.Strings.OptimizedUSBC;
+
+            labelBacklight.Text = Properties.Strings.Keyboard;
+            labelBacklightBar.Text = Properties.Strings.Lightbar;
+            labelBacklightLid.Text = Properties.Strings.Lid;
+            labelBacklightLogo.Text = Properties.Strings.Logo;
+
+            Text = Properties.Strings.ExtraSettings;
+
+            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;
+
+            // Keyboard
+            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);
+
+            // Lightbar
+            checkAwakeBar.Checked = !(Program.config.getConfig("keyboard_awake_bar") == 0);
+            checkBootBar.Checked = !(Program.config.getConfig("keyboard_boot_bar") == 0);
+            checkSleepBar.Checked = !(Program.config.getConfig("keyboard_sleep_bar") == 0);
+            checkShutdownBar.Checked = !(Program.config.getConfig("keyboard_shutdown_bar") == 0);
+
+            // Lid
+            checkAwakeLid.Checked = !(Program.config.getConfig("keyboard_awake_lid") == 0);
+            checkBootLid.Checked = !(Program.config.getConfig("keyboard_boot_lid") == 0);
+            checkSleepLid.Checked = !(Program.config.getConfig("keyboard_sleep_lid") == 0);
+            checkShutdownLid.Checked = !(Program.config.getConfig("keyboard_shutdown_lid") == 0);
+
+            // Logo
+            checkAwakeLogo.Checked = !(Program.config.getConfig("keyboard_awake_logo") == 0);
+            checkBootLogo.Checked = !(Program.config.getConfig("keyboard_boot_logo") == 0);
+            checkSleepLogo.Checked = !(Program.config.getConfig("keyboard_sleep_logo") == 0);
+            checkShutdownLogo.Checked = !(Program.config.getConfig("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 (!Program.config.ContainsModel("Strix"))
+            {
+                labelBacklightBar.Visible = false;
+                checkAwakeBar.Visible = false;
+                checkBootBar.Visible = false;
+                checkSleepBar.Visible = false;
+                checkShutdownBar.Visible = false;
+
+                if (!Program.config.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 = (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;
+
+            checkUSBC.Checked = (Program.config.getConfig("optimized_usbc") == 1);
+            checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
+
+            int kb_brightness = Program.config.getConfig("keyboard_brightness");
+            trackBrightness.Value = (kb_brightness >= 0 && kb_brightness <= 3) ? kb_brightness : 3;
+
+            pictureHelp.Click += PictureHelp_Click;
+            trackBrightness.Scroll += TrackBrightness_Scroll;
+
+            panelXMG.Visible = (Program.wmi.DeviceGet(ASUSWmi.GPUXGConnected) == 1);
+            checkXMG.Checked = !(Program.config.getConfig("xmg_light") == 0);
+            checkXMG.CheckedChanged += CheckXMG_CheckedChanged;
+
+            int kb_timeout = Program.config.getConfig("keyboard_light_tiomeout");
+            numericBacklightTime.Value = (kb_timeout >= 0) ? kb_timeout : 60;
+
+            numericBacklightTime.ValueChanged += NumericBacklightTime_ValueChanged;
+
+        }
+
+        private void NumericBacklightTime_ValueChanged(object? sender, EventArgs e)
+        {
+            Program.RunAsAdmin("extra");
+            Program.config.setConfig("keyboard_light_tiomeout", (int)numericBacklightTime.Value);
+            Aura.SetBacklightOffDelay((int)numericBacklightTime.Value);
+        }
+
+        private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("xmg_light", (checkXMG.Checked ? 1 : 0));
+            Aura.ApplyXGMLight(checkXMG.Checked);
+        }
+
+        private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
+        }
+
+        private void TrackBrightness_Scroll(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("keyboard_brightness", trackBrightness.Value);
+            Aura.ApplyBrightness(trackBrightness.Value);
+        }
+
+        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));
+
+            Program.config.setConfig("keyboard_awake_bar", (checkAwakeBar.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_boot_bar", (checkBootBar.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_sleep_bar", (checkSleepBar.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_shutdown_bar", (checkShutdownBar.Checked ? 1 : 0));
+
+            Program.config.setConfig("keyboard_awake_lid", (checkAwakeLid.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_boot_lid", (checkBootLid.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_sleep_lid", (checkSleepLid.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_shutdown_lid", (checkShutdownLid.Checked ? 1 : 0));
+
+            Program.config.setConfig("keyboard_awake_logo", (checkAwakeLogo.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_boot_logo", (checkBootLogo.Checked ? 1 : 0));
+            Program.config.setConfig("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
+            Program.config.setConfig("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);
+
+            Aura.ApplyAuraPower(flags);
+
+        }
+
+        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/Fans.Designer.cs

@@ -38,6 +38,7 @@ namespace GHelper
             ChartArea chartArea3 = new ChartArea();
             Title title3 = new Title();
             panelFans = new Panel();
+            labelFansResult = new Label();
             labelTip = new Label();
             labelBoost = new Label();
             comboBoost = new RComboBox();
@@ -47,64 +48,107 @@ namespace GHelper
             chartCPU = new Chart();
             chartMid = new Chart();
             labelFans = new Label();
-            checkAuto = new CheckBox();
+            checkApplyFans = new RCheckBox();
             buttonReset = new RButton();
-            buttonApply = new RButton();
+            panelSliders = new Panel();
             panelPower = new Panel();
-            pictureBox1 = new PictureBox();
-            labelPowerLimits = new Label();
-            checkApplyPower = new CheckBox();
-            buttonApplyPower = new RButton();
+            panelApplyPower = new Panel();
+            checkApplyPower = new RCheckBox();
+            labelInfo = new Label();
             panelCPU = new Panel();
             labelCPU = new Label();
             label2 = new Label();
             trackCPU = new TrackBar();
             panelTotal = new Panel();
             labelTotal = new Label();
-            label1 = new Label();
+            labelPlatform = new Label();
             trackTotal = new TrackBar();
-            labelApplied = new Label();
-            pictureFine = new PictureBox();
-            labelInfo = new Label();
+            panelTitleCPU = new Panel();
+            pictureBox1 = new PictureBox();
+            labelPowerLimits = new Label();
+            panelGPU = new Panel();
+            panelGPUTemp = new Panel();
+            labelGPUTemp = new Label();
+            labelGPUTempTitle = new Label();
+            trackGPUTemp = new TrackBar();
+            panelGPUBoost = new Panel();
+            labelGPUBoost = new Label();
+            labelGPUBoostTitle = new Label();
+            trackGPUBoost = new TrackBar();
+            panelGPUMemory = new Panel();
+            labelGPUMemory = new Label();
+            labelGPUMemoryTitle = new Label();
+            trackGPUMemory = new TrackBar();
+            panelGPUCore = new Panel();
+            labelGPUCore = new Label();
+            trackGPUCore = new TrackBar();
+            labelGPUCoreTitle = new Label();
+            panelTitleGPU = new Panel();
+            pictureGPU = new PictureBox();
+            labelGPU = new Label();
             panelFans.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)picturePerf).BeginInit();
             tableFanCharts.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)chartGPU).BeginInit();
             ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
             ((System.ComponentModel.ISupportInitialize)chartMid).BeginInit();
+            panelSliders.SuspendLayout();
             panelPower.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureBox1).BeginInit();
+            panelApplyPower.SuspendLayout();
             panelCPU.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)trackCPU).BeginInit();
             panelTotal.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)trackTotal).BeginInit();
-            ((System.ComponentModel.ISupportInitialize)pictureFine).BeginInit();
+            panelTitleCPU.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureBox1).BeginInit();
+            panelGPU.SuspendLayout();
+            panelGPUTemp.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUTemp).BeginInit();
+            panelGPUBoost.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUBoost).BeginInit();
+            panelGPUMemory.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUMemory).BeginInit();
+            panelGPUCore.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUCore).BeginInit();
+            panelTitleGPU.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureGPU).BeginInit();
             SuspendLayout();
             // 
             // panelFans
             // 
+            panelFans.Controls.Add(labelFansResult);
             panelFans.Controls.Add(labelTip);
             panelFans.Controls.Add(labelBoost);
             panelFans.Controls.Add(comboBoost);
             panelFans.Controls.Add(picturePerf);
             panelFans.Controls.Add(tableFanCharts);
             panelFans.Controls.Add(labelFans);
-            panelFans.Controls.Add(checkAuto);
+            panelFans.Controls.Add(checkApplyFans);
             panelFans.Controls.Add(buttonReset);
-            panelFans.Controls.Add(buttonApply);
             panelFans.Dock = DockStyle.Left;
-            panelFans.Location = new Point(364, 0);
+            panelFans.Location = new Point(533, 0);
             panelFans.Margin = new Padding(0);
             panelFans.Name = "panelFans";
-            panelFans.Padding = new Padding(20);
-            panelFans.Size = new Size(824, 1159);
+            panelFans.Padding = new Padding(10);
+            panelFans.Size = new Size(824, 1189);
             panelFans.TabIndex = 12;
             // 
+            // labelFansResult
+            // 
+            labelFansResult.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelFansResult.ForeColor = Color.Red;
+            labelFansResult.Location = new Point(30, 1073);
+            labelFansResult.Name = "labelFansResult";
+            labelFansResult.Size = new Size(760, 32);
+            labelFansResult.TabIndex = 41;
+            labelFansResult.TextAlign = ContentAlignment.TopRight;
+            labelFansResult.Visible = false;
+            // 
             // labelTip
             // 
             labelTip.AutoSize = true;
             labelTip.BackColor = SystemColors.ControlLightLight;
-            labelTip.Location = new Point(245, 13);
+            labelTip.Location = new Point(155, 9);
             labelTip.Name = "labelTip";
             labelTip.Padding = new Padding(5);
             labelTip.Size = new Size(107, 42);
@@ -113,17 +157,20 @@ namespace GHelper
             // 
             // labelBoost
             // 
+            labelBoost.Anchor = AnchorStyles.Top | AnchorStyles.Right;
             labelBoost.AutoSize = true;
-            labelBoost.Location = new Point(397, 19);
+            labelBoost.Location = new Point(375, 17);
             labelBoost.Name = "labelBoost";
             labelBoost.Size = new Size(125, 32);
             labelBoost.TabIndex = 39;
             labelBoost.Text = "CPU Boost";
+            labelBoost.TextAlign = ContentAlignment.MiddleRight;
             // 
             // comboBoost
             // 
             comboBoost.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
             comboBoost.BorderColor = Color.White;
+            comboBoost.ButtonColor = Color.FromArgb(255, 255, 255);
             comboBoost.DropDownStyle = ComboBoxStyle.DropDownList;
             comboBoost.FormattingEnabled = true;
             comboBoost.Items.AddRange(new object[] { "Disabled", "Enabled", "Aggressive", "Efficient Enabled", "Efficient Aggressive" });
@@ -153,13 +200,13 @@ namespace GHelper
             tableFanCharts.Controls.Add(chartCPU, 0, 0);
             tableFanCharts.Controls.Add(chartMid, 0, 2);
             tableFanCharts.Location = new Point(28, 64);
-            tableFanCharts.Margin = new Padding(6);
+            tableFanCharts.Margin = new Padding(4);
             tableFanCharts.Name = "tableFanCharts";
             tableFanCharts.RowCount = 2;
             tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Percent, 33F));
             tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Percent, 33F));
             tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Percent, 33F));
-            tableFanCharts.Size = new Size(764, 992);
+            tableFanCharts.Size = new Size(764, 1022);
             tableFanCharts.TabIndex = 36;
             // 
             // chartGPU
@@ -167,10 +214,10 @@ namespace GHelper
             chartArea1.Name = "ChartArea1";
             chartGPU.ChartAreas.Add(chartArea1);
             chartGPU.Dock = DockStyle.Fill;
-            chartGPU.Location = new Point(2, 340);
+            chartGPU.Location = new Point(2, 350);
             chartGPU.Margin = new Padding(2, 10, 2, 10);
             chartGPU.Name = "chartGPU";
-            chartGPU.Size = new Size(760, 310);
+            chartGPU.Size = new Size(760, 320);
             chartGPU.TabIndex = 17;
             chartGPU.Text = "chartGPU";
             title1.Name = "Title1";
@@ -184,7 +231,7 @@ namespace GHelper
             chartCPU.Location = new Point(2, 10);
             chartCPU.Margin = new Padding(2, 10, 2, 10);
             chartCPU.Name = "chartCPU";
-            chartCPU.Size = new Size(760, 310);
+            chartCPU.Size = new Size(760, 320);
             chartCPU.TabIndex = 14;
             chartCPU.Text = "chartCPU";
             title2.Name = "Title1";
@@ -195,10 +242,10 @@ namespace GHelper
             chartArea3.Name = "ChartArea3";
             chartMid.ChartAreas.Add(chartArea3);
             chartMid.Dock = DockStyle.Fill;
-            chartMid.Location = new Point(2, 670);
+            chartMid.Location = new Point(2, 690);
             chartMid.Margin = new Padding(2, 10, 2, 10);
             chartMid.Name = "chartMid";
-            chartMid.Size = new Size(760, 312);
+            chartMid.Size = new Size(760, 322);
             chartMid.TabIndex = 14;
             chartMid.Text = "chartMid";
             title3.Name = "Title3";
@@ -216,249 +263,473 @@ namespace GHelper
             labelFans.TabIndex = 28;
             labelFans.Text = "Fan Curves";
             // 
-            // checkAuto
+            // checkApplyFans
             // 
-            checkAuto.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
-            checkAuto.AutoSize = true;
-            checkAuto.Location = new Point(377, 1086);
-            checkAuto.Margin = new Padding(4, 2, 4, 2);
-            checkAuto.Name = "checkAuto";
-            checkAuto.Size = new Size(165, 36);
-            checkAuto.TabIndex = 17;
-            checkAuto.Text = "Auto Apply";
-            checkAuto.UseVisualStyleBackColor = true;
+            checkApplyFans.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            checkApplyFans.AutoSize = true;
+            checkApplyFans.BackColor = SystemColors.ControlLight;
+            checkApplyFans.Location = new Point(449, 1118);
+            checkApplyFans.Margin = new Padding(4, 2, 4, 2);
+            checkApplyFans.Name = "checkApplyFans";
+            checkApplyFans.Padding = new Padding(15, 5, 15, 5);
+            checkApplyFans.Size = new Size(339, 46);
+            checkApplyFans.TabIndex = 17;
+            checkApplyFans.Text = Properties.Strings.ApplyFanCurve;
+            checkApplyFans.UseVisualStyleBackColor = false;
             // 
             // buttonReset
             // 
             buttonReset.Activated = false;
             buttonReset.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
-            buttonReset.BackColor = Color.FromArgb(230, 230, 230);
+            buttonReset.BackColor = SystemColors.ControlLight;
             buttonReset.BorderColor = Color.Transparent;
             buttonReset.BorderRadius = 2;
             buttonReset.FlatStyle = FlatStyle.Flat;
-            buttonReset.Location = new Point(30, 1081);
+            buttonReset.Location = new Point(30, 1112);
             buttonReset.Margin = new Padding(4, 2, 4, 2);
             buttonReset.Name = "buttonReset";
             buttonReset.Secondary = true;
-            buttonReset.Size = new Size(232, 44);
+            buttonReset.Size = new Size(232, 54);
             buttonReset.TabIndex = 15;
-            buttonReset.Text = "Factory Defaults";
+            buttonReset.Text = Properties.Strings.FactoryDefaults;
             buttonReset.UseVisualStyleBackColor = false;
             // 
-            // buttonApply
+            // panelSliders
             // 
-            buttonApply.Activated = false;
-            buttonApply.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
-            buttonApply.BackColor = Color.FromArgb(230, 230, 230);
-            buttonApply.BorderColor = Color.Transparent;
-            buttonApply.BorderRadius = 2;
-            buttonApply.FlatStyle = FlatStyle.Flat;
-            buttonApply.Location = new Point(542, 1081);
-            buttonApply.Margin = new Padding(4, 2, 4, 2);
-            buttonApply.Name = "buttonApply";
-            buttonApply.Secondary = true;
-            buttonApply.Size = new Size(248, 44);
-            buttonApply.TabIndex = 14;
-            buttonApply.Text = "Apply Custom Curve";
-            buttonApply.UseVisualStyleBackColor = false;
+            panelSliders.Controls.Add(panelPower);
+            panelSliders.Controls.Add(panelGPU);
+            panelSliders.Dock = DockStyle.Left;
+            panelSliders.Location = new Point(0, 0);
+            panelSliders.Margin = new Padding(0);
+            panelSliders.Name = "panelSliders";
+            panelSliders.Padding = new Padding(10, 0, 0, 0);
+            panelSliders.Size = new Size(533, 1189);
+            panelSliders.TabIndex = 13;
             // 
             // panelPower
             // 
-            panelPower.Controls.Add(pictureBox1);
-            panelPower.Controls.Add(labelPowerLimits);
-            panelPower.Controls.Add(checkApplyPower);
-            panelPower.Controls.Add(buttonApplyPower);
+            panelPower.AutoSize = true;
+            panelPower.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelPower.Controls.Add(panelApplyPower);
+            panelPower.Controls.Add(labelInfo);
             panelPower.Controls.Add(panelCPU);
             panelPower.Controls.Add(panelTotal);
-            panelPower.Controls.Add(labelApplied);
-            panelPower.Controls.Add(pictureFine);
-            panelPower.Controls.Add(labelInfo);
-            panelPower.Dock = DockStyle.Left;
-            panelPower.Location = new Point(0, 0);
-            panelPower.Margin = new Padding(10);
+            panelPower.Controls.Add(panelTitleCPU);
+            panelPower.Dock = DockStyle.Fill;
+            panelPower.Location = new Point(10, 652);
             panelPower.Name = "panelPower";
-            panelPower.Padding = new Padding(10);
-            panelPower.Size = new Size(364, 1159);
-            panelPower.TabIndex = 13;
+            panelPower.Size = new Size(523, 537);
+            panelPower.TabIndex = 43;
+            // 
+            // panelApplyPower
+            // 
+            panelApplyPower.Controls.Add(checkApplyPower);
+            panelApplyPower.Dock = DockStyle.Bottom;
+            panelApplyPower.Location = new Point(0, 445);
+            panelApplyPower.Name = "panelApplyPower";
+            panelApplyPower.Padding = new Padding(10);
+            panelApplyPower.Size = new Size(523, 92);
+            panelApplyPower.TabIndex = 44;
+            // 
+            // checkApplyPower
+            // 
+            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            checkApplyPower.AutoSize = true;
+            checkApplyPower.BackColor = SystemColors.ControlLight;
+            checkApplyPower.Location = new Point(18, 22);
+            checkApplyPower.Margin = new Padding(10);
+            checkApplyPower.Name = "checkApplyPower";
+            checkApplyPower.Padding = new Padding(15, 5, 15, 5);
+            checkApplyPower.Size = new Size(277, 46);
+            checkApplyPower.TabIndex = 45;
+            checkApplyPower.Text = Properties.Strings.ApplyPowerLimits;
+            checkApplyPower.UseVisualStyleBackColor = false;
+            // 
+            // labelInfo
+            // 
+            labelInfo.Dock = DockStyle.Top;
+            labelInfo.Location = new Point(0, 342);
+            labelInfo.Margin = new Padding(4, 0, 4, 0);
+            labelInfo.Name = "labelInfo";
+            labelInfo.Padding = new Padding(5);
+            labelInfo.Size = new Size(523, 149);
+            labelInfo.TabIndex = 43;
+            labelInfo.Text = "Experimental Feature";
+            // 
+            // panelCPU
+            // 
+            panelCPU.AutoSize = true;
+            panelCPU.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelCPU.Controls.Add(labelCPU);
+            panelCPU.Controls.Add(label2);
+            panelCPU.Controls.Add(trackCPU);
+            panelCPU.Dock = DockStyle.Top;
+            panelCPU.Location = new Point(0, 206);
+            panelCPU.Margin = new Padding(4);
+            panelCPU.Name = "panelCPU";
+            panelCPU.Size = new Size(523, 136);
+            panelCPU.TabIndex = 41;
+            // 
+            // labelCPU
+            // 
+            labelCPU.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelCPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelCPU.Location = new Point(398, 8);
+            labelCPU.Margin = new Padding(4, 0, 4, 0);
+            labelCPU.Name = "labelCPU";
+            labelCPU.Size = new Size(120, 32);
+            labelCPU.TabIndex = 13;
+            labelCPU.Text = "CPU";
+            labelCPU.TextAlign = ContentAlignment.TopRight;
+            // 
+            // label2
+            // 
+            label2.AutoSize = true;
+            label2.Location = new Point(10, 8);
+            label2.Margin = new Padding(4, 0, 4, 0);
+            label2.Name = "label2";
+            label2.Size = new Size(58, 32);
+            label2.TabIndex = 12;
+            label2.Text = "CPU";
+            // 
+            // trackCPU
+            // 
+            trackCPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackCPU.Location = new Point(6, 44);
+            trackCPU.Margin = new Padding(4, 2, 4, 2);
+            trackCPU.Maximum = 85;
+            trackCPU.Minimum = 5;
+            trackCPU.Name = "trackCPU";
+            trackCPU.Size = new Size(513, 90);
+            trackCPU.TabIndex = 11;
+            trackCPU.TickFrequency = 5;
+            trackCPU.TickStyle = TickStyle.TopLeft;
+            trackCPU.Value = 80;
+            // 
+            // panelTotal
+            // 
+            panelTotal.AutoSize = true;
+            panelTotal.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelTotal.Controls.Add(labelTotal);
+            panelTotal.Controls.Add(labelPlatform);
+            panelTotal.Controls.Add(trackTotal);
+            panelTotal.Dock = DockStyle.Top;
+            panelTotal.Location = new Point(0, 66);
+            panelTotal.Margin = new Padding(4);
+            panelTotal.Name = "panelTotal";
+            panelTotal.Size = new Size(523, 140);
+            panelTotal.TabIndex = 40;
+            // 
+            // labelTotal
+            // 
+            labelTotal.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelTotal.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelTotal.Location = new Point(396, 10);
+            labelTotal.Margin = new Padding(4, 0, 4, 0);
+            labelTotal.Name = "labelTotal";
+            labelTotal.Size = new Size(122, 32);
+            labelTotal.TabIndex = 12;
+            labelTotal.Text = "Platform";
+            labelTotal.TextAlign = ContentAlignment.TopRight;
+            // 
+            // labelPlatform
+            // 
+            labelPlatform.AutoSize = true;
+            labelPlatform.Location = new Point(10, 10);
+            labelPlatform.Margin = new Padding(4, 0, 4, 0);
+            labelPlatform.Name = "labelPlatform";
+            labelPlatform.Size = new Size(104, 32);
+            labelPlatform.TabIndex = 11;
+            labelPlatform.Text = "Platform";
+            // 
+            // trackTotal
+            // 
+            trackTotal.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackTotal.Location = new Point(6, 48);
+            trackTotal.Margin = new Padding(4, 2, 4, 2);
+            trackTotal.Maximum = 180;
+            trackTotal.Minimum = 10;
+            trackTotal.Name = "trackTotal";
+            trackTotal.Size = new Size(513, 90);
+            trackTotal.TabIndex = 10;
+            trackTotal.TickFrequency = 5;
+            trackTotal.TickStyle = TickStyle.TopLeft;
+            trackTotal.Value = 125;
+            // 
+            // panelTitleCPU
+            // 
+            panelTitleCPU.AutoSize = true;
+            panelTitleCPU.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelTitleCPU.Controls.Add(pictureBox1);
+            panelTitleCPU.Controls.Add(labelPowerLimits);
+            panelTitleCPU.Dock = DockStyle.Top;
+            panelTitleCPU.Location = new Point(0, 0);
+            panelTitleCPU.Name = "panelTitleCPU";
+            panelTitleCPU.Size = new Size(523, 66);
+            panelTitleCPU.TabIndex = 42;
             // 
             // pictureBox1
             // 
             pictureBox1.BackgroundImage = Properties.Resources.icons8_processor_96;
             pictureBox1.BackgroundImageLayout = ImageLayout.Zoom;
             pictureBox1.InitialImage = null;
-            pictureBox1.Location = new Point(20, 18);
-            pictureBox1.Margin = new Padding(4, 2, 4, 2);
+            pictureBox1.Location = new Point(18, 18);
+            pictureBox1.Margin = new Padding(4, 2, 4, 10);
             pictureBox1.Name = "pictureBox1";
             pictureBox1.Size = new Size(36, 38);
-            pictureBox1.TabIndex = 38;
+            pictureBox1.TabIndex = 40;
             pictureBox1.TabStop = false;
             // 
             // labelPowerLimits
             // 
             labelPowerLimits.AutoSize = true;
             labelPowerLimits.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelPowerLimits.Location = new Point(54, 20);
+            labelPowerLimits.Location = new Point(62, 20);
             labelPowerLimits.Margin = new Padding(4, 0, 4, 0);
             labelPowerLimits.Name = "labelPowerLimits";
             labelPowerLimits.Size = new Size(229, 32);
-            labelPowerLimits.TabIndex = 26;
+            labelPowerLimits.TabIndex = 39;
             labelPowerLimits.Text = "Power Limits (PPT)";
             // 
-            // checkApplyPower
+            // panelGPU
             // 
-            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
-            checkApplyPower.AutoSize = true;
-            checkApplyPower.Location = new Point(27, 1039);
-            checkApplyPower.Margin = new Padding(4, 2, 4, 2);
-            checkApplyPower.Name = "checkApplyPower";
-            checkApplyPower.Size = new Size(165, 36);
-            checkApplyPower.TabIndex = 25;
-            checkApplyPower.Text = "Auto Apply";
-            checkApplyPower.UseVisualStyleBackColor = true;
+            panelGPU.AutoSize = true;
+            panelGPU.Controls.Add(panelGPUTemp);
+            panelGPU.Controls.Add(panelGPUBoost);
+            panelGPU.Controls.Add(panelGPUMemory);
+            panelGPU.Controls.Add(panelGPUCore);
+            panelGPU.Controls.Add(panelTitleGPU);
+            panelGPU.Dock = DockStyle.Top;
+            panelGPU.Location = new Point(10, 0);
+            panelGPU.Name = "panelGPU";
+            panelGPU.Padding = new Padding(0, 0, 0, 18);
+            panelGPU.Size = new Size(523, 652);
+            panelGPU.TabIndex = 44;
             // 
-            // buttonApplyPower
+            // panelGPUTemp
             // 
-            buttonApplyPower.Activated = false;
-            buttonApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
-            buttonApplyPower.BackColor = Color.FromArgb(230, 230, 230);
-            buttonApplyPower.BorderColor = Color.Transparent;
-            buttonApplyPower.BorderRadius = 2;
-            buttonApplyPower.FlatStyle = FlatStyle.Flat;
-            buttonApplyPower.Location = new Point(20, 1081);
-            buttonApplyPower.Margin = new Padding(4, 2, 4, 2);
-            buttonApplyPower.Name = "buttonApplyPower";
-            buttonApplyPower.Secondary = true;
-            buttonApplyPower.Size = new Size(324, 44);
-            buttonApplyPower.TabIndex = 24;
-            buttonApplyPower.Text = "Apply Power Limits";
-            buttonApplyPower.UseVisualStyleBackColor = false;
+            panelGPUTemp.AutoSize = true;
+            panelGPUTemp.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelGPUTemp.Controls.Add(labelGPUTemp);
+            panelGPUTemp.Controls.Add(labelGPUTempTitle);
+            panelGPUTemp.Controls.Add(trackGPUTemp);
+            panelGPUTemp.Dock = DockStyle.Top;
+            panelGPUTemp.Location = new Point(0, 485);
+            panelGPUTemp.Name = "panelGPUTemp";
+            panelGPUTemp.Size = new Size(523, 149);
+            panelGPUTemp.TabIndex = 47;
             // 
-            // panelCPU
+            // labelGPUTemp
             // 
-            panelCPU.Controls.Add(labelCPU);
-            panelCPU.Controls.Add(label2);
-            panelCPU.Controls.Add(trackCPU);
-            panelCPU.Location = new Point(184, 93);
-            panelCPU.Margin = new Padding(4);
-            panelCPU.Name = "panelCPU";
-            panelCPU.Size = new Size(160, 510);
-            panelCPU.TabIndex = 23;
+            labelGPUTemp.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelGPUTemp.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGPUTemp.Location = new Point(378, 14);
+            labelGPUTemp.Name = "labelGPUTemp";
+            labelGPUTemp.Size = new Size(130, 32);
+            labelGPUTemp.TabIndex = 44;
+            labelGPUTemp.Text = "87C";
+            labelGPUTemp.TextAlign = ContentAlignment.TopRight;
             // 
-            // labelCPU
+            // labelGPUTempTitle
             // 
-            labelCPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelCPU.Location = new Point(13, 40);
-            labelCPU.Margin = new Padding(4, 0, 4, 0);
-            labelCPU.Name = "labelCPU";
-            labelCPU.Size = new Size(120, 32);
-            labelCPU.TabIndex = 13;
-            labelCPU.Text = "CPU";
-            labelCPU.TextAlign = ContentAlignment.MiddleCenter;
+            labelGPUTempTitle.AutoSize = true;
+            labelGPUTempTitle.Location = new Point(10, 14);
+            labelGPUTempTitle.Name = "labelGPUTempTitle";
+            labelGPUTempTitle.Size = new Size(173, 32);
+            labelGPUTempTitle.TabIndex = 43;
+            labelGPUTempTitle.Text = "Thermal Target";
             // 
-            // label2
+            // trackGPUTemp
             // 
-            label2.AutoSize = true;
-            label2.Location = new Point(44, 8);
-            label2.Margin = new Padding(4, 0, 4, 0);
-            label2.Name = "label2";
-            label2.Size = new Size(58, 32);
-            label2.TabIndex = 12;
-            label2.Text = "CPU";
-            label2.TextAlign = ContentAlignment.MiddleCenter;
+            trackGPUTemp.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackGPUTemp.Location = new Point(6, 57);
+            trackGPUTemp.Margin = new Padding(4, 2, 4, 2);
+            trackGPUTemp.Maximum = 87;
+            trackGPUTemp.Minimum = 75;
+            trackGPUTemp.Name = "trackGPUTemp";
+            trackGPUTemp.Size = new Size(502, 90);
+            trackGPUTemp.TabIndex = 42;
+            trackGPUTemp.TickFrequency = 5;
+            trackGPUTemp.TickStyle = TickStyle.TopLeft;
+            trackGPUTemp.Value = 87;
             // 
-            // trackCPU
+            // panelGPUBoost
             // 
-            trackCPU.Location = new Point(48, 88);
-            trackCPU.Margin = new Padding(4, 2, 4, 2);
-            trackCPU.Maximum = 85;
-            trackCPU.Minimum = 15;
-            trackCPU.Name = "trackCPU";
-            trackCPU.Orientation = Orientation.Vertical;
-            trackCPU.Size = new Size(90, 416);
-            trackCPU.TabIndex = 11;
-            trackCPU.TickFrequency = 5;
-            trackCPU.Value = 80;
+            panelGPUBoost.AutoSize = true;
+            panelGPUBoost.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelGPUBoost.Controls.Add(labelGPUBoost);
+            panelGPUBoost.Controls.Add(labelGPUBoostTitle);
+            panelGPUBoost.Controls.Add(trackGPUBoost);
+            panelGPUBoost.Dock = DockStyle.Top;
+            panelGPUBoost.Location = new Point(0, 345);
+            panelGPUBoost.Name = "panelGPUBoost";
+            panelGPUBoost.Size = new Size(523, 140);
+            panelGPUBoost.TabIndex = 46;
             // 
-            // panelTotal
+            // labelGPUBoost
             // 
-            panelTotal.Controls.Add(labelTotal);
-            panelTotal.Controls.Add(label1);
-            panelTotal.Controls.Add(trackTotal);
-            panelTotal.Location = new Point(16, 93);
-            panelTotal.Margin = new Padding(4);
-            panelTotal.Name = "panelTotal";
-            panelTotal.Size = new Size(160, 512);
-            panelTotal.TabIndex = 22;
+            labelGPUBoost.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelGPUBoost.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGPUBoost.Location = new Point(374, 14);
+            labelGPUBoost.Name = "labelGPUBoost";
+            labelGPUBoost.Size = new Size(130, 32);
+            labelGPUBoost.TabIndex = 44;
+            labelGPUBoost.Text = "25W";
+            labelGPUBoost.TextAlign = ContentAlignment.TopRight;
             // 
-            // labelTotal
+            // labelGPUBoostTitle
             // 
-            labelTotal.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelTotal.Location = new Point(16, 40);
-            labelTotal.Margin = new Padding(4, 0, 4, 0);
-            labelTotal.Name = "labelTotal";
-            labelTotal.Size = new Size(122, 32);
-            labelTotal.TabIndex = 12;
-            labelTotal.Text = "Platform";
-            labelTotal.TextAlign = ContentAlignment.MiddleCenter;
+            labelGPUBoostTitle.AutoSize = true;
+            labelGPUBoostTitle.Location = new Point(10, 14);
+            labelGPUBoostTitle.Name = "labelGPUBoostTitle";
+            labelGPUBoostTitle.Size = new Size(174, 32);
+            labelGPUBoostTitle.TabIndex = 43;
+            labelGPUBoostTitle.Text = "Dynamic Boost";
             // 
-            // label1
+            // trackGPUBoost
             // 
-            label1.AutoSize = true;
-            label1.Location = new Point(26, 8);
-            label1.Margin = new Padding(4, 0, 4, 0);
-            label1.Name = "label1";
-            label1.Size = new Size(104, 32);
-            label1.TabIndex = 11;
-            label1.Text = "Platform";
-            label1.TextAlign = ContentAlignment.MiddleCenter;
+            trackGPUBoost.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackGPUBoost.Location = new Point(6, 48);
+            trackGPUBoost.Margin = new Padding(4, 2, 4, 2);
+            trackGPUBoost.Maximum = 25;
+            trackGPUBoost.Minimum = 5;
+            trackGPUBoost.Name = "trackGPUBoost";
+            trackGPUBoost.Size = new Size(502, 90);
+            trackGPUBoost.TabIndex = 42;
+            trackGPUBoost.TickFrequency = 5;
+            trackGPUBoost.TickStyle = TickStyle.TopLeft;
+            trackGPUBoost.Value = 25;
             // 
-            // trackTotal
+            // panelGPUMemory
             // 
-            trackTotal.Location = new Point(44, 88);
-            trackTotal.Margin = new Padding(4, 2, 4, 2);
-            trackTotal.Maximum = 150;
-            trackTotal.Minimum = 15;
-            trackTotal.Name = "trackTotal";
-            trackTotal.Orientation = Orientation.Vertical;
-            trackTotal.Size = new Size(90, 416);
-            trackTotal.TabIndex = 10;
-            trackTotal.TickFrequency = 5;
-            trackTotal.TickStyle = TickStyle.TopLeft;
-            trackTotal.Value = 125;
+            panelGPUMemory.AutoSize = true;
+            panelGPUMemory.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelGPUMemory.Controls.Add(labelGPUMemory);
+            panelGPUMemory.Controls.Add(labelGPUMemoryTitle);
+            panelGPUMemory.Controls.Add(trackGPUMemory);
+            panelGPUMemory.Dock = DockStyle.Top;
+            panelGPUMemory.Location = new Point(0, 205);
+            panelGPUMemory.Name = "panelGPUMemory";
+            panelGPUMemory.Size = new Size(523, 140);
+            panelGPUMemory.TabIndex = 45;
             // 
-            // labelApplied
+            // labelGPUMemory
             // 
-            labelApplied.AutoSize = true;
-            labelApplied.ForeColor = Color.Tomato;
-            labelApplied.Location = new Point(56, 54);
-            labelApplied.Margin = new Padding(4, 0, 4, 0);
-            labelApplied.Name = "labelApplied";
-            labelApplied.Size = new Size(143, 32);
-            labelApplied.TabIndex = 21;
-            labelApplied.Text = "Not Applied";
+            labelGPUMemory.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelGPUMemory.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGPUMemory.Location = new Point(378, 14);
+            labelGPUMemory.Name = "labelGPUMemory";
+            labelGPUMemory.Size = new Size(130, 32);
+            labelGPUMemory.TabIndex = 44;
+            labelGPUMemory.Text = "2000 MHz";
+            labelGPUMemory.TextAlign = ContentAlignment.TopRight;
             // 
-            // pictureFine
+            // labelGPUMemoryTitle
             // 
-            pictureFine.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
-            pictureFine.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureFine.Image = Properties.Resources.everything_is_fine_itsfine;
-            pictureFine.Location = new Point(20, 682);
-            pictureFine.Margin = new Padding(4, 2, 4, 2);
-            pictureFine.Name = "pictureFine";
-            pictureFine.Size = new Size(324, 268);
-            pictureFine.SizeMode = PictureBoxSizeMode.Zoom;
-            pictureFine.TabIndex = 20;
-            pictureFine.TabStop = false;
-            pictureFine.Visible = false;
+            labelGPUMemoryTitle.AutoSize = true;
+            labelGPUMemoryTitle.Location = new Point(10, 14);
+            labelGPUMemoryTitle.Name = "labelGPUMemoryTitle";
+            labelGPUMemoryTitle.Size = new Size(241, 32);
+            labelGPUMemoryTitle.TabIndex = 43;
+            labelGPUMemoryTitle.Text = "Memory Clock Offset";
             // 
-            // labelInfo
+            // trackGPUMemory
             // 
-            labelInfo.Location = new Point(24, 618);
-            labelInfo.Margin = new Padding(4, 0, 4, 0);
-            labelInfo.Name = "labelInfo";
-            labelInfo.Size = new Size(320, 330);
-            labelInfo.TabIndex = 19;
-            labelInfo.Text = "label";
+            trackGPUMemory.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackGPUMemory.LargeChange = 100;
+            trackGPUMemory.Location = new Point(6, 48);
+            trackGPUMemory.Margin = new Padding(4, 2, 4, 2);
+            trackGPUMemory.Maximum = 300;
+            trackGPUMemory.Name = "trackGPUMemory";
+            trackGPUMemory.Size = new Size(502, 90);
+            trackGPUMemory.SmallChange = 10;
+            trackGPUMemory.TabIndex = 42;
+            trackGPUMemory.TickFrequency = 50;
+            trackGPUMemory.TickStyle = TickStyle.TopLeft;
+            // 
+            // panelGPUCore
+            // 
+            panelGPUCore.AutoSize = true;
+            panelGPUCore.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelGPUCore.Controls.Add(labelGPUCore);
+            panelGPUCore.Controls.Add(trackGPUCore);
+            panelGPUCore.Controls.Add(labelGPUCoreTitle);
+            panelGPUCore.Dock = DockStyle.Top;
+            panelGPUCore.Location = new Point(0, 66);
+            panelGPUCore.Name = "panelGPUCore";
+            panelGPUCore.Size = new Size(523, 139);
+            panelGPUCore.TabIndex = 44;
+            // 
+            // labelGPUCore
+            // 
+            labelGPUCore.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelGPUCore.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGPUCore.Location = new Point(378, 15);
+            labelGPUCore.Name = "labelGPUCore";
+            labelGPUCore.Size = new Size(130, 32);
+            labelGPUCore.TabIndex = 29;
+            labelGPUCore.Text = "1500 MHz";
+            labelGPUCore.TextAlign = ContentAlignment.TopRight;
+            // 
+            // trackGPUCore
+            // 
+            trackGPUCore.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            trackGPUCore.LargeChange = 100;
+            trackGPUCore.Location = new Point(6, 47);
+            trackGPUCore.Margin = new Padding(4, 2, 4, 2);
+            trackGPUCore.Maximum = 300;
+            trackGPUCore.Name = "trackGPUCore";
+            trackGPUCore.RightToLeft = RightToLeft.No;
+            trackGPUCore.Size = new Size(502, 90);
+            trackGPUCore.SmallChange = 10;
+            trackGPUCore.TabIndex = 18;
+            trackGPUCore.TickFrequency = 50;
+            trackGPUCore.TickStyle = TickStyle.TopLeft;
+            // 
+            // labelGPUCoreTitle
+            // 
+            labelGPUCoreTitle.AutoSize = true;
+            labelGPUCoreTitle.Location = new Point(10, 15);
+            labelGPUCoreTitle.Name = "labelGPUCoreTitle";
+            labelGPUCoreTitle.Size = new Size(201, 32);
+            labelGPUCoreTitle.TabIndex = 17;
+            labelGPUCoreTitle.Text = "Core Clock Offset";
+            // 
+            // panelTitleGPU
+            // 
+            panelTitleGPU.AutoSize = true;
+            panelTitleGPU.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelTitleGPU.Controls.Add(pictureGPU);
+            panelTitleGPU.Controls.Add(labelGPU);
+            panelTitleGPU.Dock = DockStyle.Top;
+            panelTitleGPU.Location = new Point(0, 0);
+            panelTitleGPU.Name = "panelTitleGPU";
+            panelTitleGPU.Size = new Size(523, 66);
+            panelTitleGPU.TabIndex = 43;
+            // 
+            // pictureGPU
+            // 
+            pictureGPU.BackgroundImage = Properties.Resources.icons8_video_card_48;
+            pictureGPU.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureGPU.ErrorImage = null;
+            pictureGPU.InitialImage = null;
+            pictureGPU.Location = new Point(18, 18);
+            pictureGPU.Margin = new Padding(4, 2, 4, 10);
+            pictureGPU.Name = "pictureGPU";
+            pictureGPU.Size = new Size(36, 38);
+            pictureGPU.TabIndex = 41;
+            pictureGPU.TabStop = false;
+            // 
+            // labelGPU
+            // 
+            labelGPU.AutoSize = true;
+            labelGPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGPU.Location = new Point(62, 21);
+            labelGPU.Margin = new Padding(4, 0, 4, 0);
+            labelGPU.Name = "labelGPU";
+            labelGPU.Size = new Size(162, 32);
+            labelGPU.TabIndex = 40;
+            labelGPU.Text = "GPU Settings";
             // 
             // Fans
             // 
@@ -466,14 +737,14 @@ namespace GHelper
             AutoScaleMode = AutoScaleMode.Dpi;
             AutoSize = true;
             AutoSizeMode = AutoSizeMode.GrowAndShrink;
-            ClientSize = new Size(1178, 1159);
+            ClientSize = new Size(1361, 1189);
             Controls.Add(panelFans);
-            Controls.Add(panelPower);
+            Controls.Add(panelSliders);
             Margin = new Padding(4, 2, 4, 2);
             MaximizeBox = false;
             MdiChildrenMinimizedAnchorBottom = false;
             MinimizeBox = false;
-            MinimumSize = new Size(26, 1230);
+            MinimumSize = new Size(26, 1260);
             Name = "Fans";
             ShowIcon = false;
             ShowInTaskbar = false;
@@ -486,48 +757,90 @@ namespace GHelper
             ((System.ComponentModel.ISupportInitialize)chartGPU).EndInit();
             ((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
             ((System.ComponentModel.ISupportInitialize)chartMid).EndInit();
+            panelSliders.ResumeLayout(false);
+            panelSliders.PerformLayout();
             panelPower.ResumeLayout(false);
             panelPower.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureBox1).EndInit();
+            panelApplyPower.ResumeLayout(false);
+            panelApplyPower.PerformLayout();
             panelCPU.ResumeLayout(false);
             panelCPU.PerformLayout();
             ((System.ComponentModel.ISupportInitialize)trackCPU).EndInit();
             panelTotal.ResumeLayout(false);
             panelTotal.PerformLayout();
             ((System.ComponentModel.ISupportInitialize)trackTotal).EndInit();
-            ((System.ComponentModel.ISupportInitialize)pictureFine).EndInit();
+            panelTitleCPU.ResumeLayout(false);
+            panelTitleCPU.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureBox1).EndInit();
+            panelGPU.ResumeLayout(false);
+            panelGPU.PerformLayout();
+            panelGPUTemp.ResumeLayout(false);
+            panelGPUTemp.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUTemp).EndInit();
+            panelGPUBoost.ResumeLayout(false);
+            panelGPUBoost.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUBoost).EndInit();
+            panelGPUMemory.ResumeLayout(false);
+            panelGPUMemory.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUMemory).EndInit();
+            panelGPUCore.ResumeLayout(false);
+            panelGPUCore.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGPUCore).EndInit();
+            panelTitleGPU.ResumeLayout(false);
+            panelTitleGPU.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureGPU).EndInit();
             ResumeLayout(false);
         }
 
         #endregion
         private Panel panelFans;
-        private CheckBox checkAuto;
+        private RCheckBox checkApplyFans;
         private RButton buttonReset;
-        private RButton buttonApply;
-        private Panel panelPower;
-        private CheckBox checkApplyPower;
-        private RButton buttonApplyPower;
-        private Panel panelCPU;
-        private Label labelCPU;
-        private Label label2;
-        private TrackBar trackCPU;
-        private Panel panelTotal;
-        private Label labelTotal;
-        private Label label1;
-        private TrackBar trackTotal;
-        private Label labelApplied;
-        private PictureBox pictureFine;
-        private Label labelInfo;
-        private Label labelPowerLimits;
+        private Panel panelSliders;
         private TableLayoutPanel tableFanCharts;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartMid;
         private Label labelFans;
         private PictureBox picturePerf;
-        private PictureBox pictureBox1;
         private RComboBox comboBoost;
         private Label labelBoost;
         private Label labelTip;
+        private Label labelFansResult;
+        private Panel panelPower;
+        private Label labelInfo;
+        private Panel panelCPU;
+        private Label labelCPU;
+        private Label label2;
+        private TrackBar trackCPU;
+        private Panel panelTotal;
+        private Label labelTotal;
+        private Label labelPlatform;
+        private TrackBar trackTotal;
+        private Panel panelTitleCPU;
+        private PictureBox pictureBox1;
+        private Label labelPowerLimits;
+        private Panel panelGPU;
+        private Panel panelGPUMemory;
+        private Label labelGPUMemory;
+        private Label labelGPUMemoryTitle;
+        private TrackBar trackGPUMemory;
+        private Panel panelGPUCore;
+        private Label labelGPUCore;
+        private TrackBar trackGPUCore;
+        private Label labelGPUCoreTitle;
+        private Panel panelTitleGPU;
+        private PictureBox pictureGPU;
+        private Label labelGPU;
+        private Panel panelApplyPower;
+        private RCheckBox checkApplyPower;
+        private Panel panelGPUBoost;
+        private Label labelGPUBoost;
+        private Label labelGPUBoostTitle;
+        private TrackBar trackGPUBoost;
+        private Panel panelGPUTemp;
+        private Label labelGPUTemp;
+        private Label labelGPUTempTitle;
+        private TrackBar trackGPUTemp;
     }
 }

app/Fans.cs

@@ -1,6 +1,7 @@
-using System.Diagnostics;
+using CustomControls;
+using GHelper.Gpu;
+using System.Diagnostics;
 using System.Windows.Forms.DataVisualization.Charting;
-using CustomControls;
 
 namespace GHelper
 {
@@ -14,11 +15,210 @@ namespace GHelper
 
         static int MinRPM, MaxRPM;
 
+        const int fansMax = 100;
+
+        NvidiaGpuControl? nvControl = null;
+
+        public Fans()
+        {
+
+            InitializeComponent();
+
+            Text = Properties.Strings.FansAndPower;
+            labelPowerLimits.Text = Properties.Strings.PowerLimits;
+            labelInfo.Text = Properties.Strings.PPTExperimental;
+            checkApplyPower.Text = Properties.Strings.ApplyPowerLimits;
+
+            labelFans.Text = Properties.Strings.FanCurves;
+            labelBoost.Text = Properties.Strings.CPUBoost;
+            buttonReset.Text = Properties.Strings.FactoryDefaults;
+            checkApplyFans.Text = Properties.Strings.ApplyFanCurve;
+
+            labelGPU.Text = Properties.Strings.GPUSettings;
+
+            InitTheme();
+
+            MinRPM = 18;
+            MaxRPM = HardwareControl.GetFanMax();
+            labelTip.Visible = false;
+            labelTip.BackColor = Color.Transparent;
+
+            FormClosing += Fans_FormClosing;
+
+            seriesCPU = chartCPU.Series.Add("CPU");
+            seriesGPU = chartGPU.Series.Add("GPU");
+            seriesMid = chartMid.Series.Add("Mid");
+
+            seriesCPU.Color = colorStandard;
+            seriesGPU.Color = colorTurbo;
+            seriesMid.Color = colorEco;
+
+            chartCPU.MouseMove += ChartCPU_MouseMove;
+            chartCPU.MouseUp += ChartCPU_MouseUp;
+
+            chartGPU.MouseMove += ChartCPU_MouseMove;
+            chartGPU.MouseUp += ChartCPU_MouseUp;
+
+            chartMid.MouseMove += ChartCPU_MouseMove;
+            chartMid.MouseUp += ChartCPU_MouseUp;
+
+            buttonReset.Click += ButtonReset_Click;
+
+            trackTotal.Maximum = ASUSWmi.MaxTotal;
+            trackTotal.Minimum = ASUSWmi.MinTotal;
+
+            trackCPU.Maximum = ASUSWmi.MaxCPU;
+            trackCPU.Minimum = ASUSWmi.MinCPU;
+
+            trackCPU.Scroll += TrackPower_Scroll;
+            trackTotal.Scroll += TrackPower_Scroll;
+
+            trackCPU.MouseUp += TrackPower_MouseUp;
+            trackTotal.MouseUp += TrackPower_MouseUp;
+
+            checkApplyFans.Click += CheckApplyFans_Click;
+            checkApplyPower.Click += CheckApplyPower_Click;
+
+            trackGPUCore.Minimum = NvidiaGpuControl.MinCoreOffset;
+            trackGPUCore.Maximum = NvidiaGpuControl.MaxCoreOffset;
+
+            trackGPUMemory.Minimum = NvidiaGpuControl.MinMemoryOffset;
+            trackGPUMemory.Maximum = NvidiaGpuControl.MaxMemoryOffset;
+
+            trackGPUBoost.Minimum = ASUSWmi.MinGPUBoost;
+            trackGPUBoost.Maximum = ASUSWmi.MaxGPUBoost;
+
+            trackGPUTemp.Minimum = ASUSWmi.MinGPUTemp;
+            trackGPUTemp.Maximum = ASUSWmi.MaxGPUTemp;
+
+            trackGPUCore.Scroll += trackGPU_Scroll;
+            trackGPUMemory.Scroll += trackGPU_Scroll;
+
+            trackGPUBoost.Scroll += trackGPUPower_Scroll;
+            trackGPUTemp.Scroll += trackGPUPower_Scroll;
+
+            trackGPUCore.MouseUp += TrackGPU_MouseUp;
+            trackGPUMemory.MouseUp += TrackGPU_MouseUp;
+            trackGPUBoost.MouseUp += TrackGPU_MouseUp;
+            trackGPUTemp.MouseUp += TrackGPU_MouseUp;
+
+            //labelInfo.MaximumSize = new Size(280, 0);
+            labelInfo.Text = Properties.Strings.PPTExperimental;
+            labelFansResult.Visible = false;
+
+            InitFans();
+            InitPower();
+            InitBoost();
+            InitGPU(true);
+
+            comboBoost.SelectedValueChanged += ComboBoost_Changed;
+
+            Shown += Fans_Shown;
+
+
+        }
+
+
+        private void TrackGPU_MouseUp(object? sender, MouseEventArgs e)
+        {
+            Program.settingsForm.SetGPUPower();
+            Program.settingsForm.SetGPUClocks(true);
+        }
+
+        public void InitGPU(bool readClocks = false)
+        {
+            if (HardwareControl.GpuControl is not null && HardwareControl.GpuControl.IsNvidia)
+            {
+                nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+            }
+            else
+            {
+                panelGPU.Visible = false;
+                return;
+            }
+
+            try
+            {
+                panelGPU.Visible = true;
+
+                int gpu_boost = Program.config.getConfigPerf("gpu_boost");
+                int gpu_temp = Program.config.getConfigPerf("gpu_temp");
+                int core = Program.config.getConfigPerf("gpu_core");
+                int memory = Program.config.getConfigPerf("gpu_memory");
+
+                if (gpu_boost < 0) gpu_boost = ASUSWmi.MaxGPUBoost;
+                if (gpu_temp < 0) gpu_temp = ASUSWmi.MaxGPUTemp;
+                
+                if (core == -1) core = 0;
+                if (memory == -1) memory = 0;
+
+                //if (readClocks)
+                //{
+                int status = nvControl.GetClocks(out int current_core, out int current_memory);
+                if (status != -1)
+                {
+                    core = current_core;
+                    memory = current_memory;
+                }
+
+                labelGPU.Text = nvControl.FullName;
+
+                //}
+
+                trackGPUCore.Value = Math.Max(Math.Min(core, NvidiaGpuControl.MaxCoreOffset), NvidiaGpuControl.MinCoreOffset);
+                trackGPUMemory.Value = Math.Max(Math.Min(memory, NvidiaGpuControl.MaxMemoryOffset), NvidiaGpuControl.MinMemoryOffset);
+
+                trackGPUBoost.Value = Math.Max(Math.Min(gpu_boost, ASUSWmi.MaxGPUBoost), ASUSWmi.MinGPUBoost);
+                trackGPUTemp.Value = Math.Max(Math.Min(gpu_temp, ASUSWmi.MaxGPUTemp), ASUSWmi.MinGPUTemp);
+
+                panelGPUBoost.Visible = (Program.wmi.DeviceGet(ASUSWmi.PPT_GPUC0) >= 0);
+                panelGPUTemp.Visible = (Program.wmi.DeviceGet(ASUSWmi.PPT_GPUC2) >= 0);
+
+                VisualiseGPUSettings();
+
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+                panelGPU.Visible = false;
+            }
+
+        }
+
+        private void VisualiseGPUSettings()
+        {
+            labelGPUCore.Text = $"{trackGPUCore.Value} MHz";
+            labelGPUMemory.Text = $"{trackGPUMemory.Value} MHz";
+            labelGPUBoost.Text = $"{trackGPUBoost.Value}W";
+            labelGPUTemp.Text = $"{trackGPUTemp.Value}°C";
+        }
+
+        private void trackGPU_Scroll(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            TrackBar track = (TrackBar)sender;
+            track.Value = (int)Math.Round((float)track.Value / 5) * 5;
+
+            Program.config.setConfigPerf("gpu_core", trackGPUCore.Value);
+            Program.config.setConfigPerf("gpu_memory", trackGPUMemory.Value);
+
+            VisualiseGPUSettings();
+
+        }
+
+        private void trackGPUPower_Scroll(object? sender, EventArgs e)
+        {
+            Program.config.setConfigPerf("gpu_boost", trackGPUBoost.Value);
+            Program.config.setConfigPerf("gpu_temp", trackGPUTemp.Value);
+
+            VisualiseGPUSettings();
+        }
+
         static string ChartPercToRPM(int percentage, string unit = "")
         {
             if (percentage == 0) return "OFF";
 
-            return (200 * Math.Round((float)(MinRPM*100 + (MaxRPM - MinRPM) * percentage) / 200)).ToString() + unit;
+            return (200 * Math.Round((float)(MinRPM * 100 + (MaxRPM - MinRPM) * percentage) / 200)).ToString() + unit;
         }
 
         void SetChart(Chart chart, int device)
@@ -27,14 +227,14 @@ namespace GHelper
             string title;
 
             if (device == 1)
-                title = "GPU Fan Profile";
+                title = Properties.Strings.FanProfileGPU;
             else if (device == 2)
-                title = "Middle Fan Profile";
+                title = Properties.Strings.FanProfileMid;
             else
-                title = "CPU Fan Profile";
+                title = Properties.Strings.FanProfileCPU;
 
             if (Program.settingsForm.perfName.Length > 0)
-                labelFans.Text = "Fan Profiles: " + Program.settingsForm.perfName;
+                labelFans.Text = Properties.Strings.FanProfiles + ": " + Program.settingsForm.perfName;
 
             chart.Titles[0].Text = title;
 
@@ -43,21 +243,19 @@ namespace GHelper
             chart.ChartAreas[0].AxisX.Interval = 10;
 
             chart.ChartAreas[0].AxisY.Minimum = 0;
-            chart.ChartAreas[0].AxisY.Maximum = 100;
+            chart.ChartAreas[0].AxisY.Maximum = fansMax;
 
             chart.ChartAreas[0].AxisY.LabelStyle.Font = new Font("Arial", 7F);
 
-            var foreAccent = Color.FromArgb(255, 180, 180, 180);
+            chart.ChartAreas[0].AxisX.MajorGrid.LineColor = chartGrid;
+            chart.ChartAreas[0].AxisY.MajorGrid.LineColor = chartGrid;
+            chart.ChartAreas[0].AxisX.LineColor = chartGrid;
+            chart.ChartAreas[0].AxisY.LineColor = chartGrid;
 
-            chart.ChartAreas[0].AxisX.MajorGrid.LineColor = foreAccent;
-            chart.ChartAreas[0].AxisY.MajorGrid.LineColor = foreAccent;
-            chart.ChartAreas[0].AxisX.LineColor = foreAccent;
-            chart.ChartAreas[0].AxisY.LineColor = foreAccent;
-
-            for (int i = 0; i <= 90; i += 10)
+            for (int i = 0; i <= fansMax-10; i += 10)
                 chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartPercToRPM(i));
 
-            chart.ChartAreas[0].AxisY.CustomLabels.Add(98, 102, "RPM");
+            chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax-2, fansMax+2, Properties.Strings.RPM);
 
             chart.ChartAreas[0].AxisY.Interval = 10;
 
@@ -83,67 +281,10 @@ namespace GHelper
             Left = Program.settingsForm.Left - Width - 5;
         }
 
-        public Fans()
+
+        private void TrackPower_MouseUp(object? sender, MouseEventArgs e)
         {
-
-            InitializeComponent();
-            InitTheme();
-
-            MinRPM = 18;
-            MaxRPM = HardwareMonitor.GetFanMax();
-
-
-
-            labelTip.Visible = false;
-            labelTip.BackColor = Color.Transparent;
-
-            FormClosing += Fans_FormClosing;
-
-            seriesCPU = chartCPU.Series.Add("CPU");
-            seriesGPU = chartGPU.Series.Add("GPU");
-            seriesMid = chartMid.Series.Add("Mid");
-
-            seriesCPU.Color = colorStandard;
-            seriesGPU.Color = colorTurbo;
-            seriesMid.Color = colorEco;
-
-            chartCPU.MouseMove += ChartCPU_MouseMove;
-            chartCPU.MouseUp += ChartCPU_MouseUp;
-
-            chartGPU.MouseMove += ChartCPU_MouseMove;
-            chartGPU.MouseUp += ChartCPU_MouseUp;
-
-            chartMid.MouseMove += ChartCPU_MouseMove;
-            chartMid.MouseUp += ChartCPU_MouseUp;
-
-            buttonReset.Click += ButtonReset_Click;
-            buttonApply.Click += ButtonApply_Click;
-
-            trackTotal.Maximum = ASUSWmi.MaxTotal;
-            trackTotal.Minimum = ASUSWmi.MinTotal;
-
-            trackCPU.Maximum = ASUSWmi.MaxCPU;
-            trackCPU.Minimum = ASUSWmi.MinCPU;
-
-            trackCPU.Scroll += TrackCPU_Scroll;
-            trackTotal.Scroll += TrackTotal_Scroll;
-
-            buttonApplyPower.Click += ButtonApplyPower_Click;
-
-            checkAuto.Click += CheckAuto_Click;
-            checkApplyPower.Click += CheckApplyPower_Click;
-
-            //labelInfo.MaximumSize = new Size(280, 0);
-            labelInfo.Text = "Power Limits (PPT) is\nexperimental feature.\n\nUse carefully and\non your own risk!";
-
-            InitFans();
-            InitPower();
-            InitBoost();
-
-            comboBoost.SelectedValueChanged += ComboBoost_Changed;
-
-            Shown += Fans_Shown;
-
+            Program.settingsForm.AutoPower();
         }
 
 
@@ -168,29 +309,55 @@ namespace GHelper
             if (sender is null) return;
             CheckBox chk = (CheckBox)sender;
             Program.config.setConfigPerf("auto_apply_power", chk.Checked ? 1 : 0);
+
+            if (chk.Checked)
+            {
+                Program.settingsForm.AutoPower();
+            }
+            else
+            {
+                Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"), "PerfMode");
+                Program.settingsForm.AutoFans();
+            }
+
         }
 
-        private void CheckAuto_Click(object? sender, EventArgs e)
+        private void CheckApplyFans_Click(object? sender, EventArgs e)
         {
             if (sender is null) return;
             CheckBox chk = (CheckBox)sender;
+
             Program.config.setConfigPerf("auto_apply", chk.Checked ? 1 : 0);
+
+            if (chk.Checked)
+            {
+                Program.settingsForm.AutoFans();
+            }
+            else
+            {
+                Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"), "PerfMode");
+                Program.settingsForm.AutoPower();
+            }
+        }
+
+
+        public void LabelFansResult(string text)
+        {
+            labelFansResult.Text = text;
+            labelFansResult.Visible = (text.Length > 0);
         }
 
         private void Fans_FormClosing(object? sender, FormClosingEventArgs e)
         {
+
+            /*
             if (e.CloseReason == CloseReason.UserClosing)
             {
                 e.Cancel = true;
                 Hide();
-            }
+            }*/
         }
 
-        private void ButtonApplyPower_Click(object? sender, EventArgs e)
-        {
-            Program.settingsForm.SetPower();
-            ApplyLabel(true);
-        }
 
         public void InitPower(bool changed = false)
         {
@@ -204,7 +371,7 @@ namespace GHelper
             // Yes, that's stupid, but Total slider on 2021 model actually adjusts CPU PPT
             if (!cpuBmode)
             {
-                label1.Text = "CPU SPPT";
+                labelPlatform.Text = "CPU PPT";
             }
 
             int limit_total;
@@ -215,13 +382,11 @@ namespace GHelper
             {
                 limit_total = trackTotal.Value;
                 limit_cpu = trackCPU.Value;
-                ApplyLabel(false);
             }
             else
             {
                 limit_total = Program.config.getConfigPerf("limit_total");
                 limit_cpu = Program.config.getConfigPerf("limit_cpu");
-                ApplyLabel(apply);
             }
 
             if (limit_total < 0) limit_total = ASUSWmi.DefaultTotal;
@@ -239,38 +404,19 @@ namespace GHelper
 
             labelTotal.Text = trackTotal.Value.ToString() + "W";
             labelCPU.Text = trackCPU.Value.ToString() + "W";
-            pictureFine.Visible = (limit_cpu > 85 || limit_total > 145);
 
             Program.config.setConfigPerf("limit_total", limit_total);
             Program.config.setConfigPerf("limit_cpu", limit_cpu);
+
+
         }
 
 
-        private void TrackTotal_Scroll(object? sender, EventArgs e)
+        private void TrackPower_Scroll(object? sender, EventArgs e)
         {
             InitPower(true);
         }
 
-        private void TrackCPU_Scroll(object? sender, EventArgs e)
-        {
-            InitPower(true);
-        }
-
-
-        public void ApplyLabel(bool applied = false)
-        {
-            if (applied)
-            {
-                labelApplied.ForeColor = colorStandard;
-                labelApplied.Text = "Applied";
-            }
-            else
-            {
-                labelApplied.ForeColor = colorTurbo;
-                labelApplied.Text = "Not Applied";
-
-            }
-        }
 
         public void InitFans()
         {
@@ -299,7 +445,7 @@ namespace GHelper
 
             int auto_apply = Program.config.getConfigPerf("auto_apply");
 
-            checkAuto.Checked = (auto_apply == 1);
+            checkApplyFans.Checked = (auto_apply == 1);
 
         }
 
@@ -316,11 +462,16 @@ namespace GHelper
             int mode = Program.config.getConfig("performance_mode");
             byte[] curve = Program.config.getFanConfig(device);
 
-            if (def == 1 || curve.Length != 16)
+            if (def == 1 || ASUSWmi.IsEmptyCurve(curve))
+            {
                 curve = Program.wmi.GetFanCurve(device, mode);
+                
+                if (ASUSWmi.IsEmptyCurve(curve)) 
+                    curve = Program.config.getDefaultCurve(device);
 
-            if (curve.Length != 16 || curve.All(singleByte => singleByte == 0))
-                curve = Program.config.getDefaultCurve(device);
+                curve = ASUSWmi.FixFanCurve(curve);
+
+            }
 
             //Debug.WriteLine(BitConverter.ToString(curve));
 
@@ -332,6 +483,8 @@ namespace GHelper
                 old = curve[i];
             }
 
+            SaveProfile(series, device);
+
         }
 
         void SaveProfile(Series series, int device)
@@ -351,16 +504,6 @@ namespace GHelper
         }
 
 
-        private void ButtonApply_Click(object? sender, EventArgs e)
-        {
-            SaveProfile(seriesCPU, 0);
-            SaveProfile(seriesGPU, 1);
-            if (Program.config.getConfig("mid_fan") == 1)
-                SaveProfile(seriesMid, 2);
-
-            Program.settingsForm.AutoFans(true);
-        }
-
         private void ButtonReset_Click(object? sender, EventArgs e)
         {
 
@@ -369,7 +512,7 @@ namespace GHelper
             if (Program.config.getConfig("mid_fan") == 1)
                 LoadProfile(seriesMid, 2, 1);
 
-            checkAuto.Checked = false;
+            checkApplyFans.Checked = false;
             checkApplyPower.Checked = false;
 
             Program.config.setConfigPerf("auto_apply", 0);
@@ -377,70 +520,175 @@ namespace GHelper
 
             Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"), "PerfMode");
 
-            ApplyLabel(false);
+            trackGPUCore.Value = 0;
+            trackGPUMemory.Value = 0;
+            trackGPUBoost.Value = ASUSWmi.MaxGPUBoost;
+            trackGPUTemp.Value = ASUSWmi.MaxGPUTemp;
+
+            Program.config.setConfigPerf("gpu_boost", trackGPUBoost.Value);
+            Program.config.setConfigPerf("gpu_temp", trackGPUTemp.Value);
+            Program.config.setConfigPerf("gpu_core", trackGPUCore.Value);
+            Program.config.setConfigPerf("gpu_memory", trackGPUMemory.Value);
+            VisualiseGPUSettings();
+
+            Program.settingsForm.SetGPUClocks(true);
+            Program.settingsForm.SetGPUPower();
         }
 
         private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
         {
             curPoint = null;
             labelTip.Visible = false;
+
+            SaveProfile(seriesCPU, 0);
+            SaveProfile(seriesGPU, 1);
+            if (Program.config.getConfig("mid_fan") == 1)
+                SaveProfile(seriesMid, 2);
+
+            Program.settingsForm.AutoFans();
+
+
         }
 
         private void ChartCPU_MouseMove(object? sender, MouseEventArgs e)
         {
 
             if (sender is null) return;
-
             Chart chart = (Chart)sender;
 
-            if (e.Button.HasFlag(MouseButtons.Left))
+            ChartArea ca = chart.ChartAreas[0];
+            Axis ax = ca.AxisX;
+            Axis ay = ca.AxisY;
+
+            bool tip = false;
+
+            HitTestResult hit = chart.HitTest(e.X, e.Y);
+            if (hit.Series is not null && hit.PointIndex >= 0)
             {
-                ChartArea ca = chart.ChartAreas[0];
-                Axis ax = ca.AxisX;
-                Axis ay = ca.AxisY;
-
-                HitTestResult hit = chart.HitTest(e.X, e.Y);
-                if (hit.Series is not null && hit.PointIndex >= 0)
-                    curPoint = hit.Series.Points[hit.PointIndex];
+                curPoint = hit.Series.Points[hit.PointIndex];
+                tip = true;
+            }
 
 
-                if (curPoint != null)
+            if (curPoint != null)
+            {
+
+                double dx, dy, dymin;
+
+                try
                 {
+                    dx = ax.PixelPositionToValue(e.X);
+                    dy = ay.PixelPositionToValue(e.Y);
 
-                    Series s = hit.Series;
-                    double dx, dy, dymin;
+                    if (dx < 20) dx = 20;
+                    if (dx > 100) dx = 100;
 
-                    try
+                    if (dy < 0) dy = 0;
+                    if (dy > fansMax) dy = fansMax;
+
+                    dymin = (dx - 65) * 1.2;
+
+                    if (dy < dymin) dy = dymin;
+
+                    if (e.Button.HasFlag(MouseButtons.Left))
                     {
-                        dx = ax.PixelPositionToValue(e.X);
-                        dy = ay.PixelPositionToValue(e.Y);
-
-                        if (dx < 20) dx = 20;
-                        if (dx > 100) dx = 100;
-
-                        if (dy < 0) dy = 0;
-                        if (dy > 100) dy = 100;
-
-                        dymin = (dx - 65) * 1.2;
-
-                        if (dy < dymin) dy = dymin;
-
                         curPoint.XValue = dx;
                         curPoint.YValues[0] = dy;
 
-                        labelTip.Visible = true;
-                        labelTip.Text = Math.Round(dx) + "C, " + ChartPercToRPM((int)dy, " RPM");
-                        labelTip.Top = e.Y + ((Control)sender).Top;
-                        labelTip.Left = e.X;
+                        if (hit.Series is not null)
+                            AdjustAllLevels(hit.PointIndex, dx, dy, hit.Series);
 
+                        tip = true;
                     }
-                    catch
+
+                    labelTip.Text = Math.Round(curPoint.XValue) + "C, " + ChartPercToRPM((int)curPoint.YValues[0], " " + Properties.Strings.RPM);
+                    labelTip.Top = e.Y + ((Control)sender).Top;
+                    labelTip.Left = e.X - 50;
+
+                }
+                catch
+                {
+                    Debug.WriteLine(e.Y);
+                    tip = false;
+                }
+
+            }
+
+            labelTip.Visible = tip;
+
+
+        }
+
+        private void AdjustAllLevels(int index, double curXVal, double curYVal, Series series)
+        {
+
+            // Get the neighboring DataPoints of the hit point
+            DataPoint upperPoint = null;
+            DataPoint lowerPoint = null;
+
+            if (index > 0)
+            {
+                lowerPoint = series.Points[index - 1];
+            }
+
+            if (index < series.Points.Count - 1)
+            {
+                upperPoint = series.Points[index + 1];
+            }
+
+            // Adjust the values according to the comparison between the value and its neighbors
+            if (upperPoint != null)
+            {
+                if (curYVal > upperPoint.YValues[0])
+                {
+
+                    for (int i = index + 1; i < series.Points.Count; i++)
                     {
-                        Debug.WriteLine(e.Y);
+                        DataPoint curUpper = series.Points[i];
+                        if (curUpper.YValues[0] >= curYVal) break;
+
+                        curUpper.YValues[0] = curYVal;
+                    }
+                }
+                if (curXVal > upperPoint.XValue)
+                {
+
+                    for (int i = index + 1; i < series.Points.Count; i++)
+                    {
+                        DataPoint curUpper = series.Points[i];
+                        if (curUpper.XValue >= curXVal) break;
+
+                        curUpper.XValue = curXVal;
+                    }
+                }
+            }
+
+            if (lowerPoint != null)
+            {
+                //Debug.WriteLine(curYVal + " <? " + Math.Floor(lowerPoint.YValues[0]));
+                if (curYVal <= Math.Floor(lowerPoint.YValues[0]))
+                {
+                    for (int i = index - 1; i >= 0; i--)
+                    {
+                        DataPoint curLower = series.Points[i];
+                        if (curLower.YValues[0] < curYVal) break;
+                        curLower.YValues[0] = Math.Floor(curYVal);
+                    }
+                }
+                if (curXVal < lowerPoint.XValue)
+                {
+
+                    for (int i = index - 1; i >= 0; i--)
+                    {
+                        DataPoint curLower = series.Points[i];
+                        if (curLower.XValue <= curXVal) break;
+
+                        curLower.XValue = curXVal;
                     }
                 }
             }
         }
+
     }
 
 }

app/GHelper.csproj

@@ -13,10 +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.46</AssemblyVersion>
+    <AssemblyVersion>0.63</AssemblyVersion>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebugType>embedded</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DebugType>embedded</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <DebugType>embedded</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <ItemGroup>
@@ -45,8 +61,7 @@
   <ItemGroup>
     <PackageReference Include="hidlibrary" Version="3.3.40" />
     <PackageReference Include="HidSharpCore" Version="1.2.1.1" />
-    <PackageReference Include="NvAPIWrapper.Net" Version="0.8.1.101" />
-    <PackageReference Include="System.Management" Version="7.0.0" />
+    <PackageReference Include="System.Management" Version="7.0.1" />
     <PackageReference Include="TaskScheduler" Version="2.10.1" />
     <PackageReference Include="WinForms.DataVisualization" Version="1.8.0" />
   </ItemGroup>
@@ -78,6 +93,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
+    <Compile Update="Properties\Strings.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
     <Compile Update="Properties\Settings.Designer.cs">
       <DesignTimeSharedInput>True</DesignTimeSharedInput>
       <AutoGen>True</AutoGen>
@@ -86,6 +106,20 @@
   </ItemGroup>
 
   <ItemGroup>
+    <EmbeddedResource Update="Properties\Resources.uk.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+    </EmbeddedResource>
+    <EmbeddedResource Update="Properties\Resources.uk.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+    </EmbeddedResource>
+    <EmbeddedResource Update="Properties\Strings.uk.resx">
+      <LastGenOutput>Strings.uk.Designer.cs</LastGenOutput>
+      <Generator>ResXFileCodeGenerator</Generator>
+    </EmbeddedResource>
+    <EmbeddedResource Update="Properties\Strings.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
     <EmbeddedResource Update="Properties\Resources.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>

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 = Release|x64
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Release|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/AmdGpuControl.cs

@@ -4,12 +4,15 @@ using AmdAdl2;
 namespace GHelper.Gpu;
 
 // Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
-public class AmdGpuTemperatureProvider : IGpuTemperatureProvider {
+public class AmdGpuControl : IGpuControl {
     private bool _isReady;
     private IntPtr _adlContextHandle;
     private readonly ADLAdapterInfo _internalDiscreteAdapter;
 
-    public AmdGpuTemperatureProvider() {
+    public bool IsNvidia => false;
+
+    public string FullName => _internalDiscreteAdapter!.AdapterName;
+    public AmdGpuControl() {
         if (!Adl2.Load())
             return;
 
@@ -73,6 +76,24 @@ public class AmdGpuTemperatureProvider : IGpuTemperatureProvider {
         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);
@@ -86,7 +107,7 @@ public class AmdGpuTemperatureProvider : IGpuTemperatureProvider {
         GC.SuppressFinalize(this);
     }
 
-    ~AmdGpuTemperatureProvider() {
+    ~AmdGpuControl() {
         ReleaseUnmanagedResources();
     }
 }

app/Gpu/IGpuControl.cs

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

app/Gpu/IGpuTemperatureProvider.cs

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

app/Gpu/NvidiaGpuControl.cs

@@ -0,0 +1,203 @@
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Delegates;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.GPU;
+using System;
+using System.Diagnostics;
+using System.Management;
+using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
+
+namespace GHelper.Gpu;
+
+public class NvidiaGpuControl : IGpuControl
+{
+
+    public const int MaxCoreOffset = 250;
+    public const int MaxMemoryOffset = 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 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}");
+            return 0;
+
+        } catch (Exception ex)
+        {
+            Logger.WriteLine("GET GPU CLOCKS:" + ex.Message);
+            core = memory = 0; 
+            return -1;
+        }
+
+    }
+
+    private 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();
+    }
+
+
+    public bool RestartGPUPnP()
+    {
+
+        if (!IsValid) return false;
+
+        try
+        {
+            PhysicalGPU internalGpu = _internalGpu!;
+            var pnpDeviceId = internalGpu.BusInformation.PCIIdentifiers.ToString();
+            Logger.WriteLine("Device ID:" + pnpDeviceId);
+            RunCMD("pnputil", $"/disable-device /deviceid \"{pnpDeviceId}\"");
+            Thread.Sleep(3000);
+            RunCMD("pnputil", $"/enable-device /deviceid \"{pnpDeviceId}\"");
+            Thread.Sleep(2000);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.ToString());
+            return false;
+        }
+    }
+
+    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);
+            RunCMD("powershell", script);
+            //Thread.Sleep(2000);
+            return true;
+        }
+        catch (Exception ex )
+        {
+            Logger.WriteLine(ex.ToString());
+            return false;
+        }
+    }
+
+    public int SetClocksFromConfig()
+    {
+        int core = Program.config.getConfig("gpu_core");
+        int memory = Program.config.getConfig("gpu_memory");
+        int status = SetClocks(core, memory);
+        return status;
+    }
+
+    public int SetClocks(int core, int memory)
+    {
+
+        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));
+
+        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)
+        {
+            Logger.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/NvidiaGpuTemperatureProvider.cs

@@ -1,42 +0,0 @@
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Exceptions;
-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;
-        }
-    }
-}

app/HardwareControl.cs

@@ -0,0 +1,177 @@
+using GHelper;
+using GHelper.Gpu;
+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;
+        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 && fan < 110) 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 = 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.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 (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.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 = 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;
+                return;
+            }
+
+            _gpuControl.Dispose();
+
+            _gpuControl = new AmdGpuControl();
+            if (_gpuControl.IsValid)
+            {
+                GpuControl = _gpuControl;
+                return;
+            }
+            _gpuControl.Dispose();
+
+            GpuControl = null;
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.ToString());
+        }
+    }
+}

app/HardwareMonitor.cs

@@ -1,142 +0,0 @@
-using System.Diagnostics;
-using GHelper;
-using GHelper.Gpu;
-
-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 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
-    }
-
-    public static void ReadSensors()
-    {
-        batteryDischarge = -1;
-        gpuTemp = -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
-        {
-            var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
-            cpuTemp = ct.NextValue() - 273;
-            ct.Dispose();
-        } catch
-        {
-            Logger.WriteLine("Failed reading CPU temp");
-        }
-
-        if (gpuTemp < 0)  try
-        {
-           if (GpuTemperatureProvider is null) RecreateGpuTemperatureProvider();
-           gpuTemp = GpuTemperatureProvider?.GetCurrentTemperature();
-
-        }
-        catch (Exception ex) {
-            gpuTemp = -1;
-            Logger.WriteLine("Failed reading GPU temp");
-            Logger.WriteLine(ex.ToString());
-        }
-
-        if (gpuTemp is null || gpuTemp < 0)
-            gpuTemp = Program.wmi.DeviceGet(ASUSWmi.Temp_GPU);
-
-
-        try
-        {
-            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
-            batteryDischarge = cb.NextValue() / 1000;
-            cb.Dispose();
-
-        }
-        catch
-        {
-            Logger.WriteLine("Failed reading Battery discharge");
-        }
-    }
-
-    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/Keyboard.Designer.cs

@@ -1,329 +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();
-            checkKeyboardAuto = new CheckBox();
-            checkTopmost = new CheckBox();
-            checkNoOverdrive = new CheckBox();
-            groupBox1.SuspendLayout();
-            groupLight.SuspendLayout();
-            groupOther.SuspendLayout();
-            SuspendLayout();
-            // 
-            // groupBox1
-            // 
-            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(756, 242);
-            groupBox1.TabIndex = 0;
-            groupBox1.TabStop = false;
-            groupBox1.Text = "Key Bindings";
-            // 
-            // textFNF4
-            // 
-            textFNF4.Location = new Point(411, 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;
-            // 
-            // 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(411, 113);
-            textM4.Name = "textM4";
-            textM4.PlaceholderText = "action";
-            textM4.Size = new Size(320, 39);
-            textM4.TabIndex = 5;
-            // 
-            // textM3
-            // 
-            textM3.Location = new Point(411, 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[] { "Performance Mode", "Open G-Helper window", "Custom" });
-            comboM4.Location = new Point(93, 112);
-            comboM4.Name = "comboM4";
-            comboM4.Size = new Size(312, 40);
-            comboM4.TabIndex = 3;
-            // 
-            // 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[] { "Default", "Volume Mute", "Play / Pause", "PrintScreen", "Toggle Aura", "Custom" });
-            comboM3.Location = new Point(93, 54);
-            comboM3.Name = "comboM3";
-            comboM3.Size = new Size(312, 40);
-            comboM3.TabIndex = 1;
-            // 
-            // 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(756, 304);
-            groupLight.TabIndex = 1;
-            groupLight.TabStop = false;
-            groupLight.Text = "Keyboard Backlight";
-            // 
-            // labelSpeed
-            // 
-            labelSpeed.AutoSize = true;
-            labelSpeed.Location = new Point(25, 237);
-            labelSpeed.Name = "labelSpeed";
-            labelSpeed.Size = new Size(198, 32);
-            labelSpeed.TabIndex = 40;
-            labelSpeed.Text = "Animation Speed";
-            // 
-            // 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 = "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 = "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 = "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 = "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, 556);
-            groupOther.Name = "groupOther";
-            groupOther.Size = new Size(756, 225);
-            groupOther.TabIndex = 2;
-            groupOther.TabStop = false;
-            groupOther.Text = "Other";
-            // 
-            // checkKeyboardAuto
-            // 
-            checkKeyboardAuto.AutoSize = true;
-            checkKeyboardAuto.Location = new Point(25, 51);
-            checkKeyboardAuto.Name = "checkKeyboardAuto";
-            checkKeyboardAuto.Size = new Size(712, 36);
-            checkKeyboardAuto.TabIndex = 2;
-            checkKeyboardAuto.Text = "Lower backlight brightness on battery and back when plugged";
-            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 = "Keep app window always on top";
-            checkTopmost.UseVisualStyleBackColor = true;
-            // 
-            // checkNoOverdrive
-            // 
-            checkNoOverdrive.AutoSize = true;
-            checkNoOverdrive.Location = new Point(25, 156);
-            checkNoOverdrive.Name = "checkNoOverdrive";
-            checkNoOverdrive.Size = new Size(307, 36);
-            checkNoOverdrive.TabIndex = 3;
-            checkNoOverdrive.Text = "Disable screen overdrive";
-            checkNoOverdrive.UseVisualStyleBackColor = true;
-            // 
-            // Keyboard
-            // 
-            AutoScaleDimensions = new SizeF(13F, 32F);
-            AutoScaleMode = AutoScaleMode.Font;
-            ClientSize = new Size(776, 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 = "Extra Settings";
-            groupBox1.ResumeLayout(false);
-            groupBox1.PerformLayout();
-            groupLight.ResumeLayout(false);
-            groupLight.PerformLayout();
-            groupOther.ResumeLayout(false);
-            groupOther.PerformLayout();
-            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;
-    }
-}

app/Keyboard.cs

@@ -1,132 +0,0 @@
-using CustomControls;
-
-namespace GHelper
-{
-    public partial class Keyboard : RForm
-    {
-
-        Dictionary<string, string> customActions = new Dictionary<string, string>
-        {
-          {"","--------------" },
-          {"mute", "Volume Mute"},
-          {"screenshot", "Screenshot"},
-          {"play", "Play/Pause"},
-          {"aura", "Aura"},
-          {"ghelper", "Open GHelper"},
-          {"custom", "Custom"}
-        };
-
-        private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
-        {
-            if (name == "m4")
-                customActions[""] = "Performance";
-
-            if (name == "fnf4")
-            {
-                customActions[""] = "Aura";
-                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;
-
-        }
-
-        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/NativeMethods.cs

@@ -1,12 +1,54 @@
-using System.ComponentModel;
+using GHelper;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using System.Xml.Linq;
 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
     {
         public const int ERROR_SUCCESS = 0;
@@ -309,6 +351,33 @@ namespace Tools
 public class NativeMethods
 {
 
+    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;
@@ -578,12 +647,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;
         }
 
 
@@ -608,7 +679,8 @@ public class NativeMethods
                 if (dm.dmDisplayFrequency > frequency) frequency = dm.dmDisplayFrequency;
                 i++;
             }
-        } else
+        }
+        else
         {
             if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
             {
@@ -675,7 +747,6 @@ public class NativeMethods
 
         PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
 
-        /*
         var hrDC = PowerWriteDCValueIndex(
              IntPtr.Zero,
              activeSchemeGuid,
@@ -684,11 +755,17 @@ public class NativeMethods
              boost);
 
         PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
-        */
 
         Logger.WriteLine("Boost " + boost);
     }
 
+    public static void SetPowerScheme(string scheme)
+    {
+        PowerSetActiveScheme(IntPtr.Zero, new Guid(scheme));
+        PowerSetActiveOverlayScheme(new Guid(scheme));
+        Logger.WriteLine(scheme);
+    }
+
     public static void SetPowerScheme(int mode)
     {
         switch (mode)

app/NvAPIWrapper/Display/ColorData.cs

@@ -0,0 +1,200 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <inheritdoc cref="IColorData" />
+    public class ColorData : IColorData, IEquatable<ColorData>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="ColorData" /> to modify the color data
+        /// </summary>
+        /// <param name="colorFormat">The color data color format.</param>
+        /// <param name="colorimetry">The color data color space.</param>
+        /// <param name="dynamicRange">The color data dynamic range.</param>
+        /// <param name="colorDepth">The color data color depth.</param>
+        /// <param name="colorSelectionPolicy">The color data selection policy.</param>
+        /// <param name="desktopColorDepth">The color data desktop color depth.</param>
+        public ColorData(
+            ColorDataFormat colorFormat = ColorDataFormat.Auto,
+            ColorDataColorimetry colorimetry = ColorDataColorimetry.Auto,
+            ColorDataDynamicRange? dynamicRange = null,
+            ColorDataDepth? colorDepth = null,
+            ColorDataSelectionPolicy? colorSelectionPolicy = null,
+            ColorDataDesktopDepth? desktopColorDepth = null
+        )
+        {
+            ColorFormat = colorFormat;
+            Colorimetry = colorimetry;
+            DynamicRange = dynamicRange;
+            ColorDepth = colorDepth;
+            SelectionPolicy = colorSelectionPolicy;
+            DesktopColorDepth = desktopColorDepth;
+        }
+
+        internal ColorData(IColorData colorData)
+        {
+            ColorDepth = colorData.ColorDepth;
+            DynamicRange = colorData.DynamicRange;
+            ColorFormat = colorData.ColorFormat;
+            Colorimetry = colorData.Colorimetry;
+            SelectionPolicy = colorData.SelectionPolicy;
+            DesktopColorDepth = colorData.DesktopColorDepth;
+        }
+
+        /// <inheritdoc />
+        public ColorDataDepth? ColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataFormat ColorFormat { get; }
+
+        /// <inheritdoc />
+        public ColorDataColorimetry Colorimetry { get; }
+
+        /// <inheritdoc />
+        public ColorDataDesktopDepth? DesktopColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataDynamicRange? DynamicRange { get; }
+
+        /// <inheritdoc />
+        public ColorDataSelectionPolicy? SelectionPolicy { get; }
+
+        /// <inheritdoc />
+        public bool Equals(ColorData other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return ColorDepth == other.ColorDepth &&
+                   ColorFormat == other.ColorFormat &&
+                   Colorimetry == other.Colorimetry &&
+                   DesktopColorDepth == other.DesktopColorDepth &&
+                   DynamicRange == other.DynamicRange &&
+                   SelectionPolicy == other.SelectionPolicy;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="ColorData" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are equal; otherwise false.</returns>
+        public static bool operator ==(ColorData left, ColorData right)
+        {
+            return left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="ColorData" /> for inequality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are not equal; otherwise false.</returns>
+        public static bool operator !=(ColorData left, ColorData right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((ColorData) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = ColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ (int) Colorimetry;
+                hashCode = (hashCode * 397) ^ DesktopColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
+                hashCode = (hashCode * 397) ^ SelectionPolicy.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal ColorDataV1 AsColorDataV1(ColorDataCommand command)
+        {
+            return new ColorDataV1(
+                command,
+                ColorFormat,
+                Colorimetry
+            );
+        }
+
+        internal ColorDataV2 AsColorDataV2(ColorDataCommand command)
+        {
+            return new ColorDataV2(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto
+            );
+        }
+
+        internal ColorDataV3 AsColorDataV3(ColorDataCommand command)
+        {
+            return new ColorDataV3(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default
+            );
+        }
+
+        internal ColorDataV4 AsColorDataV4(ColorDataCommand command)
+        {
+            return new ColorDataV4(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default,
+                SelectionPolicy ?? ColorDataSelectionPolicy.Default
+            );
+        }
+
+        internal ColorDataV5 AsColorDataV5(ColorDataCommand command)
+        {
+            return new ColorDataV5(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default,
+                SelectionPolicy ?? ColorDataSelectionPolicy.Default,
+                DesktopColorDepth ?? ColorDataDesktopDepth.Default
+            );
+        }
+    }
+}

app/NvAPIWrapper/Display/CustomResolution.cs

@@ -0,0 +1,245 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Hold information about a custom display resolution
+    /// </summary>
+    public class CustomResolution : IEquatable<CustomResolution>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="CustomResolution" />.
+        /// </summary>
+        /// <param name="width">The screen width.</param>
+        /// <param name="height">The screen height.</param>
+        /// <param name="colorFormat">The color format.</param>
+        /// <param name="timing">The resolution timing.</param>
+        /// <param name="xRatio">The horizontal scaling ratio.</param>
+        /// <param name="yRatio">The vertical scaling ratio.</param>
+        public CustomResolution(
+            uint width,
+            uint height,
+            ColorFormat colorFormat,
+            Timing timing,
+            float xRatio = 1,
+            float yRatio = 1
+        )
+        {
+            if (xRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(xRatio));
+            }
+
+            if (yRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(yRatio));
+            }
+
+            Width = width;
+            Height = height;
+            ColorFormat = colorFormat;
+            XRatio = xRatio;
+            YRatio = yRatio;
+            Timing = timing;
+
+            switch (ColorFormat)
+            {
+                case ColorFormat.P8:
+                    ColorDepth = 8;
+
+                    break;
+                case ColorFormat.R5G6B5:
+                    ColorDepth = 16;
+
+                    break;
+                case ColorFormat.A8R8G8B8:
+                    ColorDepth = 24;
+
+                    break;
+                case ColorFormat.A16B16G16R16F:
+                    ColorDepth = 32;
+
+                    break;
+                default:
+                    throw new ArgumentException("Color format is invalid.", nameof(colorFormat));
+            }
+        }
+
+        /// <summary>
+        ///     Creates an instance of <see cref="CustomResolution" />.
+        /// </summary>
+        /// <param name="width">The screen width.</param>
+        /// <param name="height">The screen height.</param>
+        /// <param name="colorDepth">The color depth.</param>
+        /// <param name="timing">The resolution timing.</param>
+        /// <param name="xRatio">The horizontal scaling ratio.</param>
+        /// <param name="yRatio">The vertical scaling ratio.</param>
+        public CustomResolution(
+            uint width,
+            uint height,
+            uint colorDepth,
+            Timing timing,
+            float xRatio = 1,
+            float yRatio = 1)
+        {
+            if (xRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(xRatio));
+            }
+
+            if (yRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(yRatio));
+            }
+
+            if (colorDepth != 0 && colorDepth != 8 && colorDepth != 16 && colorDepth != 24 && colorDepth != 32)
+            {
+                throw new ArgumentOutOfRangeException(nameof(colorDepth));
+            }
+
+            Width = width;
+            Height = height;
+            ColorDepth = colorDepth;
+            ColorFormat = ColorFormat.Unknown;
+            XRatio = xRatio;
+            YRatio = yRatio;
+            Timing = timing;
+        }
+
+        internal CustomResolution(CustomDisplay customDisplay)
+        {
+            Width = customDisplay.Width;
+            Height = customDisplay.Height;
+            ColorDepth = customDisplay.Depth;
+            ColorFormat = customDisplay.ColorFormat;
+            Timing = customDisplay.Timing;
+            XRatio = customDisplay.XRatio;
+            YRatio = customDisplay.YRatio;
+        }
+
+        /// <summary>
+        ///     Gets the source surface color depth. "0" means all 8/16/32bpp.
+        /// </summary>
+        public uint ColorDepth { get; }
+
+        /// <summary>
+        ///     Gets the color format (optional)
+        /// </summary>
+        public ColorFormat ColorFormat { get; }
+
+        /// <summary>
+        ///     Gets the source surface (source mode) height.
+        /// </summary>
+        public uint Height { get; }
+
+        /// <summary>
+        ///     Gets the timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc.
+        /// </summary>
+        public Timing Timing { get; }
+
+        /// <summary>
+        ///     Gets the source surface (source mode) width.
+        /// </summary>
+        public uint Width { get; }
+
+        /// <summary>
+        ///     Gets the horizontal scaling ratio.
+        /// </summary>
+        public float XRatio { get; }
+
+        /// <summary>
+        ///     Gets the vertical scaling ratio.
+        /// </summary>
+        public float YRatio { get; }
+
+        /// <inheritdoc />
+        public bool Equals(CustomResolution other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Width == other.Width &&
+                   Height == other.Height &&
+                   ColorDepth == other.ColorDepth &&
+                   Timing.Equals(other.Timing) &&
+                   ColorFormat == other.ColorFormat &&
+                   XRatio.Equals(other.XRatio) &&
+                   YRatio.Equals(other.YRatio);
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="CustomResolution" /> for equality.
+        /// </summary>
+        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <returns>True if both instances are equal, otherwise false.</returns>
+        public static bool operator ==(CustomResolution left, CustomResolution right)
+        {
+            return Equals(left, right);
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="CustomResolution" /> for inequality.
+        /// </summary>
+        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <returns>True if both instances are not equal, otherwise false.</returns>
+        public static bool operator !=(CustomResolution left, CustomResolution right)
+        {
+            return !Equals(left, right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((CustomResolution) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) Width;
+                hashCode = (hashCode * 397) ^ (int) Height;
+                hashCode = (hashCode * 397) ^ (int) ColorDepth;
+                hashCode = (hashCode * 397) ^ Timing.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ XRatio.GetHashCode();
+                hashCode = (hashCode * 397) ^ YRatio.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal CustomDisplay AsCustomDisplay(bool hardwareModeSetOnly)
+        {
+            return new CustomDisplay(Width, Height, ColorDepth, ColorFormat, XRatio, YRatio, Timing,
+                hardwareModeSetOnly);
+        }
+    }
+}

app/NvAPIWrapper/Display/DVCInformation.cs

@@ -0,0 +1,325 @@
+using System;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     This class contains and provides a way to modify the Digital Vibrance Control information regarding the
+    ///     saturation level of the display or the output
+    /// </summary>
+    public class DVCInformation : IDisplayDVCInfo
+    {
+        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
+        private readonly OutputId _outputId = OutputId.Invalid;
+        private bool? _isLegacy;
+
+        /// <summary>
+        ///     Creates a new instance of the class using a DisplayHandle
+        /// </summary>
+        /// <param name="displayHandle">The handle of the display.</param>
+        public DVCInformation(DisplayHandle displayHandle)
+        {
+            _displayHandle = displayHandle;
+        }
+
+        /// <summary>
+        ///     Creates a new instance of this class using a OutputId
+        /// </summary>
+        /// <param name="outputId">The output identification of a display or an output</param>
+        public DVCInformation(OutputId outputId)
+        {
+            _outputId = outputId;
+        }
+
+        /// <summary>
+        ///     Gets and sets the normalized saturation level in the [-1,1] inclusive range.
+        ///     a -1 value corresponds to the minimum saturation level and maximum under-saturation and the
+        ///     a 1 value corresponds to the maximum saturation level and maximum over-saturation.
+        ///     The value of 0 indicates the default saturation level.
+        /// </summary>
+        public double NormalizedLevel
+        {
+            get
+            {
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return double.NaN;
+                }
+
+                var deviance = info.CurrentLevel - info.DefaultLevel;
+                var range = deviance >= 0
+                    ? info.MaximumLevel - info.DefaultLevel
+                    : info.DefaultLevel - info.MinimumLevel;
+
+                if (deviance == 0 || range == 0)
+                {
+                    return 0;
+                }
+
+                return Math.Max(Math.Min((double) deviance / range, 1), -1);
+            }
+            set
+            {
+                if (double.IsNaN(value) || double.IsInfinity(value))
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return;
+                }
+
+                var range = value >= 0 ? info.MaximumLevel - info.DefaultLevel : info.DefaultLevel - info.MinimumLevel;
+                var level = Math.Max(Math.Min((int) (value * range) + info.DefaultLevel, info.MaximumLevel), info.MinimumLevel);
+
+                if (level == info.CurrentLevel)
+                {
+                    return;
+                }
+
+                SetLevel(level);
+            }
+        }
+
+        /// <summary>
+        ///     Gets and sets the current saturation level
+        /// </summary>
+        public int CurrentLevel
+        {
+            get => GetInfo()?.CurrentLevel ?? 0;
+            set
+            {
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return;
+                }
+
+                value = Math.Max(Math.Min(value, info.MaximumLevel), info.MinimumLevel);
+
+                if (info.CurrentLevel == value)
+                {
+                    return;
+                }
+
+                SetLevel(value);
+            }
+        }
+
+        /// <inheritdoc />
+        public int DefaultLevel
+        {
+            get => GetInfo()?.DefaultLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public int MaximumLevel
+        {
+            get => GetInfo()?.MaximumLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public int MinimumLevel
+        {
+            get => GetInfo()?.MinimumLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"{CurrentLevel:D} @ [{MinimumLevel:D} <= {DefaultLevel:D} <= {MaximumLevel:D}] = {NormalizedLevel:F2}";
+        }
+
+        private IDisplayDVCInfo GetInfo()
+        {
+            if (_isLegacy == true)
+            {
+                return GetLegacyInfo();
+            }
+
+            if (_isLegacy == false)
+            {
+                return GetModernInfo();
+            }
+
+            var info = GetModernInfo() ?? GetLegacyInfo();
+
+            if (info == null)
+            {
+                // exception occured on both, force a mode
+                _isLegacy = false;
+
+                return GetInfo();
+            }
+
+            return info;
+        }
+
+        private IDisplayDVCInfo GetLegacyInfo()
+        {
+            try
+            {
+                var info = _outputId == OutputId.Invalid
+                    ? DisplayApi.GetDVCInfo(_displayHandle)
+                    : DisplayApi.GetDVCInfo(_outputId);
+
+                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
+                {
+                    return null;
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = true;
+                }
+
+
+                return info;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == true)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return null;
+        }
+
+        private IDisplayDVCInfo GetModernInfo()
+        {
+            try
+            {
+                var info = _outputId == OutputId.Invalid
+                    ? DisplayApi.GetDVCInfoEx(_displayHandle)
+                    : DisplayApi.GetDVCInfoEx(_outputId);
+
+                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
+                {
+                    return null;
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = false;
+                }
+
+                return info;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == false)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return null;
+        }
+
+        private bool SetLegacyLevel(int level)
+        {
+            try
+            {
+                if (_outputId == OutputId.Invalid)
+                {
+                    DisplayApi.SetDVCLevel(_displayHandle, level);
+                }
+                else
+                {
+                    DisplayApi.SetDVCLevel(_outputId, level);
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = true;
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == true)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return false;
+        }
+
+        private void SetLevel(int level)
+        {
+            if (_isLegacy == true)
+            {
+                SetLegacyLevel(level);
+            }
+            else if (_isLegacy == false)
+            {
+                SetModernLevel(level);
+            }
+            else
+            {
+                var success = SetModernLevel(level) || SetLegacyLevel(level);
+
+                if (!success)
+                {
+                    // exception occured on both, force a mode
+                    _isLegacy = false;
+
+                    SetLevel(level);
+                }
+            }
+        }
+
+        private bool SetModernLevel(int level)
+        {
+            try
+            {
+                if (_outputId == OutputId.Invalid)
+                {
+                    DisplayApi.SetDVCLevelEx(_displayHandle, level);
+                }
+                else
+                {
+                    DisplayApi.SetDVCLevelEx(_outputId, level);
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = false;
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == false)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return false;
+        }
+    }
+}

app/NvAPIWrapper/Display/Display.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an attached display
+    /// </summary>
+    public class Display : IEquatable<Display>
+    {
+        /// <summary>
+        ///     Creates a new Display
+        /// </summary>
+        /// <param name="handle">Handle of the display device</param>
+        public Display(DisplayHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Creates a new Display
+        /// </summary>
+        /// <param name="displayName">Name of the display device</param>
+        public Display(string displayName)
+        {
+            Handle = DisplayApi.GetAssociatedNvidiaDisplayHandle(displayName);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding Digital Vibrance Control information
+        /// </summary>
+        public DVCInformation DigitalVibranceControl
+        {
+            get => new DVCInformation(Handle);
+        }
+
+        /// <summary>
+        ///     Gets corresponding DisplayDevice based on display name
+        /// </summary>
+        public DisplayDevice DisplayDevice
+        {
+            get => new DisplayDevice(Name);
+        }
+
+        /// <summary>
+        ///     Gets display driver build title
+        /// </summary>
+        public string DriverBuildTitle
+        {
+            get => DisplayApi.GetDisplayDriverBuildTitle(Handle);
+        }
+
+        /// <summary>
+        ///     Gets display handle
+        /// </summary>
+        public DisplayHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets the display HDMI support information
+        /// </summary>
+        public IHDMISupportInfo HDMISupportInfo
+        {
+            get
+            {
+                var outputId = OutputId.Invalid;
+                try
+                {
+                    outputId = DisplayApi.GetAssociatedDisplayOutputId(Handle);
+                }
+                catch (NVIDIAApiException)
+                {
+                    // ignore
+                }
+                return DisplayApi.GetHDMISupportInfo(Handle, outputId);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the corresponding HUE information
+        /// </summary>
+        public HUEInformation HUEControl
+        {
+            get => new HUEInformation(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the driving logical GPU
+        /// </summary>
+        public LogicalGPU LogicalGPU
+        {
+            get => new LogicalGPU(GPUApi.GetLogicalGPUFromDisplay(Handle));
+        }
+
+        /// <summary>
+        ///     Gets display name
+        /// </summary>
+        public string Name
+        {
+            get => DisplayApi.GetAssociatedNvidiaDisplayName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the connected GPU output
+        /// </summary>
+        public GPUOutput Output
+        {
+            get => new GPUOutput(DisplayApi.GetAssociatedDisplayOutputId(Handle), PhysicalGPUs.FirstOrDefault());
+        }
+
+        /// <summary>
+        ///     Gets the list of all physical GPUs responsible for this display, with the first GPU returned as the one with the
+        ///     attached active output.
+        /// </summary>
+        public PhysicalGPU[] PhysicalGPUs
+        {
+            get => GPUApi.GetPhysicalGPUsFromDisplay(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <inheritdoc />
+        public bool Equals(Display other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     This function returns all NVIDIA displays
+        ///     Note: Display handles can get invalidated on a modeset.
+        /// </summary>
+        /// <returns>An array of Display objects</returns>
+        public static Display[] GetDisplays()
+        {
+            return DisplayApi.EnumNvidiaDisplayHandle().Select(handle => new Display(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(Display left, Display right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(Display left, Display right)
+        {
+            return !(right == left);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((Display) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        /// <summary>
+        ///     Gets all the supported NVIDIA display views (nView and Dualview modes) for this display.
+        /// </summary>
+        /// <returns></returns>
+        public TargetViewMode[] GetSupportedViews()
+        {
+            return DisplayApi.GetSupportedViews(Handle);
+        }
+
+        /// <summary>
+        ///     Overrides the refresh rate on this display.
+        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
+        ///     mode-set.
+        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
+        /// </summary>
+        /// <param name="refreshRate">The refresh rate to be applied.</param>
+        /// <param name="isDeferred">
+        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
+        ///     mode-set.
+        /// </param>
+        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
+        {
+            DisplayApi.SetRefreshRateOverride(Handle, refreshRate, isDeferred);
+        }
+    }
+}

app/NvAPIWrapper/Display/DisplayDevice.cs

@@ -0,0 +1,893 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an NVIDIA display device
+    /// </summary>
+    public class DisplayDevice : IEquatable<DisplayDevice>
+    {
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayId">Display identification of the device</param>
+        public DisplayDevice(uint displayId)
+        {
+            DisplayId = displayId;
+            var extraInformation = PhysicalGPU.GetDisplayDevices().FirstOrDefault(ids => ids.DisplayId == DisplayId);
+
+            if (extraInformation != null)
+            {
+                IsAvailable = true;
+                ScanOutInformation = new ScanOutInformation(this);
+                ConnectionType = extraInformation.ConnectionType;
+                IsDynamic = extraInformation.IsDynamic;
+                IsMultiStreamRootNode = extraInformation.IsMultiStreamRootNode;
+                IsActive = extraInformation.IsActive;
+                IsCluster = extraInformation.IsCluster;
+                IsOSVisible = extraInformation.IsOSVisible;
+                IsWFD = extraInformation.IsWFD;
+                IsConnected = extraInformation.IsConnected;
+                IsPhysicallyConnected = extraInformation.IsPhysicallyConnected;
+            }
+        }
+
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayIds">Display identification and attributes of the display device</param>
+        public DisplayDevice(IDisplayIds displayIds)
+        {
+            IsAvailable = true;
+            DisplayId = displayIds.DisplayId;
+            ScanOutInformation = new ScanOutInformation(this);
+            ConnectionType = displayIds.ConnectionType;
+            IsDynamic = displayIds.IsDynamic;
+            IsMultiStreamRootNode = displayIds.IsMultiStreamRootNode;
+            IsActive = displayIds.IsActive;
+            IsCluster = displayIds.IsCluster;
+            IsOSVisible = displayIds.IsOSVisible;
+            IsWFD = displayIds.IsWFD;
+            IsConnected = displayIds.IsConnected;
+            IsPhysicallyConnected = displayIds.IsPhysicallyConnected;
+        }
+
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayName">Display name of the display device</param>
+        public DisplayDevice(string displayName) : this(DisplayApi.GetDisplayIdByDisplayName(displayName))
+        {
+        }
+
+        /// <summary>
+        ///     Gets the display device connection type
+        /// </summary>
+        public MonitorConnectionType ConnectionType { get; }
+
+        /// <summary>
+        ///     Gets the current display color data
+        /// </summary>
+        public ColorData CurrentColorData
+        {
+            get
+            {
+                var instances = new IColorData[]
+                {
+                    new ColorDataV5(ColorDataCommand.Get),
+                    new ColorDataV4(ColorDataCommand.Get),
+                    new ColorDataV3(ColorDataCommand.Get),
+                    new ColorDataV2(ColorDataCommand.Get),
+                    new ColorDataV1(ColorDataCommand.Get)
+                };
+
+                var instance = DisplayApi.ColorControl(DisplayId, instances);
+
+                return new ColorData(instance);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current display device timing
+        /// </summary>
+        public Timing CurrentTiming
+        {
+            get => DisplayApi.GetTiming(DisplayId, new TimingInput(TimingOverride.Current));
+        }
+
+        /// <summary>
+        ///     Gets the default display color data
+        /// </summary>
+        public ColorData DefaultColorData
+        {
+            get
+            {
+                var instances = new IColorData[]
+                {
+                    new ColorDataV5(ColorDataCommand.GetDefault),
+                    new ColorDataV4(ColorDataCommand.GetDefault),
+                    new ColorDataV3(ColorDataCommand.GetDefault),
+                    new ColorDataV2(ColorDataCommand.GetDefault),
+                    new ColorDataV1(ColorDataCommand.GetDefault)
+                };
+
+                var instance = DisplayApi.ColorControl(DisplayId, instances);
+
+                return new ColorData(instance);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the NVIDIA display identification
+        /// </summary>
+        public uint DisplayId { get; }
+
+        /// <summary>
+        ///     Gets the monitor Display port capabilities
+        /// </summary>
+        public MonitorColorData[] DisplayPortColorCapabilities
+        {
+            get
+            {
+                if (ConnectionType != MonitorConnectionType.DisplayPort)
+                {
+                    return null;
+                }
+
+                return DisplayApi.GetMonitorColorCapabilities(DisplayId);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the display driver EDID specified HDR capabilities
+        /// </summary>
+        public HDRCapabilitiesV1 DriverHDRCapabilities
+        {
+            get => DisplayApi.GetHDRCapabilities(DisplayId, true);
+        }
+
+        /// <summary>
+        ///     Gets the display currently effective HDR capabilities
+        /// </summary>
+        public HDRCapabilitiesV1 EffectiveHDRCapabilities
+        {
+            get => DisplayApi.GetHDRCapabilities(DisplayId, false);
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame current information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameCurrentInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame default information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameDefaultInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame override information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameOverrideInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame property information
+        /// </summary>
+        public InfoFrameProperty? HDMIAudioFramePropertyInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.PropertyInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the device HDMI support information
+        /// </summary>
+        public IHDMISupportInfo HDMISupportInfo
+        {
+            get => DisplayApi.GetHDMISupportInfo(DisplayId);
+        }
+
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame current information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameCurrentInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame =
+                        new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame default information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameDefaultInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame override information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameOverrideInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame property information
+        /// </summary>
+        public InfoFrameProperty? HDMIVideoFramePropertyInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.PropertyInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDR color data, or null if the HDR is disabled or unavailable
+        /// </summary>
+        public HDRColorData HDRColorData
+        {
+            get
+            {
+                try
+                {
+                    var instances = new IHDRColorData[]
+                    {
+                        new HDRColorDataV2(ColorDataHDRCommand.Get),
+                        new HDRColorDataV1(ColorDataHDRCommand.Get)
+                    };
+
+                    var instance = DisplayApi.HDRColorControl(DisplayId, instances);
+
+                    if (instance.HDRMode == ColorDataHDRMode.Off)
+                    {
+                        return null;
+                    }
+
+                    return new HDRColorData(instance);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Indicates if the display is being actively driven
+        /// </summary>
+        public bool IsActive { get; }
+
+        /// <summary>
+        ///     Indicates if the display device is currently available
+        /// </summary>
+        public bool IsAvailable { get; }
+
+        /// <summary>
+        ///     Indicates if the display is the representative display
+        /// </summary>
+        public bool IsCluster { get; }
+
+        /// <summary>
+        ///     Indicates if the display is connected
+        /// </summary>
+        public bool IsConnected { get; }
+
+        /// <summary>
+        ///     Indicates if the display is part of MST topology and it's a dynamic
+        /// </summary>
+        public bool IsDynamic { get; }
+
+        /// <summary>
+        ///     Indicates if the display identification belongs to a multi stream enabled connector (root node). Note that when
+        ///     multi stream is enabled and a single multi stream capable monitor is connected to it, the monitor will share the
+        ///     display id with the RootNode.
+        ///     When there is more than one monitor connected in a multi stream topology, then the root node will have a separate
+        ///     displayId.
+        /// </summary>
+        public bool IsMultiStreamRootNode { get; }
+
+        /// <summary>
+        ///     Indicates if the display is reported to the OS
+        /// </summary>
+        public bool IsOSVisible { get; }
+
+        /// <summary>
+        ///     Indicates if the display is a physically connected display; Valid only when IsConnected is true
+        /// </summary>
+        public bool IsPhysicallyConnected { get; }
+
+        /// <summary>
+        ///     Indicates if the display is wireless
+        /// </summary>
+        public bool IsWFD { get; }
+
+        /// <summary>
+        ///     Gets the connected GPU output
+        /// </summary>
+        public GPUOutput Output
+        {
+            get
+            {
+                PhysicalGPUHandle handle;
+                var outputId = GPUApi.GetGPUAndOutputIdFromDisplayId(DisplayId, out handle);
+
+                return new GPUOutput(outputId, new PhysicalGPU(handle));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the connected physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU
+        {
+            get
+            {
+                try
+                {
+                    var gpuHandle = GPUApi.GetPhysicalGPUFromDisplayId(DisplayId);
+
+                    return new PhysicalGPU(gpuHandle);
+                }
+                catch
+                {
+                    // ignored
+                }
+
+                return Output.PhysicalGPU;
+            }
+        }
+
+        /// <summary>
+        ///     Gets information regarding the scan-out settings of this display device
+        /// </summary>
+        public ScanOutInformation ScanOutInformation { get; }
+
+        /// <summary>
+        ///     Gets monitor capabilities from the Video Capability Data Block if available, otherwise null
+        /// </summary>
+        public MonitorVCDBCapabilities? VCDBMonitorCapabilities
+        {
+            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VCDB)?.VCDBCapabilities;
+        }
+
+        /// <summary>
+        ///     Gets monitor capabilities from the Vendor Specific Data Block if available, otherwise null
+        /// </summary>
+        public MonitorVSDBCapabilities? VSDBMonitorCapabilities
+        {
+            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VSDB)?.VSDBCapabilities;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(DisplayDevice other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return DisplayId == other.DisplayId;
+        }
+
+        /// <summary>
+        ///     Deletes a custom resolution.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to delete.</param>
+        /// <param name="displayIds">A list of display ids to remove the custom resolution from.</param>
+        public static void DeleteCustomResolution(CustomResolution customResolution, uint[] displayIds)
+        {
+            var customDisplay = customResolution.AsCustomDisplay(false);
+            DisplayApi.DeleteCustomDisplay(displayIds, customDisplay);
+        }
+
+        /// <summary>
+        ///     Returns an instance of <see cref="DisplayDevice" /> representing the primary GDI display device.
+        /// </summary>
+        /// <returns>An instance of <see cref="DisplayDevice" />.</returns>
+        public static DisplayDevice GetGDIPrimaryDisplayDevice()
+        {
+            var displayId = DisplayApi.GetGDIPrimaryDisplayId();
+
+            if (displayId == 0)
+            {
+                return null;
+            }
+
+            return new DisplayDevice(displayId);
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(DisplayDevice left, DisplayDevice right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(DisplayDevice left, DisplayDevice right)
+        {
+            return !(right == left);
+        }
+
+        /// <summary>
+        ///     Reverts the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="displayIds">A list of display ids to revert the custom resolution from.</param>
+        public static void RevertCustomResolution(uint[] displayIds)
+        {
+            DisplayApi.RevertCustomDisplayTrial(displayIds);
+        }
+
+        /// <summary>
+        ///     Saves the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="displayIds">A list of display ids to save the custom resolution for.</param>
+        /// <param name="isThisOutputIdOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same
+        ///     outputId.
+        /// </param>
+        /// <param name="isThisMonitorOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
+        ///     ID or the same TV connector in case of analog TV.
+        /// </param>
+        public static void SaveCustomResolution(uint[] displayIds, bool isThisOutputIdOnly, bool isThisMonitorOnly)
+        {
+            DisplayApi.SaveCustomDisplay(displayIds, isThisOutputIdOnly, isThisMonitorOnly);
+        }
+
+        /// <summary>
+        ///     Applies a custom resolution into trial
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to apply.</param>
+        /// <param name="displayIds">A list of display ids to apply the custom resolution on.</param>
+        /// <param name="hardwareModeSetOnly">
+        ///     A boolean value indicating that a hardware mode-set without OS update should be
+        ///     performed.
+        /// </param>
+        public static void TrialCustomResolution(
+            CustomResolution customResolution,
+            uint[] displayIds,
+            bool hardwareModeSetOnly = true)
+        {
+            var customDisplay = customResolution.AsCustomDisplay(hardwareModeSetOnly);
+            DisplayApi.TryCustomDisplay(displayIds.ToDictionary(u => u, u => customDisplay));
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((DisplayDevice) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return (int) DisplayId;
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"Display #{DisplayId}";
+        }
+
+        /// <summary>
+        ///     Calculates a valid timing based on the argument passed
+        /// </summary>
+        /// <param name="width">The preferred width.</param>
+        /// <param name="height">The preferred height.</param>
+        /// <param name="refreshRate">The preferred refresh rate.</param>
+        /// <param name="isInterlaced">The boolean value indicating if the preferred resolution is an interlaced resolution.</param>
+        /// <returns>Returns a valid instance of <see cref="Timing" />.</returns>
+        public Timing CalculateTiming(uint width, uint height, float refreshRate, bool isInterlaced)
+        {
+            return DisplayApi.GetTiming(
+                DisplayId,
+                new TimingInput(width, height, refreshRate, TimingOverride.Auto, isInterlaced)
+            );
+        }
+
+        /// <summary>
+        ///     Deletes a custom resolution.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to delete.</param>
+        public void DeleteCustomResolution(CustomResolution customResolution)
+        {
+            DeleteCustomResolution(customResolution, new[] {DisplayId});
+        }
+
+        /// <summary>
+        ///     Retrieves the list of custom resolutions saved for this display device
+        /// </summary>
+        /// <returns>A list of <see cref="CustomResolution" /> instances.</returns>
+        public IEnumerable<CustomResolution> GetCustomResolutions()
+        {
+            return DisplayApi.EnumCustomDisplays(DisplayId).Select(custom => new CustomResolution(custom));
+        }
+
+        /// <summary>
+        ///     Checks if a color data is supported on this display
+        /// </summary>
+        /// <param name="colorData">The color data to be checked.</param>
+        /// <returns>true if the color data passed is supported; otherwise false</returns>
+        public bool IsColorDataSupported(ColorData colorData)
+        {
+            var instances = new IColorData[]
+            {
+                colorData.AsColorDataV5(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV4(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV3(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV2(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV1(ColorDataCommand.IsSupportedColor)
+            };
+
+            try
+            {
+                DisplayApi.ColorControl(DisplayId, instances);
+
+                return true;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status == Status.NotSupported)
+                {
+                    return false;
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        ///     Resets the HDMI audio info-frame information to default
+        /// </summary>
+        public void ResetHDMIAudioFrameInformation()
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.Reset,
+                InfoFrameDataType.AudioInformation
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Resets the HDMI auxiliary video info-frame information to default
+        /// </summary>
+        public void ResetHDMIVideoFrameInformation()
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.Reset,
+                InfoFrameDataType.AuxiliaryVideoInformation
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Reverts the custom resolution currently on trial.
+        /// </summary>
+        public void RevertCustomResolution()
+        {
+            RevertCustomResolution(new[] {DisplayId});
+        }
+
+        /// <summary>
+        ///     Saves the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="isThisOutputIdOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same
+        ///     outputId.
+        /// </param>
+        /// <param name="isThisMonitorOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
+        ///     ID or the same TV connector in case of analog TV.
+        /// </param>
+        public void SaveCustomResolution(bool isThisOutputIdOnly = true, bool isThisMonitorOnly = true)
+        {
+            SaveCustomResolution(new[] {DisplayId}, isThisOutputIdOnly, isThisMonitorOnly);
+        }
+
+        /// <summary>
+        ///     Changes the display current color data configuration
+        /// </summary>
+        /// <param name="colorData">The color data to be set.</param>
+        public void SetColorData(ColorData colorData)
+        {
+            var instances = new IColorData[]
+            {
+                colorData.AsColorDataV5(ColorDataCommand.Set),
+                colorData.AsColorDataV4(ColorDataCommand.Set),
+                colorData.AsColorDataV3(ColorDataCommand.Set),
+                colorData.AsColorDataV2(ColorDataCommand.Set),
+                colorData.AsColorDataV1(ColorDataCommand.Set)
+            };
+
+            DisplayApi.ColorControl(DisplayId, instances);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI video info-frame current or override information
+        /// </summary>
+        /// <param name="audio">The new information.</param>
+        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
+        public void SetHDMIAudioFrameInformation(InfoFrameAudio audio, bool isOverride = false)
+        {
+            var infoFrame = new InfoFrameData(
+                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
+                audio
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI audio info-frame property information
+        /// </summary>
+        /// <param name="property">The new property information.</param>
+        public void SetHDMIAudioFramePropertyInformation(InfoFrameProperty property)
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.SetProperty,
+                InfoFrameDataType.AudioInformation,
+                property
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI auxiliary video info-frame current or override information
+        /// </summary>
+        /// <param name="video">The new information.</param>
+        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
+        public void SetHDMIVideoFrameInformation(InfoFrameVideo video, bool isOverride = false)
+        {
+            var infoFrame = new InfoFrameData(
+                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
+                video
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI auxiliary video info-frame property information
+        /// </summary>
+        /// <param name="property">The new property information.</param>
+        public void SetHDMIVideoFramePropertyInformation(InfoFrameProperty property)
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.SetProperty,
+                InfoFrameDataType.AuxiliaryVideoInformation,
+                property
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Changes the display HDR color data configuration
+        /// </summary>
+        /// <param name="colorData">The color data to be set.</param>
+        public void SetHDRColorData(HDRColorData colorData)
+        {
+            var instances = new IHDRColorData[]
+            {
+                colorData.AsHDRColorDataV2(ColorDataHDRCommand.Set),
+                colorData.AsHDRColorDataV1(ColorDataHDRCommand.Set)
+            };
+
+            DisplayApi.HDRColorControl(DisplayId, instances);
+        }
+
+        /// <summary>
+        ///     Applies a custom resolution into trial.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to apply.</param>
+        /// <param name="hardwareModeSetOnly">
+        ///     A boolean value indicating that a hardware mode-set without OS update should be
+        ///     performed.
+        /// </param>
+        public void TrialCustomResolution(CustomResolution customResolution, bool hardwareModeSetOnly = true)
+        {
+            TrialCustomResolution(customResolution, new[] {DisplayId}, hardwareModeSetOnly);
+        }
+    }
+}

app/NvAPIWrapper/Display/FloatTexture.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Linq;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a texture of float values
+    /// </summary>
+    public class FloatTexture : IEquatable<FloatTexture>
+    {
+        /// <summary>
+        ///     Underlying float array containing the values of all channels in all pixels
+        /// </summary>
+        protected readonly float[] UnderlyingArray;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="FloatTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The number of texture channels.</param>
+        public FloatTexture(int width, int height, int channels) : this(width, height, channels, null)
+        {
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="FloatTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The number of texture channels.</param>
+        /// <param name="array">The underlying array containing all float values.</param>
+        // ReSharper disable once TooManyDependencies
+        protected FloatTexture(int width, int height, int channels, float[] array)
+        {
+            Width = width;
+            Height = height;
+            Channels = channels;
+            UnderlyingArray = array ?? new float[width * height * channels];
+        }
+
+        /// <summary>
+        ///     Gets the number of texture channels
+        /// </summary>
+        public int Channels { get; }
+
+        /// <summary>
+        ///     Gets the texture height in pixel
+        /// </summary>
+        public int Height { get; }
+
+        /// <summary>
+        ///     Gets the texture width in pixels
+        /// </summary>
+        public int Width { get; }
+
+        /// <inheritdoc />
+        public bool Equals(FloatTexture other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (other.UnderlyingArray.Length != UnderlyingArray.Length)
+            {
+                return false;
+            }
+
+            if (other.Width != Width || other.Height != Height || other.Channels != Channels)
+            {
+                return false;
+            }
+
+            return !UnderlyingArray.Where((t, i) => Math.Abs(other.UnderlyingArray[i] - t) > 0.0001).Any();
+        }
+
+        /// <summary>
+        ///     Returns a new instance of FloatTexture from the passed array of float values.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The texture channels.</param>
+        /// <param name="floats">The array of float values.</param>
+        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
+        // ReSharper disable once TooManyArguments
+        public static FloatTexture FromFloatArray(int width, int height, int channels, float[] floats)
+        {
+            if (floats.Length != width * height * channels)
+            {
+                throw new ArgumentOutOfRangeException(nameof(floats));
+            }
+
+            return new FloatTexture(width, height, channels, floats.ToArray());
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="FloatTexture" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(FloatTexture left, FloatTexture right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="FloatTexture" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(FloatTexture left, FloatTexture right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as FloatTexture);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return UnderlyingArray.GetHashCode();
+        }
+
+        /// <summary>
+        ///     Gets the values of each channel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <returns>An array of float values each representing a channel value.</returns>
+        public float[] GetValues(int x, int y)
+        {
+            return UnderlyingArray.Skip(y * Width + x).Take(Channels).ToArray();
+        }
+
+        /// <summary>
+        ///     Sets the value of each channel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <param name="floats">An array of float values each representing a channel value.</param>
+        public void SetValues(int x, int y, params float[] floats)
+        {
+            var index = y * Width + x;
+
+            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
+            {
+                UnderlyingArray[index + i] = floats[i];
+            }
+        }
+
+        /// <summary>
+        ///     Returns this instance of <see cref="FloatTexture" /> as an array of float values.
+        /// </summary>
+        /// <returns>An array of float values representing this instance of <see cref="FloatTexture" />.</returns>
+        public float[] ToFloatArray()
+        {
+            // Returns a copy of the underlying array
+            return UnderlyingArray.ToArray();
+        }
+    }
+}

app/NvAPIWrapper/Display/HDRColorData.cs

@@ -0,0 +1,157 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <inheritdoc cref="IHDRColorData" />
+    public class HDRColorData : IHDRColorData, IEquatable<HDRColorData>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="HDRColorData" />.
+        /// </summary>
+        /// <param name="hdrMode">The hdr mode.</param>
+        /// <param name="masteringDisplayData">The display color space configurations.</param>
+        /// <param name="colorFormat">The color data color format.</param>
+        /// <param name="dynamicRange">The color data dynamic range.</param>
+        /// <param name="colorDepth">The color data color depth.</param>
+        public HDRColorData(
+            ColorDataHDRMode hdrMode,
+            MasteringDisplayColorData masteringDisplayData,
+            ColorDataFormat? colorFormat = null,
+            ColorDataDynamicRange? dynamicRange = null,
+            ColorDataDepth? colorDepth = null
+        )
+        {
+            HDRMode = hdrMode;
+            MasteringDisplayData = masteringDisplayData;
+            ColorFormat = colorFormat;
+            DynamicRange = dynamicRange;
+            ColorDepth = colorDepth;
+        }
+
+        internal HDRColorData(IHDRColorData colorData)
+        {
+            HDRMode = colorData.HDRMode;
+            MasteringDisplayData = colorData.MasteringDisplayData;
+            ColorDepth = colorData.ColorDepth;
+            ColorFormat = colorData.ColorFormat;
+            DynamicRange = colorData.DynamicRange;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(HDRColorData other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return ColorDepth == other.ColorDepth &&
+                   ColorFormat == other.ColorFormat &&
+                   DynamicRange == other.DynamicRange &&
+                   HDRMode == other.HDRMode &&
+                   MasteringDisplayData.Equals(other.MasteringDisplayData);
+        }
+
+        /// <inheritdoc />
+        public ColorDataDepth? ColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataFormat? ColorFormat { get; }
+
+        /// <inheritdoc />
+        public ColorDataDynamicRange? DynamicRange { get; }
+
+        /// <inheritdoc />
+        public ColorDataHDRMode HDRMode { get; }
+
+        /// <inheritdoc />
+        public MasteringDisplayColorData MasteringDisplayData { get; }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="HDRColorData" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are equal; otherwise false.</returns>
+        public static bool operator ==(HDRColorData left, HDRColorData right)
+        {
+            return left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="HDRColorData" /> for inequality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are not equal; otherwise false.</returns>
+        public static bool operator !=(HDRColorData left, HDRColorData right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((HDRColorData) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = ColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ ColorFormat.GetHashCode();
+                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) HDRMode;
+                hashCode = (hashCode * 397) ^ MasteringDisplayData.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal HDRColorDataV1 AsHDRColorDataV1(ColorDataHDRCommand command)
+        {
+            return new HDRColorDataV1(
+                command,
+                HDRMode,
+                MasteringDisplayData
+            );
+        }
+
+        internal HDRColorDataV2 AsHDRColorDataV2(ColorDataHDRCommand command)
+        {
+            return new HDRColorDataV2(
+                command,
+                HDRMode,
+                MasteringDisplayData,
+                ColorFormat ?? ColorDataFormat.Auto,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default
+            );
+        }
+    }
+}

app/NvAPIWrapper/Display/HUEInformation.cs

@@ -0,0 +1,97 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     This class contains and provides a way to modify the HUE angle
+    /// </summary>
+    public class HUEInformation
+    {
+        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
+        private readonly OutputId _outputId = OutputId.Invalid;
+
+        /// <summary>
+        ///     Creates a new instance of the class using a DisplayHandle
+        /// </summary>
+        /// <param name="displayHandle">The handle of the display.</param>
+        public HUEInformation(DisplayHandle displayHandle)
+        {
+            _displayHandle = displayHandle;
+        }
+
+        /// <summary>
+        ///     Creates a new instance of this class using a OutputId
+        /// </summary>
+        /// <param name="outputId">The output identification of a display or an output</param>
+        public HUEInformation(OutputId outputId)
+        {
+            _outputId = outputId;
+        }
+
+        /// <summary>
+        ///     Gets or sets the current HUE offset angle [0-359]
+        /// </summary>
+        public int CurrentAngle
+        {
+            get
+            {
+                PrivateDisplayHUEInfo? hueInfo = null;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
+                }
+
+                return hueInfo?.CurrentAngle ?? 0;
+            }
+            set
+            {
+                value %= 360;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    DisplayApi.SetHUEAngle(_displayHandle, value);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    DisplayApi.SetHUEAngle(_outputId, value);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the default HUE offset angle [0-359]
+        /// </summary>
+        public int DefaultAngle
+        {
+            get
+            {
+                PrivateDisplayHUEInfo? hueInfo = null;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
+                }
+
+                return hueInfo?.DefaultAngle ?? 0;
+            }
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{CurrentAngle:D}º [{DefaultAngle:D}º]";
+        }
+    }
+}

app/NvAPIWrapper/Display/IntensityTexture.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Linq;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a texture of intensity values
+    /// </summary>
+    public class IntensityTexture : FloatTexture
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="IntensityTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        public IntensityTexture(int width, int height) : base(width, height, 3)
+        {
+        }
+
+        private IntensityTexture(int width, int height, float[] floats) : base(width, height, 3, floats)
+        {
+        }
+
+        /// <summary>
+        ///     Returns a new instance of FloatTexture from the passed array of float values.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="floats">The array of float values.</param>
+        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
+        // ReSharper disable once TooManyArguments
+        public static IntensityTexture FromFloatArray(int width, int height, float[] floats)
+        {
+            if (floats.Length != width * height * 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(floats));
+            }
+
+            return new IntensityTexture(width, height, floats.ToArray());
+        }
+
+        /// <summary>
+        ///     Gets the value of intensity pixel at a specific location.
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <returns>An instance of <see cref="IntensityTexturePixel" />.</returns>
+        public IntensityTexturePixel GetPixel(int x, int y)
+        {
+            return IntensityTexturePixel.FromFloatArray(UnderlyingArray, y * Width + x);
+        }
+
+        /// <summary>
+        ///     Sets the value of intensity pixel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <param name="pixel">An instance of <see cref="IntensityTexturePixel" />.</param>
+        public void SetPixel(int x, int y, IntensityTexturePixel pixel)
+        {
+            var index = y * Width + x;
+            var floats = pixel.ToFloatArray();
+
+            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
+            {
+                UnderlyingArray[index + i] = floats[i];
+            }
+        }
+    }
+}

app/NvAPIWrapper/Display/IntensityTexturePixel.cs

@@ -0,0 +1,117 @@
+using System;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a RGB intensity texture pixel
+    /// </summary>
+    public class IntensityTexturePixel : IEquatable<IntensityTexturePixel>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="IntensityTexturePixel" />.
+        /// </summary>
+        /// <param name="redIntensity">The intensity of the red light (0-1)</param>
+        /// <param name="greenIntensity">The intensity of the green light (0-1)</param>
+        /// <param name="blueIntensity">The intensity of the blue light (0-1)</param>
+        public IntensityTexturePixel(float redIntensity, float greenIntensity, float blueIntensity)
+        {
+            RedIntensity = Math.Max(Math.Min(redIntensity, 1), 0);
+            GreenIntensity = Math.Max(Math.Min(greenIntensity, 1), 0);
+            BlueIntensity = Math.Max(Math.Min(blueIntensity, 1), 0);
+        }
+
+        /// <summary>
+        ///     Gets the intensity of the blue light (0-1)
+        /// </summary>
+        public float BlueIntensity { get; }
+
+        /// <summary>
+        ///     Gets the intensity of the green light (0-1)
+        /// </summary>
+        public float GreenIntensity { get; }
+
+        /// <summary>
+        ///     Gets the intensity of the red light (0-1)
+        /// </summary>
+        public float RedIntensity { get; }
+
+        /// <inheritdoc />
+        public bool Equals(IntensityTexturePixel other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Math.Abs(RedIntensity - other.RedIntensity) < 0.0001 &&
+                   Math.Abs(GreenIntensity - other.GreenIntensity) < 0.0001 &&
+                   Math.Abs(BlueIntensity - other.BlueIntensity) < 0.0001;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(IntensityTexturePixel left, IntensityTexturePixel right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(IntensityTexturePixel left, IntensityTexturePixel right)
+        {
+            return !(left == right);
+        }
+
+        internal static IntensityTexturePixel FromFloatArray(float[] floats, int index)
+        {
+            return new IntensityTexturePixel(floats[index], floats[index + 1], floats[index + 2]);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as IntensityTexturePixel);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = RedIntensity.GetHashCode();
+                hashCode = (hashCode * 397) ^ GreenIntensity.GetHashCode();
+                hashCode = (hashCode * 397) ^ BlueIntensity.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal float[] ToFloatArray()
+        {
+            return new[] {RedIntensity, GreenIntensity, BlueIntensity};
+        }
+    }
+}

app/NvAPIWrapper/Display/PathInfo.cs

@@ -0,0 +1,288 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a configuration path
+    /// </summary>
+    public class PathInfo : IEquatable<PathInfo>
+    {
+        /// <summary>
+        ///     Creates a new PathInfo
+        /// </summary>
+        /// <param name="resolution">Display resolution</param>
+        /// <param name="colorFormat">Display color format</param>
+        /// <param name="targetInfos">Target configuration informations</param>
+        public PathInfo(Resolution resolution, ColorFormat colorFormat, PathTargetInfo[] targetInfos)
+        {
+            Resolution = resolution;
+            ColorFormat = colorFormat;
+            TargetsInfo = targetInfos;
+        }
+
+        /// <summary>
+        ///     Creates a new PathInfo
+        /// </summary>
+        /// <param name="info">IPathInfo implamented object</param>
+        public PathInfo(IPathInfo info)
+        {
+            SourceId = info.SourceId;
+            Resolution = info.SourceModeInfo.Resolution;
+            ColorFormat = info.SourceModeInfo.ColorFormat;
+            Position = info.SourceModeInfo.Position;
+            SpanningOrientation = info.SourceModeInfo.SpanningOrientation;
+            IsGDIPrimary = info.SourceModeInfo.IsGDIPrimary;
+            IsSLIFocus = info.SourceModeInfo.IsSLIFocus;
+            TargetsInfo =
+                info.TargetsInfo.Select(targetInfo => new PathTargetInfo(targetInfo)).ToArray();
+
+            if (info is PathInfoV2)
+            {
+                OSAdapterLUID = ((PathInfoV2) info).OSAdapterLUID;
+            }
+        }
+
+        /// <summary>
+        ///     Gets or sets the display color format
+        /// </summary>
+        public ColorFormat ColorFormat { get; set; }
+
+        /// <summary>
+        ///     Gets or sets a boolean value indicating if the this is the primary GDI display
+        /// </summary>
+        public bool IsGDIPrimary { get; set; }
+
+        /// <summary>
+        ///     Gets or sets a boolean value indicating if the this is the SLI focus display
+        /// </summary>
+        public bool IsSLIFocus { get; set; }
+
+        /// <summary>
+        ///     Gets OS Adapter of LUID for Non-NVIDIA adapters
+        /// </summary>
+        public LUID? OSAdapterLUID { get; }
+
+        /// <summary>
+        ///     Gets or sets the display position
+        /// </summary>
+        public Position Position { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the display resolution
+        /// </summary>
+        public Resolution Resolution { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the Windows CCD display source identification. This can be optionally set.
+        /// </summary>
+        public uint SourceId { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the display spanning orientation, valid for XP only
+        /// </summary>
+        public SpanningOrientation SpanningOrientation { get; set; }
+
+
+        /// <summary>
+        ///     Gets information about path targets
+        /// </summary>
+        public PathTargetInfo[] TargetsInfo { get; }
+
+
+        /// <summary>
+        ///     Checks for equality with a PathInfo instance
+        /// </summary>
+        /// <param name="other">The PathInfo object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(PathInfo other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Resolution.Equals(other.Resolution) &&
+                   ColorFormat == other.ColorFormat &&
+                   Position.Equals(other.Position) &&
+                   SpanningOrientation == other.SpanningOrientation &&
+                   IsGDIPrimary == other.IsGDIPrimary &&
+                   IsSLIFocus == other.IsSLIFocus &&
+                   TargetsInfo.SequenceEqual(other.TargetsInfo);
+        }
+
+
+        /// <summary>
+        ///     Creates and fills a PathInfo object
+        /// </summary>
+        /// <returns>The newly created PathInfo object</returns>
+        public static PathInfo[] GetDisplaysConfig()
+        {
+            var configs = DisplayApi.GetDisplayConfig();
+            var logicalDisplays = configs.Select(info => new PathInfo(info)).ToArray();
+            configs.DisposeAll();
+
+            return logicalDisplays;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PathInfo left, PathInfo right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PathInfo left, PathInfo right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        ///     Applies one or more path information configurations
+        /// </summary>
+        /// <param name="pathInfos">An array of path information configuration</param>
+        /// <param name="flags">DisplayConfigFlags flags</param>
+        public static void SetDisplaysConfig(PathInfo[] pathInfos, DisplayConfigFlags flags)
+        {
+            try
+            {
+                var configsV2 = pathInfos.Select(config => config.GetPathInfoV2()).Cast<IPathInfo>().ToArray();
+                DisplayApi.SetDisplayConfig(configsV2, flags);
+                configsV2.DisposeAll();
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            var configsV1 = pathInfos.Select(config => config.GetPathInfoV1()).Cast<IPathInfo>().ToArray();
+            DisplayApi.SetDisplayConfig(configsV1, flags);
+            configsV1.DisposeAll();
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((PathInfo) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Resolution.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ Position.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) SpanningOrientation;
+                hashCode = (hashCode * 397) ^ IsGDIPrimary.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsSLIFocus.GetHashCode();
+                hashCode = (hashCode * 397) ^ (TargetsInfo?.GetHashCode() ?? 0);
+
+                return hashCode;
+            }
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{Resolution} @ {Position} [{TargetsInfo.Length}]";
+        }
+
+        /// <summary>
+        ///     Creates and fills a GetPathInfoV1 object
+        /// </summary>
+        /// <returns>The newly created GetPathInfoV1 object</returns>
+        public PathInfoV1 GetPathInfoV1()
+        {
+            var sourceModeInfo = GetSourceModeInfo();
+            var pathTargetInfoV1 = GetPathTargetInfoV1Array();
+
+            return new PathInfoV1(pathTargetInfoV1, sourceModeInfo, SourceId);
+        }
+
+        /// <summary>
+        ///     Creates and fills a GetPathInfoV2 object
+        /// </summary>
+        /// <returns>The newly created GetPathInfoV2 object</returns>
+        public PathInfoV2 GetPathInfoV2()
+        {
+            var sourceModeInfo = GetSourceModeInfo();
+            var pathTargetInfoV2 = GetPathTargetInfoV2Array();
+
+            return new PathInfoV2(pathTargetInfoV2, sourceModeInfo, SourceId);
+        }
+
+        /// <summary>
+        ///     Creates and fills an array of GetPathTargetInfoV1 object
+        /// </summary>
+        /// <returns>The newly created array of GetPathTargetInfoV1 objects</returns>
+        public PathTargetInfoV1[] GetPathTargetInfoV1Array()
+        {
+            return TargetsInfo.Select(config => config.GetPathTargetInfoV1()).ToArray();
+        }
+
+        /// <summary>
+        ///     Creates and fills an array of GetPathTargetInfoV2 object
+        /// </summary>
+        /// <returns>The newly created array of GetPathTargetInfoV2 objects</returns>
+        public PathTargetInfoV2[] GetPathTargetInfoV2Array()
+        {
+            return TargetsInfo.Select(config => config.GetPathTargetInfoV2()).ToArray();
+        }
+
+        /// <summary>
+        ///     Creates and fills a SourceModeInfo object
+        /// </summary>
+        /// <returns>The newly created SourceModeInfo object</returns>
+        public SourceModeInfo GetSourceModeInfo()
+        {
+            return new SourceModeInfo(Resolution, ColorFormat, Position, SpanningOrientation, IsGDIPrimary, IsSLIFocus);
+        }
+    }
+}

app/NvAPIWrapper/Display/PathTargetInfo.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a display configuration on a path
+    /// </summary>
+    public class PathTargetInfo : IEquatable<PathTargetInfo>
+    {
+        private TimingOverride _timingOverride;
+
+        /// <summary>
+        ///     Creates a new PathTargetInfo
+        /// </summary>
+        /// <param name="info">IPathTargetInfo implamented object</param>
+        public PathTargetInfo(IPathTargetInfo info)
+        {
+            DisplayDevice = new DisplayDevice(info.DisplayId);
+
+            if (info.Details.HasValue)
+            {
+                Rotation = info.Details.Value.Rotation;
+                Scaling = info.Details.Value.Scaling;
+                TVConnectorType = info.Details.Value.ConnectorType;
+                TVFormat = info.Details.Value.TVFormat;
+                RefreshRateInMillihertz = info.Details.Value.RefreshRateInMillihertz;
+                TimingOverride = info.Details.Value.TimingOverride;
+                IsInterlaced = info.Details.Value.IsInterlaced;
+                IsClonePrimary = info.Details.Value.IsClonePrimary;
+                IsClonePanAndScanTarget = info.Details.Value.IsClonePanAndScanTarget;
+                DisableVirtualModeSupport = info.Details.Value.DisableVirtualModeSupport;
+                IsPreferredUnscaledTarget = info.Details.Value.IsPreferredUnscaledTarget;
+            }
+
+            if (info is PathTargetInfoV2)
+            {
+                WindowsCCDTargetId = ((PathTargetInfoV2) info).WindowsCCDTargetId;
+            }
+        }
+
+        /// <summary>
+        ///     Creates a new PathTargetInfo
+        /// </summary>
+        /// <param name="device">DisplayDevice object</param>
+        public PathTargetInfo(DisplayDevice device)
+        {
+            DisplayDevice = device;
+        }
+
+        /// <summary>
+        ///     Gets or sets the virtual mode support
+        /// </summary>
+        public bool DisableVirtualModeSupport { get; set; }
+
+        /// <summary>
+        ///     Gets corresponding DisplayDevice
+        /// </summary>
+        public DisplayDevice DisplayDevice { get; }
+
+        /// <summary>
+        ///     Gets or sets the pan and scan is availability. Valid only when the target is part of clone
+        ///     topology.
+        /// </summary>
+        public bool IsClonePanAndScanTarget { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the primary display in clone configuration. This is *NOT* GDI Primary.
+        ///     Only one target can be primary per source. If no primary is specified, the first target will automatically be
+        ///     primary.
+        /// </summary>
+        public bool IsClonePrimary { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the interlaced mode flag, ignored if refreshRate == 0
+        /// </summary>
+        public bool IsInterlaced { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the preferred unscaled mode of target
+        /// </summary>
+        public bool IsPreferredUnscaledTarget { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored
+        ///     This is the value which driver reports to the OS.
+        /// </summary>
+        public uint RefreshRateInMillihertz { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the rotation setting
+        /// </summary>
+        public Rotate Rotation { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the scaling setting
+        /// </summary>
+        public Scaling Scaling { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the custom timing of display
+        ///     Ignored if TimingOverride == TimingOverride.Current
+        /// </summary>
+        public TimingOverride TimingOverride
+        {
+            get => _timingOverride;
+            set
+            {
+                if (value == TimingOverride.Custom)
+                {
+                    throw new NVIDIANotSupportedException("Custom timing is not supported yet.");
+                }
+
+                _timingOverride = value;
+            }
+        }
+
+        /// <summary>
+        ///     Gets and sets the connector type. For TV only, ignored if TVFormat == TVFormat.None.
+        /// </summary>
+        public ConnectorType TVConnectorType { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the TV format. For TV only, otherwise set to TVFormat.None
+        /// </summary>
+        public TVFormat TVFormat { get; set; }
+
+        /// <summary>
+        ///     Gets the Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is
+        ///     ignored.
+        /// </summary>
+        public uint WindowsCCDTargetId { get; }
+
+        /// <summary>
+        ///     Checks for equality with a PathTargetInfo instance
+        /// </summary>
+        /// <param name="other">The PathTargetInfo object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(PathTargetInfo other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return _timingOverride == other._timingOverride &&
+                   Rotation == other.Rotation &&
+                   Scaling == other.Scaling &&
+                   RefreshRateInMillihertz == other.RefreshRateInMillihertz &&
+                   (TVFormat == TVFormat.None || TVConnectorType == other.TVConnectorType) &&
+                   TVFormat == other.TVFormat &&
+                   DisplayDevice.Equals(other.DisplayDevice) &&
+                   IsInterlaced == other.IsInterlaced &&
+                   IsClonePrimary == other.IsClonePrimary &&
+                   IsClonePanAndScanTarget == other.IsClonePanAndScanTarget &&
+                   DisableVirtualModeSupport == other.DisableVirtualModeSupport &&
+                   IsPreferredUnscaledTarget == other.IsPreferredUnscaledTarget;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PathTargetInfo left, PathTargetInfo right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PathTargetInfo left, PathTargetInfo right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((PathTargetInfo) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) _timingOverride;
+                hashCode = (hashCode * 397) ^ (int) Rotation;
+                hashCode = (hashCode * 397) ^ (int) Scaling;
+                hashCode = (hashCode * 397) ^ (int) RefreshRateInMillihertz;
+                hashCode = (hashCode * 397) ^ (int) TVFormat;
+                hashCode = (hashCode * 397) ^ (TVFormat != TVFormat.None ? (int) TVConnectorType : 0);
+                hashCode = (hashCode * 397) ^ (DisplayDevice?.GetHashCode() ?? 0);
+                hashCode = (hashCode * 397) ^ IsInterlaced.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsClonePrimary.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsClonePanAndScanTarget.GetHashCode();
+                hashCode = (hashCode * 397) ^ DisableVirtualModeSupport.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsPreferredUnscaledTarget.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var strs = new List<string>
+            {
+                DisplayDevice.ToString()
+            };
+
+            if (RefreshRateInMillihertz > 0)
+            {
+                strs.Add($"@ {RefreshRateInMillihertz / 1000}hz");
+            }
+
+            if (TVFormat != TVFormat.None)
+            {
+                strs.Add($"- TV {TVFormat}");
+            }
+
+            strs.Add(IsInterlaced ? "Interlaced" : "Progressive");
+
+            if (Rotation != Rotate.Degree0)
+            {
+                strs.Add($"- Rotation: {Rotation}");
+            }
+
+            return string.Join(" ", strs);
+        }
+
+
+        /// <summary>
+        ///     Creates and fills a PathAdvancedTargetInfo object
+        /// </summary>
+        /// <returns>The newly created PathAdvancedTargetInfo object</returns>
+        public PathAdvancedTargetInfo GetPathAdvancedTargetInfo()
+        {
+            if (TVFormat == TVFormat.None)
+            {
+                return new PathAdvancedTargetInfo(Rotation, Scaling, RefreshRateInMillihertz, TimingOverride,
+                    IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
+                    IsPreferredUnscaledTarget);
+            }
+
+            return new PathAdvancedTargetInfo(Rotation, Scaling, TVFormat, TVConnectorType, RefreshRateInMillihertz,
+                TimingOverride, IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
+                IsPreferredUnscaledTarget);
+        }
+
+        /// <summary>
+        ///     Creates and fills a PathTargetInfoV1 object
+        /// </summary>
+        /// <returns>The newly created PathTargetInfoV1 object</returns>
+        public PathTargetInfoV1 GetPathTargetInfoV1()
+        {
+            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
+
+            return new PathTargetInfoV1(DisplayDevice.DisplayId, pathAdvancedTargetInfo);
+        }
+
+        /// <summary>
+        ///     Creates and fills a PathTargetInfoV2 object
+        /// </summary>
+        /// <returns>The newly created PathTargetInfoV2 object</returns>
+        public PathTargetInfoV2 GetPathTargetInfoV2()
+        {
+            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
+
+            return new PathTargetInfoV2(DisplayDevice.DisplayId, WindowsCCDTargetId, pathAdvancedTargetInfo);
+        }
+    }
+}

app/NvAPIWrapper/Display/ScanOutInformation.cs

@@ -0,0 +1,218 @@
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General.Structures;
+using Rectangle = NvAPIWrapper.Native.General.Structures.Rectangle;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Contains information regarding the scan-out buffer settings of a display device
+    /// </summary>
+    public class ScanOutInformation
+    {
+        internal ScanOutInformation(DisplayDevice displayDevice)
+        {
+            DisplayDevice = displayDevice;
+        }
+
+        /// <summary>
+        ///     Gets the clone importance assigned to the target if the target is a cloned view of the SourceDesktopRectangle
+        ///     (0:primary,1 secondary,...).
+        /// </summary>
+        public uint CloneImportance
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).CloneImportance;
+        }
+
+        /// <summary>
+        ///     Gets the display device that this instance describes
+        /// </summary>
+        public DisplayDevice DisplayDevice { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the display device scan out output is warped
+        /// </summary>
+        public bool IsDisplayWarped
+        {
+            get => DisplayApi.GetScanOutWarpingState(DisplayDevice.DisplayId).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the display device intensity is modified
+        /// </summary>
+        public bool IsIntensityModified
+        {
+            get => DisplayApi.GetScanOutIntensityState(DisplayDevice.DisplayId).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets the operating system display device rectangle in desktop coordinates displayId is scanning out from.
+        /// </summary>
+        public Rectangle SourceDesktopRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceDesktopRectangle;
+        }
+
+        /// <summary>
+        ///     Gets the rotation performed between the SourceViewPortRectangle and the TargetViewPortRectangle.
+        /// </summary>
+        public Rotate SourceToTargetRotation
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceToTargetRotation;
+        }
+
+        /// <summary>
+        ///     Gets the area inside the SourceDesktopRectangle which is scanned out to the display.
+        /// </summary>
+        public Rectangle SourceViewPortRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceViewPortRectangle;
+        }
+
+        /// <summary>
+        ///     Gets the vertical size of the active resolution scanned out to the display.
+        /// </summary>
+        public uint TargetDisplayHeight
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayHeight;
+        }
+
+        /// <summary>
+        ///     Gets the horizontal size of the active resolution scanned out to the display.
+        /// </summary>
+        public uint TargetDisplayWidth
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayWidth;
+        }
+
+        /// <summary>
+        ///     Gets the area inside the rectangle described by targetDisplayWidth/Height SourceViewPortRectangle is scanned out
+        ///     to.
+        /// </summary>
+        public Rectangle TargetViewPortRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetViewPortRectangle;
+        }
+
+        /// <summary>
+        ///     Disables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void DisableIntensityModifications(out bool isSticky)
+        {
+            DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, null, out isSticky);
+        }
+
+        /// <summary>
+        ///     Disables the warping of display device scan-out buffer.
+        /// </summary>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void DisableWarping(out bool isSticky)
+        {
+            var vorticesCount = 0;
+            DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, null, ref vorticesCount, out isSticky);
+        }
+
+        /// <summary>
+        ///     Enables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void EnableIntensityModifications(IntensityTexture intensityTexture, out bool isSticky)
+        {
+            using (
+                var intensity = new ScanOutIntensityV1(
+                    (uint) intensityTexture.Width,
+                    (uint) intensityTexture.Height,
+                    intensityTexture.ToFloatArray()
+                )
+            )
+            {
+                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Enables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
+        /// <param name="offsetTexture">The offset texture to apply to the scan-out buffer.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void EnableIntensityModifications(
+            IntensityTexture intensityTexture,
+            FloatTexture offsetTexture,
+            out bool isSticky)
+        {
+            using (
+                var intensity = new ScanOutIntensityV2(
+                    (uint) intensityTexture.Width,
+                    (uint) intensityTexture.Height,
+                    intensityTexture.ToFloatArray(),
+                    (uint) offsetTexture.Channels,
+                    offsetTexture.ToFloatArray()
+                )
+            )
+            {
+                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Enables the warping of display device scan-out buffer
+        /// </summary>
+        /// <param name="warpingVerticeFormat">The type of warping vortexes.</param>
+        /// <param name="vortices">An array of warping vortexes.</param>
+        /// <param name="textureRectangle">The rectangle in desktop coordinates describing the source area for the warping.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        // ReSharper disable once TooManyArguments
+        public void EnableWarping(
+            WarpingVerticeFormat warpingVerticeFormat,
+            XYUVRQVortex[] vortices,
+            Rectangle textureRectangle,
+            out bool isSticky)
+        {
+            using (
+                var warping = new ScanOutWarpingV1(
+                    warpingVerticeFormat,
+                    vortices.SelectMany(vortex => vortex.AsFloatArray()).ToArray(),
+                    textureRectangle
+                )
+            )
+            {
+                var vorticesCount = vortices.Length;
+                DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, warping, ref vorticesCount, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Queries the current state of one of the various scan-out composition parameters.
+        /// </summary>
+        /// <param name="parameter">The scan-out composition parameter.</param>
+        /// <param name="additionalValue">The additional value included with the parameter value.</param>
+        /// <returns>The scan-out composition parameter value.</returns>
+        public ScanOutCompositionParameterValue GetCompositionParameterValue(
+            ScanOutCompositionParameter parameter,
+            out float additionalValue)
+        {
+            return DisplayApi.GetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, out additionalValue);
+        }
+
+
+        /// <summary>
+        ///     Sets the current state of one of the various scan-out composition parameters.
+        /// </summary>
+        /// <param name="parameter">The scan-out composition parameter.</param>
+        /// <param name="parameterValue">The scan-out composition parameter value.</param>
+        /// <param name="additionalValue">The additional value included with the parameter value.</param>
+        public void SetCompositionParameterValue(
+            ScanOutCompositionParameter parameter,
+            ScanOutCompositionParameterValue parameterValue,
+            float additionalValue)
+        {
+            DisplayApi.SetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, parameterValue,
+                ref additionalValue);
+        }
+    }
+}

app/NvAPIWrapper/Display/UnAttachedDisplay.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an unattached display
+    /// </summary>
+    public class UnAttachedDisplay : IEquatable<UnAttachedDisplay>
+    {
+        /// <summary>
+        ///     Creates a new UnAttachedDisplay
+        /// </summary>
+        /// <param name="handle">Handle of the unattached display device</param>
+        public UnAttachedDisplay(UnAttachedDisplayHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Creates a new UnAttachedDisplay
+        /// </summary>
+        /// <param name="displayName">Name of the unattached display device</param>
+        public UnAttachedDisplay(string displayName)
+        {
+            Handle = DisplayApi.GetAssociatedUnAttachedNvidiaDisplayHandle(displayName);
+        }
+
+        /// <summary>
+        ///     Gets display handle
+        /// </summary>
+        public UnAttachedDisplayHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets display name
+        /// </summary>
+        public string Name
+        {
+            get => DisplayApi.GetUnAttachedAssociatedDisplayName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets corresponding physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU
+        {
+            get => new PhysicalGPU(GPUApi.GetPhysicalGPUFromUnAttachedDisplay(Handle));
+        }
+
+        /// <summary>
+        ///     Checks for equality with a UnAttachedDisplay instance
+        /// </summary>
+        /// <param name="other">The Display object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(UnAttachedDisplay other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     This function returns all unattached NVIDIA displays
+        ///     Note: Display handles can get invalidated on a modeset.
+        /// </summary>
+        /// <returns>An array of Display objects</returns>
+        public static UnAttachedDisplay[] GetUnAttachedDisplays()
+        {
+            return
+                DisplayApi.EnumNvidiaUnAttachedDisplayHandle().Select(handle => new UnAttachedDisplay(handle))
+                    .ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(UnAttachedDisplay left, UnAttachedDisplay right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(UnAttachedDisplay left, UnAttachedDisplay right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((UnAttachedDisplay) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        /// <summary>
+        ///     Creates a new active attached display from this unattached display
+        ///     At least one GPU must be present in the system and running an NVIDIA display driver.
+        /// </summary>
+        /// <returns>An active attached display</returns>
+        public Display CreateDisplay()
+        {
+            return new Display(DisplayApi.CreateDisplayFromUnAttachedDisplay(Handle));
+        }
+    }
+}

app/NvAPIWrapper/Display/XYUVRQVortex.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a XYUVRQ scan-out warping vortex
+    /// </summary>
+    public class XYUVRQVortex : IEquatable<XYUVRQVortex>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="XYUVRQVortex" />.
+        /// </summary>
+        /// <param name="x">The target view port mesh horizontal coordinate</param>
+        /// <param name="y">The target view port mesh vertical coordinate</param>
+        /// <param name="u">The desktop view port texture horizontal coordinate</param>
+        /// <param name="v">The desktop view port texture vertical coordinate</param>
+        /// <param name="r">The 3D warp perspective R factor</param>
+        /// <param name="q">The 3D warp perspective Q factor</param>
+        // ReSharper disable once TooManyDependencies
+        public XYUVRQVortex(int x, int y, int u, int v, float r, float q)
+        {
+            X = x;
+            Y = y;
+            U = u;
+            V = v;
+            R = r;
+            Q = q;
+        }
+
+        /// <summary>
+        ///     3D warp perspective Q factor
+        /// </summary>
+        public float Q { get; }
+
+        /// <summary>
+        ///     3D warp perspective R factor
+        /// </summary>
+        public float R { get; }
+
+        /// <summary>
+        ///     Desktop view port texture horizontal coordinate
+        /// </summary>
+        public int U { get; }
+
+        /// <summary>
+        ///     Desktop view port texture vertical coordinate
+        /// </summary>
+        public int V { get; }
+
+        /// <summary>
+        ///     Target view port mesh horizontal coordinate
+        /// </summary>
+        public int X { get; }
+
+        /// <summary>
+        ///     Target view port mesh vertical coordinate
+        /// </summary>
+        public int Y { get; }
+
+        /// <inheritdoc />
+        public bool Equals(XYUVRQVortex other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Math.Abs(Q - other.Q) < 0.0001 &&
+                   Math.Abs(R - other.R) < 0.0001 &&
+                   U == other.U &&
+                   V == other.V &&
+                   X == other.X &&
+                   Y == other.Y;
+        }
+
+        /// <summary>
+        ///     Parses an array of floats and returns the corresponding <see cref="XYUVRQVortex" />s.
+        /// </summary>
+        /// <param name="floats">The array of float representing one or more <see cref="XYUVRQVortex" />s.</param>
+        /// <returns>Instances of <see cref="XYUVRQVortex" />.</returns>
+        public static IEnumerable<XYUVRQVortex> FromFloatArray(float[] floats)
+        {
+            for (var i = 0; i + 6 <= floats.Length; i += 6)
+            {
+                yield return new XYUVRQVortex(
+                    (int) floats[i],
+                    (int) floats[i + 1],
+                    (int) floats[i + 2],
+                    (int) floats[i + 3],
+                    floats[i + 4],
+                    floats[i + 5]
+                );
+            }
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="XYUVRQVortex" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(XYUVRQVortex left, XYUVRQVortex right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="XYUVRQVortex" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(XYUVRQVortex left, XYUVRQVortex right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as XYUVRQVortex);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Q.GetHashCode();
+                hashCode = (hashCode * 397) ^ R.GetHashCode();
+                hashCode = (hashCode * 397) ^ U;
+                hashCode = (hashCode * 397) ^ V;
+                hashCode = (hashCode * 397) ^ X;
+                hashCode = (hashCode * 397) ^ Y;
+
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Returns this instance of <see cref="XYUVRQVortex"/> as a float array.
+        /// </summary>
+        /// <returns>An array of float values representing this instance of <see cref="XYUVRQVortex"/>.</returns>
+        public float[] AsFloatArray()
+        {
+            return new[] {X, Y, U, V, R, Q};
+        }
+    }
+}

app/NvAPIWrapper/GPU/AGPInformation.cs

@@ -0,0 +1,30 @@
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the accelerated graphics connection
+    /// </summary>
+    public class AGPInformation
+    {
+        internal AGPInformation(int aperture, int currentRate)
+        {
+            ApertureInMB = aperture;
+            CurrentRate = currentRate;
+        }
+
+        /// <summary>
+        ///     Gets AGP aperture in megabytes
+        /// </summary>
+        public int ApertureInMB { get; }
+
+        /// <summary>
+        ///     Gets current AGP Rate (0 = AGP not present, 1 = 1x, 2 = 2x, etc.)
+        /// </summary>
+        public int CurrentRate { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"AGP Aperture: {ApertureInMB}MB, Current Rate: {CurrentRate}x";
+        }
+    }
+}

app/NvAPIWrapper/GPU/ECCMemoryInformation.cs

@@ -0,0 +1,201 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the ECC memory
+    /// </summary>
+    public class ECCMemoryInformation
+    {
+        internal ECCMemoryInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the number of aggregated ECC memory double bit errors
+        /// </summary>
+        public ulong AggregatedDoubleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.DoubleBitErrors;
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the number of aggregated ECC memory single bit errors
+        /// </summary>
+        public ulong AggregatedSingleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.SingleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the ECC memory configuration in regard to how changes are applied
+        /// </summary>
+        public ECCConfiguration Configuration
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).ConfigurationOptions;
+                }
+                catch
+                {
+                    return ECCConfiguration.NotSupported;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of current ECC memory double bit errors
+        /// </summary>
+        public ulong CurrentDoubleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.DoubleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of current ECC memory single bit errors
+        /// </summary>
+        public ulong CurrentSingleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.SingleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory error correction is enabled
+        /// </summary>
+
+        public bool IsEnabled
+        {
+            get => IsSupported &&
+                   GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsEnabled &&
+                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory is enabled by default
+        /// </summary>
+        public bool IsEnabledByDefault
+        {
+            get => IsSupported &&
+                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabledByDefault;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory is supported and available
+        /// </summary>
+        public bool IsSupported
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsSupported;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (!IsSupported)
+            {
+                return "[Not Supported]";
+            }
+
+            if (!IsEnabled)
+            {
+                return "[Disabled]";
+            }
+
+            return
+                $"{CurrentSingleBitErrors}, {CurrentDoubleBitErrors} ({AggregatedSingleBitErrors}, {AggregatedDoubleBitErrors})";
+        }
+
+        /// <summary>
+        ///     Clears aggregated error counters.
+        /// </summary>
+        public void ClearAggregatedErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, false, true);
+        }
+
+        /// <summary>
+        ///     Clears current error counters.
+        /// </summary>
+        public void ClearCurrentErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, false);
+        }
+
+        /// <summary>
+        ///     Clears all error counters.
+        /// </summary>
+        public void ClearErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, true);
+        }
+
+        /// <summary>
+        ///     Disables ECC memory error correction.
+        /// </summary>
+        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
+        public void Disable(bool immediate)
+        {
+            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, false, immediate);
+        }
+
+        /// <summary>
+        ///     Enables ECC memory error correction.
+        /// </summary>
+        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
+        public void Enable(bool immediate)
+        {
+            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, true, immediate);
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUArchitectInformation.cs

@@ -0,0 +1,115 @@
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains physical GPU architect information
+    /// </summary>
+    public class GPUArchitectInformation
+    {
+        internal GPUArchitectInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets total number of cores defined for this GPU, or zero for older architectures
+        /// </summary>
+        public int NumberOfCores
+        {
+            get => (int) GPUApi.GetGPUCoreCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of graphics processing clusters (aka GPU Partitions)
+        /// </summary>
+        public int NumberOfGPC
+        {
+            get => (int) GPUApi.GetPartitionCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of render output units
+        /// </summary>
+        public int NumberOfROPs
+        {
+            get => (int) GPUApi.GetROPCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of shader pipelines
+        /// </summary>
+        public int NumberOfShaderPipelines
+        {
+            get => (int) GPUApi.GetShaderPipeCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of shader sub pipelines
+        /// </summary>
+        public int NumberOfShaderSubPipelines
+        {
+            get => (int) GPUApi.GetShaderSubPipeCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of video processing engines
+        /// </summary>
+        public int NumberOfVPEs
+        {
+            get => (int) GPUApi.GetVPECount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the GPU revision number (should be displayed as a hex string)
+        /// </summary>
+        public int Revision
+        {
+            get => (int) GPUApi.GetArchitectInfo(PhysicalGPU.Handle).Revision;
+        }
+
+        /// <summary>
+        ///     Gets the GPU short name (aka Codename)
+        /// </summary>
+        public string ShortName
+        {
+            get => GPUApi.GetShortName(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the total number of streaming multiprocessors
+        /// </summary>
+        public int TotalNumberOfSMs
+        {
+            get => (int) GPUApi.GetTotalSMCount(PhysicalGPU.Handle);
+        }
+
+
+        /// <summary>
+        ///     Gets the total number of streaming processors
+        /// </summary>
+        public int TotalNumberOfSPs
+        {
+            get => (int) GPUApi.GetTotalSPCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the total number of texture processing clusters
+        /// </summary>
+        public int TotalNumberOfTPCs
+        {
+            get => (int) GPUApi.GetTotalTPCCount(PhysicalGPU.Handle);
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{ShortName} REV{Revision:X}] Cores: {NumberOfCores}";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUBusInformation.cs

@@ -0,0 +1,118 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU bus
+    /// </summary>
+    public class GPUBusInformation
+    {
+        internal GPUBusInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets accelerated graphics port information
+        /// </summary>
+        public AGPInformation AGPInformation
+        {
+            get
+            {
+                if (BusType != GPUBusType.AGP)
+                {
+                    return null;
+                }
+
+                return new AGPInformation(
+                    GPUApi.GetAGPAperture(PhysicalGPU.Handle),
+                    GPUApi.GetCurrentAGPRate(PhysicalGPU.Handle)
+                );
+            }
+        }
+
+        /// <summary>
+        ///     Gets the bus identification
+        /// </summary>
+        public int BusId
+        {
+            get => GPUApi.GetBusId(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the bus slot identification
+        /// </summary>
+        public int BusSlot
+        {
+            get => GPUApi.GetBusSlotId(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the the bus type
+        /// </summary>
+        public GPUBusType BusType
+        {
+            get => GPUApi.GetBusType(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets number of PCIe lanes being used for the PCIe interface downstream
+        /// </summary>
+        public int CurrentPCIeLanes
+        {
+            get
+            {
+                if (BusType == GPUBusType.PCIExpress)
+                {
+                    return GPUApi.GetCurrentPCIEDownStreamWidth(PhysicalGPU.Handle);
+                }
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU interrupt number
+        /// </summary>
+        public int IRQ
+        {
+            get => GPUApi.GetIRQ(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the PCI identifiers
+        /// </summary>
+        public PCIIdentifiers PCIIdentifiers
+        {
+            get
+            {
+                if (BusType == GPUBusType.FPCI || BusType == GPUBusType.PCI || BusType == GPUBusType.PCIExpress)
+                {
+                    GPUApi.GetPCIIdentifiers(
+                        PhysicalGPU.Handle,
+                        out var deviceId,
+                        out var subSystemId,
+                        out var revisionId,
+                        out var extDeviceId
+                    );
+
+                    return new PCIIdentifiers(deviceId, subSystemId, revisionId, (int) extDeviceId);
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{BusType}] Bus #{BusId}, Slot #{BusSlot}";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUCooler.cs

@@ -0,0 +1,130 @@
+using System;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a GPU cooler entry
+    /// </summary>
+    public class GPUCooler
+    {
+        internal GPUCooler(int coolerId, PrivateCoolerSettingsV1.CoolerSetting coolerSetting, int currentRPM = -1)
+        {
+            CoolerId = coolerId;
+            CurrentLevel = (int) coolerSetting.CurrentLevel;
+            DefaultMinimumLevel = (int) coolerSetting.DefaultMinimumLevel;
+            DefaultMaximumLevel = (int) coolerSetting.DefaultMaximumLevel;
+            CurrentMinimumLevel = (int) coolerSetting.CurrentMinimumLevel;
+            CurrentMaximumLevel = (int) coolerSetting.CurrentMaximumLevel;
+            CoolerType = coolerSetting.CoolerType;
+            CoolerController = coolerSetting.CoolerController;
+            DefaultPolicy = coolerSetting.DefaultPolicy;
+            CurrentPolicy = coolerSetting.CurrentPolicy;
+            Target = coolerSetting.Target;
+            ControlMode = coolerSetting.ControlMode;
+            CurrentFanSpeedInRPM = currentRPM;
+        }
+
+        // ReSharper disable once TooManyDependencies
+        internal GPUCooler(
+            PrivateFanCoolersInfoV1.FanCoolersInfoEntry infoEntry,
+            PrivateFanCoolersStatusV1.FanCoolersStatusEntry statusEntry,
+            PrivateFanCoolersControlV1.FanCoolersControlEntry controlEntry)
+        {
+            if (infoEntry.CoolerId != statusEntry.CoolerId || statusEntry.CoolerId != controlEntry.CoolerId)
+            {
+                throw new ArgumentException("Passed arguments are meant to be for different coolers.");
+            }
+
+            CoolerId = (int) statusEntry.CoolerId;
+            CurrentLevel = (int) statusEntry.CurrentLevel;
+            DefaultMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
+            DefaultMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
+            CurrentMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
+            CurrentMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
+            CoolerType = CoolerType.Fan;
+            CoolerController = CoolerController.Internal;
+            DefaultPolicy = CoolerPolicy.None;
+            CurrentPolicy = controlEntry.ControlMode == FanCoolersControlMode.Manual
+                ? CoolerPolicy.Manual
+                : CoolerPolicy.None;
+            Target = CoolerTarget.All;
+            ControlMode = CoolerControlMode.Variable;
+            CurrentFanSpeedInRPM = (int) statusEntry.CurrentRPM;
+        }
+
+        /// <summary>
+        ///     Gets the cooler control mode
+        /// </summary>
+        public CoolerControlMode ControlMode { get; }
+
+        /// <summary>
+        ///     Gets the cooler controller
+        /// </summary>
+        public CoolerController CoolerController { get; }
+
+        /// <summary>
+        ///     Gets the cooler identification number or index
+        /// </summary>
+        public int CoolerId { get; }
+
+        /// <summary>
+        ///     Gets the cooler type
+        /// </summary>
+        public CoolerType CoolerType { get; }
+
+        /// <summary>
+        ///     Gets the GPU fan speed in revolutions per minute
+        /// </summary>
+        public int CurrentFanSpeedInRPM { get; }
+
+        /// <summary>
+        ///     Gets the cooler current level in percentage
+        /// </summary>
+        public int CurrentLevel { get; }
+
+
+        /// <summary>
+        ///     Gets the cooler current maximum level in percentage
+        /// </summary>
+        public int CurrentMaximumLevel { get; }
+
+
+        /// <summary>
+        ///     Gets the cooler current minimum level in percentage
+        /// </summary>
+        public int CurrentMinimumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler current policy
+        /// </summary>
+        public CoolerPolicy CurrentPolicy { get; }
+
+        /// <summary>
+        ///     Gets the cooler default maximum level in percentage
+        /// </summary>
+        public int DefaultMaximumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler default minimum level in percentage
+        /// </summary>
+        public int DefaultMinimumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler default policy
+        /// </summary>
+        public CoolerPolicy DefaultPolicy { get; }
+
+        /// <summary>
+        ///     Gets the cooler target
+        /// </summary>
+        public CoolerTarget Target { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{CoolerId} @ {CoolerController}] {Target}: {CurrentLevel}%";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUCoolerInformation.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU coolers and current fan speed
+    /// </summary>
+    public class GPUCoolerInformation
+    {
+        internal GPUCoolerInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+
+            // TODO: Add Support For Pascal Only Policy Table Method
+            // TODO: GPUApi.GetCoolerPolicyTable & GPUApi.SetCoolerPolicyTable & GPUApi.RestoreCoolerPolicyTable
+            // TODO: Better support of ClientFanCoolers set of APIs
+        }
+
+        /// <summary>
+        ///     Gets a list of all available coolers along with their current settings and status
+        /// </summary>
+        public IEnumerable<GPUCooler> Coolers
+        {
+            get
+            {
+                PrivateCoolerSettingsV1? settings = null;
+
+                try
+                {
+                    settings = GPUApi.GetCoolerSettings(PhysicalGPU.Handle);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status != Status.NotSupported)
+                    {
+                        throw;
+                    }
+                }
+
+                if (settings != null)
+                {
+                    for (var i = 0; i < settings.Value.CoolerSettings.Length; i++)
+                    {
+                        if (i == 0)
+                        {
+                            var currentRPM = -1;
+                            try
+                            {
+                                currentRPM = (int)GPUApi.GetTachReading(PhysicalGPU.Handle);
+                            }
+                            catch (NVIDIAApiException)
+                            {
+                                // ignored
+                            }
+
+                            if (currentRPM >= 0)
+                            {
+                                yield return new GPUCooler(
+                                    i,
+                                    settings.Value.CoolerSettings[i],
+                                    currentRPM
+                                );
+                                continue;
+                            }
+                        }
+
+                        yield return new GPUCooler(
+                            i,
+                            settings.Value.CoolerSettings[i]
+                        );
+                    }
+
+                    yield break;
+                }
+
+                PrivateFanCoolersStatusV1? status = null;
+                PrivateFanCoolersInfoV1? info = null;
+                PrivateFanCoolersControlV1? control = null;
+
+                try
+                {
+                    status = GPUApi.GetClientFanCoolersStatus(PhysicalGPU.Handle);
+                    info = GPUApi.GetClientFanCoolersInfo(PhysicalGPU.Handle);
+                    control = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status != Status.NotSupported)
+                    {
+                        throw;
+                    }
+                }
+
+                if (status != null && info != null && control != null)
+                {
+                    for (var i = 0; i < status.Value.FanCoolersStatusEntries.Length; i++)
+                    {
+                        if (info.Value.FanCoolersInfoEntries.Length > i &&
+                            control.Value.FanCoolersControlEntries.Length > i)
+                        {
+                            yield return new GPUCooler(
+                                info.Value.FanCoolersInfoEntries[i],
+                                status.Value.FanCoolersStatusEntries[i],
+                                control.Value.FanCoolersControlEntries[i]
+                            );
+                        }
+                    }
+
+                    yield break;
+                }
+
+                throw new NVIDIAApiException(Status.NotSupported);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the GPU fan speed in revolutions per minute
+        /// </summary>
+        public int CurrentFanSpeedInRPM
+        {
+            get
+            {
+                try
+                {
+                    return (int) GPUApi.GetTachReading(PhysicalGPU.Handle);
+                }
+                catch
+                {
+                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentFanSpeedInRPM ??
+                           0;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current fan speed in percentage if available
+        /// </summary>
+        public int CurrentFanSpeedLevel
+        {
+            get
+            {
+                try
+                {
+                    return (int) GPUApi.GetCurrentFanSpeedLevel(PhysicalGPU.Handle);
+                }
+                catch
+                {
+                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentLevel ?? 0;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{CurrentFanSpeedInRPM} RPM ({CurrentFanSpeedLevel}%)";
+        }
+
+        /// <summary>
+        ///     Resets all cooler settings to default.
+        /// </summary>
+        public void RestoreCoolerSettingsToDefault()
+        {
+            RestoreCoolerSettingsToDefault(Coolers.Select(cooler => cooler.CoolerId).ToArray());
+        }
+
+        /// <summary>
+        ///     Resets one or more cooler settings to default.
+        /// </summary>
+        /// <param name="coolerIds">The cooler identification numbers (indexes) to reset their settings to default.</param>
+        public void RestoreCoolerSettingsToDefault(params int[] coolerIds)
+        {
+            var availableCoolerIds = Coolers.Select(cooler => cooler.CoolerId).ToArray();
+
+            if (coolerIds.Any(i => !availableCoolerIds.Contains(i)))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerIds));
+            }
+
+            try
+            {
+                GPUApi.RestoreCoolerSettings(PhysicalGPU.Handle, coolerIds.Select(i => (uint) i).ToArray());
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => coolerIds.Contains((int) entry.CoolerId)
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                FanCoolersControlMode.Auto
+                            )
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler settings by modifying the policy and the current level
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="policy">The new cooler policy.</param>
+        /// <param name="newLevel">The new cooler level. Valid only if policy is set to manual.</param>
+        // ReSharper disable once TooManyDeclarations
+        public void SetCoolerSettings(int coolerId, CoolerPolicy policy, int newLevel)
+        {
+            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
+            }
+
+            try
+            {
+                GPUApi.SetCoolerLevels(
+                    PhysicalGPU.Handle,
+                    (uint) coolerId,
+                    new PrivateCoolerLevelsV1(new[]
+                        {
+                            new PrivateCoolerLevelsV1.CoolerLevel(policy, (uint) newLevel)
+                        }
+                    ),
+                    1
+                );
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => entry.CoolerId == coolerId
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                policy == CoolerPolicy.Manual
+                                    ? FanCoolersControlMode.Manual
+                                    : FanCoolersControlMode.Auto,
+                                policy == CoolerPolicy.Manual ? (uint)newLevel : 0u)
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler setting by modifying the policy
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="policy">The new cooler policy.</param>
+        // ReSharper disable once TooManyDeclarations
+        public void SetCoolerSettings(int coolerId, CoolerPolicy policy)
+        {
+            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
+            }
+
+            try
+            {
+                GPUApi.SetCoolerLevels(
+                    PhysicalGPU.Handle,
+                    (uint) coolerId,
+                    new PrivateCoolerLevelsV1(new[]
+                        {
+                            new PrivateCoolerLevelsV1.CoolerLevel(policy)
+                        }
+                    ),
+                    1
+                );
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => entry.CoolerId == coolerId
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                policy == CoolerPolicy.Manual
+                                    ? FanCoolersControlMode.Manual
+                                    : FanCoolersControlMode.Auto)
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler settings by modifying the policy to manual and sets a new level
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="newLevel">The new cooler level.</param>
+        public void SetCoolerSettings(int coolerId, int newLevel)
+        {
+            SetCoolerSettings(coolerId, CoolerPolicy.Manual, newLevel);
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUMemoryInformation.cs

@@ -0,0 +1,222 @@
+using System;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information regarding the available and total memory as well as the type of memory and other information
+    ///     regarding the GPU RAM and frame buffer
+    /// </summary>
+    public class GPUMemoryInformation : IDisplayDriverMemoryInfo
+    {
+        internal GPUMemoryInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer bandwidth
+        /// </summary>
+
+        public int FrameBufferBandwidth
+        {
+            get
+            {
+                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out var width, out _);
+
+                return (int) width;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer location index
+        /// </summary>
+        public int FrameBufferLocation
+        {
+            get
+            {
+                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out _, out var location);
+
+                return (int) location;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the internal clock to bus clock factor based on the type of RAM
+        /// </summary>
+        public int InternalClockToBusClockFactor
+        {
+            get => GetMemoryBusClockFactor(RAMType);
+        }
+
+        /// <summary>
+        ///     Gets the internal clock to transfer rate factor based on the type of RAM
+        /// </summary>
+        public int InternalClockToTransferRateFactor
+        {
+            get => GetMemoryTransferRateFactor(RAMType);
+        }
+
+        /// <summary>
+        ///     Gets GPU physical frame buffer size in KB. This does NOT include any system RAM that may be dedicated for use by
+        ///     the GPU.
+        /// </summary>
+        public int PhysicalFrameBufferSizeInkB
+        {
+            get => GPUApi.GetPhysicalFrameBufferSize(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the number of memory banks
+        /// </summary>
+        public uint RAMBanks
+        {
+            get => GPUApi.GetRAMBankCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory bus width
+        /// </summary>
+        public uint RAMBusWidth
+        {
+            get => GPUApi.GetRAMBusWidth(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory maker (brand)
+        /// </summary>
+        public GPUMemoryMaker RAMMaker
+        {
+            get => GPUApi.GetRAMMaker(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory type
+        /// </summary>
+        public GPUMemoryType RAMType
+        {
+            get => GPUApi.GetRAMType(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets virtual size of frame-buffer in KB for this GPU. This includes the physical RAM plus any system RAM that has
+        ///     been dedicated for use by the GPU.
+        /// </summary>
+        public int VirtualFrameBufferSizeInkB
+        {
+            get => GPUApi.GetVirtualFrameBufferSize(PhysicalGPU.Handle);
+        }
+
+        /// <inheritdoc />
+        public uint AvailableDedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).AvailableDedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint CurrentAvailableDedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).CurrentAvailableDedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint DedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).DedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint SharedSystemMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SharedSystemMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint SystemVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SystemVideoMemoryInkB;
+        }
+
+        /// <summary>
+        ///     Gets the memory bus clock to internal memory clock factor
+        /// </summary>
+        /// <param name="memoryType"></param>
+        /// <returns>The value of X in X(InternalMemoryClock)=(BusMemoryClock)</returns>
+        public static int GetMemoryBusClockFactor(GPUMemoryType memoryType)
+        {
+            switch (memoryType)
+            {
+                case GPUMemoryType.SDRAM:
+
+                    // Bus Clocks Per Internal Clock = 1
+                    return 1;
+                case GPUMemoryType.DDR1:
+                case GPUMemoryType.DDR2:
+                case GPUMemoryType.DDR3:
+                case GPUMemoryType.GDDR2:
+                case GPUMemoryType.GDDR3:
+                case GPUMemoryType.GDDR4:
+                case GPUMemoryType.LPDDR2:
+                case GPUMemoryType.GDDR5:
+                case GPUMemoryType.GDDR5X:
+
+                    // Bus Clocks Per Internal Clock = 2
+                    return 2;
+                default:
+
+                    throw new ArgumentOutOfRangeException(nameof(memoryType));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of transfers per internal memory clock factor
+        /// </summary>
+        /// <param name="memoryType"></param>
+        /// <returns>The value of X in X(InternalMemoryClock)=(OperationsPerSecond)</returns>
+        public static int GetMemoryTransferRateFactor(GPUMemoryType memoryType)
+        {
+            switch (memoryType)
+            {
+                case GPUMemoryType.SDRAM:
+
+                    // Transfers Per Internal Clock = 1
+                    return 1;
+                case GPUMemoryType.DDR1:
+                case GPUMemoryType.DDR2:
+                case GPUMemoryType.DDR3:
+                case GPUMemoryType.GDDR2:
+                case GPUMemoryType.GDDR3:
+                case GPUMemoryType.GDDR4:
+                case GPUMemoryType.LPDDR2:
+
+                    // Transfers Per Internal Clock = 1
+                    return 2;
+                case GPUMemoryType.GDDR5:
+
+                    // Transfers Per Internal Clock = 2
+                    return 4;
+                case GPUMemoryType.GDDR5X:
+
+                    // Transfers Per Internal Clock = 4
+                    return 8;
+                default:
+
+                    throw new ArgumentOutOfRangeException(nameof(memoryType));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{RAMMaker} {RAMType}] Total: {AvailableDedicatedVideoMemoryInkB:N0} kB - Available: {CurrentAvailableDedicatedVideoMemoryInkB:N0} kB";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUOutput.cs

@@ -0,0 +1,264 @@
+using System;
+using NvAPIWrapper.Display;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a single GPU output
+    /// </summary>
+    public class GPUOutput : IEquatable<GPUOutput>
+    {
+        internal GPUOutput(OutputId outputId, PhysicalGPUHandle gpuHandle)
+        {
+            OutputId = outputId;
+            OutputType = !gpuHandle.IsNull ? GPUApi.GetOutputType(gpuHandle, outputId) : OutputType.Unknown;
+            PhysicalGPU = new PhysicalGPU(gpuHandle);
+        }
+
+        internal GPUOutput(OutputId outputId, PhysicalGPU gpu)
+            : this(outputId, gpu?.Handle ?? PhysicalGPUHandle.DefaultHandle)
+        {
+            PhysicalGPU = gpu;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding Digital Vibrance Control information
+        /// </summary>
+        public DVCInformation DigitalVibranceControl
+        {
+            get => new DVCInformation(OutputId);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding HUE information
+        /// </summary>
+        public HUEInformation HUEControl
+        {
+            get => new HUEInformation(OutputId);
+        }
+
+        /// <summary>
+        ///     Gets the output identification as a single bit unsigned integer
+        /// </summary>
+        public OutputId OutputId { get; }
+
+        /// <summary>
+        ///     Gets the output type
+        /// </summary>
+        public OutputType OutputType { get; }
+
+        /// <summary>
+        ///     Gets the corresponding physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public bool Equals(GPUOutput other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return PhysicalGPU.Equals(other.PhysicalGPU) && OutputId == other.OutputId;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(GPUOutput left, GPUOutput right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(GPUOutput left, GPUOutput right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((GPUOutput) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((PhysicalGPU != null ? PhysicalGPU.GetHashCode() : 0) * 397) ^ (int) OutputId;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{OutputId} {OutputType} @ {PhysicalGPU}";
+        }
+
+        /// <summary>
+        ///     Overrides the refresh rate on this output.
+        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
+        ///     mode-set.
+        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
+        /// </summary>
+        /// <param name="refreshRate">The refresh rate to be applied.</param>
+        /// <param name="isDeferred">
+        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
+        ///     mode-set.
+        /// </param>
+        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
+        {
+            DisplayApi.SetRefreshRateOverride(OutputId, refreshRate, isDeferred);
+        }
+
+        /// <summary>
+        ///     Reads data from the I2C bus
+        /// </summary>
+        /// <param name="portId">The port id on which device is connected</param>
+        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
+        /// <param name="deviceAddress">The device I2C slave address</param>
+        /// <param name="registerAddress">The target I2C register address</param>
+        /// <param name="readDataLength">The length of the buffer to allocate for the read operation.</param>
+        /// <param name="speed">The target speed of the transaction in kHz</param>
+        public byte[] ReadI2C(
+            byte? portId,
+            bool useDDCPort,
+            byte deviceAddress,
+            byte[] registerAddress,
+            uint readDataLength,
+            I2CSpeed speed = I2CSpeed.Default
+        )
+        {
+            try
+            {
+                // ReSharper disable once InconsistentNaming
+                var i2cInfoV3 = new I2CInfoV3(
+                    OutputId,
+                    portId,
+                    useDDCPort,
+                    deviceAddress,
+                    registerAddress,
+                    readDataLength,
+                    speed
+                );
+
+                return PhysicalGPU.ReadI2C(i2cInfoV3);
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            // ReSharper disable once InconsistentNaming
+            var i2cInfoV2 = new I2CInfoV2(
+                OutputId,
+                useDDCPort,
+                deviceAddress,
+                registerAddress,
+                readDataLength,
+                speed
+            );
+
+            return PhysicalGPU.ReadI2C(i2cInfoV2);
+        }
+
+        /// <summary>
+        ///     Writes data to the I2C bus
+        /// </summary>
+        /// <param name="portId">The port id on which device is connected</param>
+        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
+        /// <param name="deviceAddress">The device I2C slave address</param>
+        /// <param name="registerAddress">The target I2C register address</param>
+        /// <param name="data">The payload data</param>
+        /// <param name="speed">The target speed of the transaction in kHz</param>
+        public void WriteI2C(
+            byte? portId,
+            bool useDDCPort,
+            byte deviceAddress,
+            byte[] registerAddress,
+            byte[] data,
+            I2CSpeed speed = I2CSpeed.Default
+        )
+        {
+            try
+            {
+                // ReSharper disable once InconsistentNaming
+                var i2cInfoV3 = new I2CInfoV3(
+                    OutputId,
+                    portId,
+                    useDDCPort,
+                    deviceAddress,
+                    registerAddress,
+                    data,
+                    speed
+                );
+
+                PhysicalGPU.WriteI2C(i2cInfoV3);
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            // ReSharper disable once InconsistentNaming
+            var i2cInfoV2 = new I2CInfoV2(
+                OutputId,
+                useDDCPort,
+                deviceAddress,
+                registerAddress,
+                data,
+                speed
+            );
+
+            PhysicalGPU.WriteI2C(i2cInfoV2);
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceControl.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information regarding the GPU performance control and limitations
+    /// </summary>
+    public class GPUPerformanceControl
+    {
+        internal GPUPerformanceControl(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the current active performance limitation
+        /// </summary>
+        public PerformanceLimit CurrentActiveLimit
+        {
+            get => GPUApi.PerformancePoliciesGetStatus(PhysicalGPU.Handle).PerformanceLimit;
+        }
+
+        /// <summary>
+        ///     Gets the current performance decrease reason
+        /// </summary>
+        public PerformanceDecreaseReason CurrentPerformanceDecreaseReason
+        {
+            get => GPUApi.GetPerformanceDecreaseInfo(PhysicalGPU.Handle);
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if no load limit is supported with this GPU
+        /// </summary>
+        public bool IsNoLoadLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsNoLoadLimitSupported;
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if power limit is supported with this GPU
+        /// </summary>
+        public bool IsPowerLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsPowerLimitSupported;
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if temperature limit is supported with this GPU
+        /// </summary>
+        public bool IsTemperatureLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsTemperatureLimitSupported;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if voltage limit is supported with this GPU
+        /// </summary>
+        public bool IsVoltageLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsVoltageLimitSupported;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets information regarding possible power limit policies and their acceptable range
+        /// </summary>
+        public IEnumerable<GPUPowerLimitInfo> PowerLimitInformation
+        {
+            get
+            {
+                return GPUApi.ClientPowerPoliciesGetInfo(PhysicalGPU.Handle).PowerPolicyInfoEntries
+                    .Select(entry => new GPUPowerLimitInfo(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current active power limit policies
+        /// </summary>
+        public IEnumerable<GPUPowerLimitPolicy> PowerLimitPolicies
+        {
+            get
+            {
+                // TODO: GPUApi.ClientPowerPoliciesSetStatus();
+                return GPUApi.ClientPowerPoliciesGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
+                    .Select(entry => new GPUPowerLimitPolicy(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets information regarding possible thermal limit policies and their acceptable range
+        /// </summary>
+        public IEnumerable<GPUThermalLimitInfo> ThermalLimitInformation
+        {
+            get
+            {
+                return GPUApi.GetThermalPoliciesInfo(PhysicalGPU.Handle).ThermalPoliciesInfoEntries
+                    .Select(entry => new GPUThermalLimitInfo(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current active thermal limit policies
+        /// </summary>
+        public IEnumerable<GPUThermalLimitPolicy> ThermalLimitPolicies
+        {
+            get
+            {
+                // TODO: GPUApi.SetThermalPoliciesStatus();
+                return GPUApi.GetThermalPoliciesStatus(PhysicalGPU.Handle).ThermalPoliciesStatusEntries
+                    .Select(entry => new GPUThermalLimitPolicy(entry));
+            }
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceState.cs

@@ -0,0 +1,70 @@
+using System.Linq;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state
+    /// </summary>
+    public class GPUPerformanceState
+    {
+        // ReSharper disable once TooManyDependencies
+        internal GPUPerformanceState(
+            int index,
+            IPerformanceState20 performanceState,
+            IPerformanceStates20ClockEntry[] statesClockEntries,
+            IPerformanceStates20VoltageEntry[] baseVoltageEntries,
+            PCIeInformation pcieInformation)
+        {
+            StateIndex = index;
+            StateId = performanceState.StateId;
+            IsReadOnly = !performanceState.IsEditable;
+            Clocks = statesClockEntries.Select(entry => new GPUPerformanceStateClock(entry)).ToArray();
+            Voltages = baseVoltageEntries.Select(entry => new GPUPerformanceStateVoltage(entry)).ToArray();
+            PCIeInformation = pcieInformation;
+        }
+
+        /// <summary>
+        ///     Gets a list of clocks associated with this performance state
+        /// </summary>
+
+        public GPUPerformanceStateClock[] Clocks { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this performance state is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e information regarding this performance state.
+        /// </summary>
+        public PCIeInformation PCIeInformation { get; }
+
+        /// <summary>
+        ///     Gets the performance state identification
+        /// </summary>
+        public PerformanceStateId StateId { get; }
+
+        /// <summary>
+        ///     Gets the state index
+        /// </summary>
+        public int StateIndex { get; }
+
+        /// <summary>
+        ///     Gets a list of voltages associated with this performance state
+        /// </summary>
+        public GPUPerformanceStateVoltage[] Voltages { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (IsReadOnly)
+            {
+                return $"{StateId} (ReadOnly)";
+            }
+
+            return StateId.ToString();
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceStateClock.cs

@@ -0,0 +1,99 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state clock settings
+    /// </summary>
+    public class GPUPerformanceStateClock
+    {
+        internal GPUPerformanceStateClock(IPerformanceStates20ClockEntry states20ClockEntry)
+        {
+            ClockDomain = states20ClockEntry.DomainId;
+            IsReadOnly = !states20ClockEntry.IsEditable;
+            ClockDeltaInkHz = states20ClockEntry.FrequencyDeltaInkHz.DeltaValue;
+            ClockDeltaRangeInkHz = new GPUPerformanceStateValueRange(
+                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Minimum,
+                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Maximum
+            );
+
+            if (states20ClockEntry.ClockType == PerformanceStates20ClockType.Range)
+            {
+                CurrentClockInkHz = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.FrequencyRange.MinimumFrequencyInkHz,
+                    states20ClockEntry.FrequencyRange.MaximumFrequencyInkHz
+                );
+                BaseClockInkHz = new GPUPerformanceStateValueRange(
+                    CurrentClockInkHz.Minimum - ClockDeltaInkHz,
+                    CurrentClockInkHz.Maximum - ClockDeltaInkHz
+                );
+                DependentVoltageDomain = states20ClockEntry.FrequencyRange.VoltageDomainId;
+                DependentVoltageRangeInMicroVolt = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.FrequencyRange.MinimumVoltageInMicroVolt,
+                    states20ClockEntry.FrequencyRange.MaximumVoltageInMicroVolt
+                );
+            }
+            else
+            {
+                CurrentClockInkHz = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.SingleFrequency.FrequencyInkHz
+                );
+                BaseClockInkHz = new GPUPerformanceStateValueRange(
+                    CurrentClockInkHz.Minimum - ClockDeltaInkHz
+                );
+                DependentVoltageDomain = PerformanceVoltageDomain.Undefined;
+                DependentVoltageRangeInMicroVolt = null;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the base clock frequency in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange BaseClockInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock frequency delta in kHz
+        /// </summary>
+        public int ClockDeltaInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock frequency delta range in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange ClockDeltaRangeInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock domain
+        /// </summary>
+        public PublicClockDomain ClockDomain { get; }
+
+        /// <summary>
+        ///     Gets the current clock frequency in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange CurrentClockInkHz { get; }
+
+        /// <summary>
+        ///     Gets the dependent voltage domain
+        /// </summary>
+        public PerformanceVoltageDomain DependentVoltageDomain { get; }
+
+        /// <summary>
+        ///     Gets the dependent voltage range in uV
+        /// </summary>
+        public GPUPerformanceStateValueRange DependentVoltageRangeInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this clock setting is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var title = IsReadOnly ? $"{ClockDomain} (ReadOnly)" : ClockDomain.ToString();
+
+            return
+                $"{title}: {BaseClockInkHz} + ({ClockDeltaInkHz}) = {CurrentClockInkHz}";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceStateValueRange.cs

@@ -0,0 +1,115 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents an integer value range
+    /// </summary>
+    public class GPUPerformanceStateValueRange : IEquatable<GPUPerformanceStateValueRange>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="GPUPerformanceStateValueRange" />.
+        /// </summary>
+        /// <param name="min">The lower bound of the range.</param>
+        /// <param name="max">The upper bound of the range.</param>
+        public GPUPerformanceStateValueRange(long min, long max)
+        {
+            Minimum = min;
+            Maximum = max;
+        }
+
+        /// <summary>
+        ///     Creates a new single value instance of <see cref="GPUPerformanceStateValueRange" />.
+        /// </summary>
+        /// <param name="value">The only value in the range</param>
+        public GPUPerformanceStateValueRange(long value)
+        {
+            Minimum = value;
+            Maximum = value;
+        }
+
+        /// <summary>
+        ///     Gets the upper bound of the inclusive range
+        /// </summary>
+        public long Maximum { get; }
+
+        /// <summary>
+        ///     Gets the lower bound of the inclusive range
+        /// </summary>
+        public long Minimum { get; }
+
+        /// <inheritdoc />
+        public bool Equals(GPUPerformanceStateValueRange other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Maximum == other.Maximum && Minimum == other.Minimum;
+        }
+
+        /// <summary>
+        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for equality.
+        /// </summary>
+        /// <param name="left">The left side of the comparison.</param>
+        /// <param name="right">The right side of the comparison.</param>
+        /// <returns>true if instances are equal, otherwise false</returns>
+        public static bool operator ==(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for inequality.
+        /// </summary>
+        /// <param name="left">The left side of the comparison.</param>
+        /// <param name="right">The right side of the comparison.</param>
+        /// <returns>true if instances are in-equal, otherwise false</returns>
+        public static bool operator !=(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as GPUPerformanceStateValueRange);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((int) Maximum * 397) ^ (int) Minimum;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (Minimum == Maximum)
+            {
+                return $"({Minimum})";
+            }
+
+            return $"[({Minimum}) - ({Maximum})]";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceStateVoltage.cs

@@ -0,0 +1,65 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state voltage settings
+    /// </summary>
+    public class GPUPerformanceStateVoltage
+    {
+        internal GPUPerformanceStateVoltage(IPerformanceStates20VoltageEntry states20BaseVoltageEntry)
+        {
+            VoltageDomain = states20BaseVoltageEntry.DomainId;
+            IsReadOnly = !states20BaseVoltageEntry.IsEditable;
+
+            CurrentVoltageInMicroVolt = states20BaseVoltageEntry.ValueInMicroVolt;
+            VoltageDeltaInMicroVolt = states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaValue;
+            BaseVoltageInMicroVolt = (int) (CurrentVoltageInMicroVolt - VoltageDeltaInMicroVolt);
+
+            VoltageDeltaRangeInMicroVolt = new GPUPerformanceStateValueRange(
+                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Minimum,
+                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Maximum
+            );
+        }
+
+        /// <summary>
+        ///     Gets the base voltage in uV
+        /// </summary>
+        public int BaseVoltageInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the current voltage in uV
+        /// </summary>
+        public uint CurrentVoltageInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this voltage is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets the voltage delta in uV
+        /// </summary>
+        public int VoltageDeltaInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the voltage delta range in uV
+        /// </summary>
+        public GPUPerformanceStateValueRange VoltageDeltaRangeInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the voltage domain
+        /// </summary>
+        public PerformanceVoltageDomain VoltageDomain { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var title = IsReadOnly ? $"{VoltageDomain} (ReadOnly)" : VoltageDomain.ToString();
+
+            return
+                $"{title}: ({BaseVoltageInMicroVolt}) + ({VoltageDeltaInMicroVolt}) = ({CurrentVoltageInMicroVolt})";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPerformanceStatesInfo.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds the retrieved performance states information
+    /// </summary>
+    public class GPUPerformanceStatesInformation
+    {
+        internal GPUPerformanceStatesInformation(
+            IPerformanceStates20Info states20Info,
+            PerformanceStateId currentPerformanceStateId,
+            PrivatePCIeInfoV2? pciInformation)
+        {
+            IsReadOnly = !states20Info.IsEditable;
+
+            GlobalVoltages = states20Info.GeneralVoltages
+                .Select(entry => new GPUPerformanceStateVoltage(entry))
+                .ToArray();
+
+            var clocks = states20Info.Clocks;
+            var baseVoltages = states20Info.Voltages;
+
+            PerformanceStates = states20Info.PerformanceStates.Select((state20, i) =>
+            {
+                PCIeInformation statePCIeInfo = null;
+
+                if (pciInformation != null && pciInformation.Value.PCIePerformanceStateInfos.Length > i)
+                {
+                    statePCIeInfo = new PCIeInformation(pciInformation.Value.PCIePerformanceStateInfos[i]);
+                }
+
+                return new GPUPerformanceState(
+                    i,
+                    state20,
+                    clocks[state20.StateId],
+                    baseVoltages[state20.StateId],
+                    statePCIeInfo
+                );
+            }).ToArray();
+
+            CurrentPerformanceState =
+                PerformanceStates.FirstOrDefault(performanceState =>
+                    performanceState.StateId == currentPerformanceStateId);
+        }
+
+        /// <summary>
+        ///     Gets the currently active performance state
+        /// </summary>
+        public GPUPerformanceState CurrentPerformanceState { get; }
+
+        /// <summary>
+        ///     Gets a list of global voltage settings
+        /// </summary>
+        public GPUPerformanceStateVoltage[] GlobalVoltages { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if performance states are readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets a list of all available performance states
+        /// </summary>
+        public GPUPerformanceState[] PerformanceStates { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (PerformanceStates.Length == 0)
+            {
+                return "No Performance State Available";
+            }
+
+            return string.Join(
+                ", ",
+                PerformanceStates
+                    .Select(
+                        state =>
+                        {
+                            var attributes = new List<string>();
+
+                            if (state.IsReadOnly)
+                            {
+                                attributes.Add("ReadOnly");
+                            }
+
+                            if (CurrentPerformanceState.StateId == state.StateId)
+                            {
+                                attributes.Add("Active");
+                            }
+
+                            if (attributes.Any())
+                            {
+                                return $"{state.StateId} ({string.Join(" - ", attributes)})";
+                            }
+
+                            return state.StateId.ToString();
+                        })
+            );
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPowerLimitInfo.cs

@@ -0,0 +1,70 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a possible power limit policy and its acceptable range
+    /// </summary>
+    public class GPUPowerLimitInfo
+    {
+        internal GPUPowerLimitInfo(PrivatePowerPoliciesInfoV1.PowerPolicyInfoEntry powerPolicyInfoEntry)
+        {
+            PerformanceStateId = powerPolicyInfoEntry.PerformanceStateId;
+            MinimumPowerInPCM = powerPolicyInfoEntry.MinimumPowerInPCM;
+            DefaultPowerInPCM = powerPolicyInfoEntry.DefaultPowerInPCM;
+            MaximumPowerInPCM = powerPolicyInfoEntry.MaximumPowerInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the default policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint DefaultPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the default policy target power in percentage
+        /// </summary>
+        public float DefaultPowerInPercent
+        {
+            get => DefaultPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the maximum possible policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint MaximumPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the maximum possible policy target power in percentage
+        /// </summary>
+        public float MaximumPowerInPercent
+        {
+            get => MaximumPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint MinimumPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target power in percentage
+        /// </summary>
+        public float MinimumPowerInPercent
+        {
+            get => MinimumPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{PerformanceStateId}] Default: {DefaultPowerInPercent}% - Range: ({MinimumPowerInPercent}% - {MaximumPowerInPercent}%)";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPowerLimitPolicy.cs

@@ -0,0 +1,41 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a currently active power limit policy
+    /// </summary>
+    public class GPUPowerLimitPolicy
+    {
+        internal GPUPowerLimitPolicy(PrivatePowerPoliciesStatusV1.PowerPolicyStatusEntry powerPolicyStatusEntry)
+        {
+            PerformanceStateId = powerPolicyStatusEntry.PerformanceStateId;
+            PowerTargetInPCM = powerPolicyStatusEntry.PowerTargetInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <summary>
+        ///     Gets the current policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint PowerTargetInPCM { get; }
+
+        /// <summary>
+        ///     Gets the current policy target power in percentage
+        /// </summary>
+        public float PowerTargetInPercent
+        {
+            get => PowerTargetInPCM / 1000f;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{PerformanceStateId} Target: {PowerTargetInPercent}%";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPowerTopologyInformation.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding current power topology and their current power usage
+    /// </summary>
+    public class GPUPowerTopologyInformation
+    {
+        internal GPUPowerTopologyInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the current power topology entries
+        /// </summary>
+        public IEnumerable<GPUPowerTopologyStatus> PowerTopologyEntries
+        {
+            get
+            {
+                return GPUApi.ClientPowerTopologyGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
+                    .Select(entry => new GPUPowerTopologyStatus(entry));
+            }
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUPowerTopologyStatus.cs

@@ -0,0 +1,42 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about a power domain usage
+    /// </summary>
+    public class GPUPowerTopologyStatus
+    {
+        internal GPUPowerTopologyStatus(
+            PrivatePowerTopologiesStatusV1.PowerTopologiesStatusEntry powerTopologiesStatusEntry)
+        {
+            Domain = powerTopologiesStatusEntry.Domain;
+            PowerUsageInPCM = powerTopologiesStatusEntry.PowerUsageInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the power usage domain
+        /// </summary>
+        public PowerTopologyDomain Domain { get; }
+
+        /// <summary>
+        ///     Gets the current power usage in per cent mille (PCM)
+        /// </summary>
+        public uint PowerUsageInPCM { get; }
+
+        /// <summary>
+        ///     Gets the current power usage in percentage
+        /// </summary>
+        public float PowerUsageInPercent
+        {
+            get => PowerUsageInPCM / 1000f;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{Domain}] {PowerUsageInPercent}%";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUThermalInformation.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding the available thermal sensors and current thermal level of a GPU
+    /// </summary>
+    public class GPUThermalInformation
+    {
+        internal GPUThermalInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the current thermal level of the GPU
+        /// </summary>
+        public int CurrentThermalLevel
+        {
+            get => (int) GPUApi.GetCurrentThermalLevel(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the list of available thermal sensors
+        /// </summary>
+        public IEnumerable<GPUThermalSensor> ThermalSensors
+        {
+            get
+            {
+                return GPUApi.GetThermalSettings(PhysicalGPU.Handle).Sensors
+                    .Select((sensor, i) => new GPUThermalSensor(i, sensor));
+            }
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUThermalLimitInfo.cs

@@ -0,0 +1,47 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a possible thermal limit policy and its acceptable range
+    /// </summary>
+    public class GPUThermalLimitInfo
+    {
+        internal GPUThermalLimitInfo(PrivateThermalPoliciesInfoV2.ThermalPoliciesInfoEntry policiesInfoEntry)
+        {
+            Controller = policiesInfoEntry.Controller;
+            MinimumTemperature = policiesInfoEntry.MinimumTemperature;
+            DefaultTemperature = policiesInfoEntry.DefaultTemperature;
+            MaximumTemperature = policiesInfoEntry.MaximumTemperature;
+        }
+
+        /// <summary>
+        ///     Gets the policy's thermal controller
+        /// </summary>
+        public ThermalController Controller { get; }
+
+        /// <summary>
+        ///     Gets the default policy target temperature in degree Celsius
+        /// </summary>
+        public int DefaultTemperature { get; }
+
+
+        /// <summary>
+        ///     Gets the maximum possible policy target temperature in degree Celsius
+        /// </summary>
+        public int MaximumTemperature { get; }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target temperature in degree Celsius
+        /// </summary>
+        public int MinimumTemperature { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{Controller}] Default: {DefaultTemperature}°C - Range: ({MinimumTemperature}°C - {MaximumTemperature}°C)";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUThermalLimitPolicy.cs

@@ -0,0 +1,40 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a currently active temperature limit policy
+    /// </summary>
+    public class GPUThermalLimitPolicy
+    {
+        internal GPUThermalLimitPolicy(PrivateThermalPoliciesStatusV2.ThermalPoliciesStatusEntry thermalPoliciesEntry)
+        {
+            Controller = thermalPoliciesEntry.Controller;
+            PerformanceStateId = thermalPoliciesEntry.PerformanceStateId;
+            TargetTemperature = thermalPoliciesEntry.TargetTemperature;
+        }
+
+        /// <summary>
+        ///     Gets the policy's thermal controller
+        /// </summary>
+        public ThermalController Controller { get; }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <summary>
+        ///     Gets the current policy target temperature in degree Celsius
+        /// </summary>
+        public int TargetTemperature { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"{PerformanceStateId} [{Controller}] Target: {TargetTemperature}°C";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUThermalSensor.cs

@@ -0,0 +1,48 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a thermal sensor
+    /// </summary>
+    public class GPUThermalSensor : IThermalSensor
+    {
+        internal GPUThermalSensor(int sensorId, IThermalSensor thermalSensor)
+        {
+            SensorId = sensorId;
+            Controller = thermalSensor.Controller;
+            DefaultMinimumTemperature = thermalSensor.DefaultMinimumTemperature;
+            DefaultMaximumTemperature = thermalSensor.DefaultMaximumTemperature;
+            CurrentTemperature = thermalSensor.CurrentTemperature;
+            Target = thermalSensor.Target;
+        }
+
+        /// <summary>
+        ///     Gets the sensor identification number or index
+        /// </summary>
+        public int SensorId { get; set; }
+
+        /// <inheritdoc />
+        public ThermalController Controller { get; }
+
+        /// <inheritdoc />
+        public int CurrentTemperature { get; }
+
+        /// <inheritdoc />
+        public int DefaultMaximumTemperature { get; }
+
+        /// <inheritdoc />
+        public int DefaultMinimumTemperature { get; }
+
+        /// <inheritdoc />
+        public ThermalSettingsTarget Target { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{Target} @ {Controller}] Current: {CurrentTemperature}°C - Default Range: [({DefaultMinimumTemperature}°C) , ({DefaultMaximumTemperature}°C)]";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUUsageDomainStatus.cs

@@ -0,0 +1,33 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information about a utilization domain
+    /// </summary>
+    public class GPUUsageDomainStatus
+    {
+        internal GPUUsageDomainStatus(UtilizationDomain domain, IUtilizationDomainInfo utilizationDomainInfo)
+        {
+            Domain = domain;
+            Percentage = (int) utilizationDomainInfo.Percentage;
+        }
+
+        /// <summary>
+        ///     Gets the utilization domain that this instance describes
+        /// </summary>
+        public UtilizationDomain Domain { get; }
+
+        /// <summary>
+        ///     Gets the percentage of time where the domain is considered busy in the last 1 second interval.
+        /// </summary>
+        public int Percentage { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{Domain}] {Percentage}%";
+        }
+    }
+}

app/NvAPIWrapper/GPU/GPUUsageInformation.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information about the GPU utilization domains
+    /// </summary>
+    public class GPUUsageInformation
+    {
+        internal GPUUsageInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the Bus interface (BUS) utilization
+        /// </summary>
+        public GPUUsageDomainStatus BusInterface
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.BusInterface);
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer (FB) utilization
+        /// </summary>
+        public GPUUsageDomainStatus FrameBuffer
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.FrameBuffer);
+        }
+
+        /// <summary>
+        ///     Gets the graphic engine (GPU) utilization
+        /// </summary>
+        public GPUUsageDomainStatus GPU
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.GPU);
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the dynamic performance states is enabled
+        /// </summary>
+        public bool IsDynamicPerformanceStatesEnabled
+        {
+            get => GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle).IsDynamicPerformanceStatesEnabled;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets all valid utilization domains and information
+        /// </summary>
+        public IEnumerable<GPUUsageDomainStatus> UtilizationDomainsStatus
+        {
+            get
+            {
+                try
+                {
+                    var dynamicPerformanceStates = GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle);
+
+                    if (dynamicPerformanceStates.IsDynamicPerformanceStatesEnabled)
+                    {
+                        return dynamicPerformanceStates.Domains
+                            .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
+                    }
+                }
+                catch
+                {
+                    // ignored
+                }
+
+                return GPUApi.GetUsages(PhysicalGPU.Handle).Domains
+                    .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the Video engine (VID) utilization
+        /// </summary>
+        public GPUUsageDomainStatus VideoEngine
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.VideoEngine);
+        }
+
+        /// <summary>
+        ///     Enables dynamic performance states
+        /// </summary>
+        public void EnableDynamicPerformanceStates()
+        {
+            GPUApi.EnableDynamicPStates(PhysicalGPU.Handle);
+        }
+    }
+}

app/NvAPIWrapper/GPU/LogicalGPU.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a logical NVIDIA GPU
+    /// </summary>
+    public class LogicalGPU : IEquatable<LogicalGPU>
+    {
+        /// <summary>
+        ///     Creates a new LogicalGPU
+        /// </summary>
+        /// <param name="handle">Logical GPU handle</param>
+        public LogicalGPU(LogicalGPUHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Gets a list of all corresponding physical GPUs
+        /// </summary>
+        public PhysicalGPU[] CorrespondingPhysicalGPUs
+        {
+            get
+            {
+                return GPUApi.GetPhysicalGPUsFromLogicalGPU(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
+            }
+        }
+
+        /// <summary>
+        ///     Gets the logical GPU handle
+        /// </summary>
+        public LogicalGPUHandle Handle { get; }
+
+        /// <inheritdoc />
+        public bool Equals(LogicalGPU other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     Gets all logical GPUs
+        /// </summary>
+        /// <returns>An array of logical GPUs</returns>
+        public static LogicalGPU[] GetLogicalGPUs()
+        {
+            return GPUApi.EnumLogicalGPUs().Select(handle => new LogicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(LogicalGPU left, LogicalGPU right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(LogicalGPU left, LogicalGPU right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((LogicalGPU) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"Logical GPU [{CorrespondingPhysicalGPUs.Length}] {{{string.Join(", ", CorrespondingPhysicalGPUs.Select(gpu => gpu.FullName).ToArray())}}}";
+        }
+    }
+}

app/NvAPIWrapper/GPU/PCIIdentifiers.cs

@@ -0,0 +1,114 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the PCI connection
+    /// </summary>
+    public class PCIIdentifiers : IEquatable<PCIIdentifiers>
+    {
+        // ReSharper disable once TooManyDependencies
+        internal PCIIdentifiers(uint deviceId, uint subSystemId, uint revisionId, int externalDeviceId = 0)
+        {
+            DeviceId = deviceId;
+            SubSystemId = subSystemId;
+            RevisionId = revisionId;
+
+            if (externalDeviceId > 0)
+            {
+                ExternalDeviceId = (ushort) externalDeviceId;
+            }
+            else
+            {
+                ExternalDeviceId = (ushort) (deviceId >> 16);
+            }
+
+            VendorId = (ushort) ((DeviceId << 16) >> 16);
+        }
+
+        /// <summary>
+        ///     Gets the internal PCI device identifier
+        /// </summary>
+        public uint DeviceId { get; }
+
+        /// <summary>
+        ///     Gets the external PCI device identifier
+        /// </summary>
+        public ushort ExternalDeviceId { get; }
+
+        /// <summary>
+        ///     Gets the internal PCI device-specific revision identifier
+        /// </summary>
+        public uint RevisionId { get; }
+
+        /// <summary>
+        ///     Gets the internal PCI subsystem identifier
+        /// </summary>
+        public uint SubSystemId { get; }
+
+        /// <summary>
+        ///     Gets the vendor identification calculated from internal device identification
+        /// </summary>
+        public ushort VendorId { get; }
+
+        /// <inheritdoc />
+        public bool Equals(PCIIdentifiers other)
+        {
+            return DeviceId == other.DeviceId &&
+                   SubSystemId == other.SubSystemId &&
+                   RevisionId == other.RevisionId;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PCIIdentifiers left, PCIIdentifiers right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PCIIdentifiers left, PCIIdentifiers right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is PCIIdentifiers identifiers && Equals(identifiers);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) DeviceId;
+                hashCode = (hashCode * 397) ^ (int) SubSystemId;
+                hashCode = (hashCode * 397) ^ (int) RevisionId;
+
+                return hashCode;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"PCI\\VEN_{VendorId:X}&DEV_{ExternalDeviceId:X}&SUBSYS_{SubSystemId:X}&REV_{RevisionId:X}";
+        }
+    }
+}

app/NvAPIWrapper/GPU/PCIeInformation.cs

@@ -0,0 +1,67 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the PCI-e connection
+    /// </summary>
+    public class PCIeInformation
+    {
+        internal PCIeInformation(PrivatePCIeInfoV2.PCIePerformanceStateInfo stateInfo)
+        {
+            TransferRateInMTps = stateInfo.TransferRateInMTps;
+            Generation = stateInfo.Generation;
+            Lanes = stateInfo.Lanes;
+            Version = stateInfo.Version;
+        }
+
+        /// <summary>
+        ///     Gets the PCI-e generation
+        /// </summary>
+        public PCIeGeneration Generation { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e down stream lanes
+        /// </summary>
+        public uint Lanes { get; }
+
+        /// <summary>
+        ///     Gets the PCIe transfer rate in Mega Transfers per Second
+        /// </summary>
+        public uint TransferRateInMTps { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e version
+        /// </summary>
+        public PCIeGeneration Version { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var v = "Unknown";
+
+            switch (Version)
+            {
+                case PCIeGeneration.PCIe1:
+                    v = "PCIe 1.0";
+
+                    break;
+                case PCIeGeneration.PCIe1Minor1:
+                    v = "PCIe 1.1";
+
+                    break;
+                case PCIeGeneration.PCIe2:
+                    v = "PCIe 2.0";
+
+                    break;
+                case PCIeGeneration.PCIe3:
+                    v = "PCIe 3.0";
+
+                    break;
+            }
+
+            return $"{v} x{Lanes} - {TransferRateInMTps} MTps";
+        }
+    }
+}

app/NvAPIWrapper/GPU/PhysicalGPU.cs

@@ -0,0 +1,559 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using NvAPIWrapper.Display;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a physical NVIDIA GPU
+    /// </summary>
+    public class PhysicalGPU : IEquatable<PhysicalGPU>
+    {
+        /// <summary>
+        ///     Creates a new PhysicalGPU
+        /// </summary>
+        /// <param name="handle">Physical GPU handle</param>
+        public PhysicalGPU(PhysicalGPUHandle handle)
+        {
+            Handle = handle;
+            UsageInformation = new GPUUsageInformation(this);
+            ThermalInformation = new GPUThermalInformation(this);
+            BusInformation = new GPUBusInformation(this);
+            ArchitectInformation = new GPUArchitectInformation(this);
+            MemoryInformation = new GPUMemoryInformation(this);
+            CoolerInformation = new GPUCoolerInformation(this);
+            ECCMemoryInformation = new ECCMemoryInformation(this);
+            PerformanceControl = new GPUPerformanceControl(this);
+            PowerTopologyInformation = new GPUPowerTopologyInformation(this);
+        }
+
+        /// <summary>
+        ///     Gets all active outputs of this GPU
+        /// </summary>
+        public GPUOutput[] ActiveOutputs
+        {
+            get
+            {
+                var outputs = new List<GPUOutput>();
+                var allOutputs = GPUApi.GetActiveOutputs(Handle);
+
+                foreach (OutputId outputId in Enum.GetValues(typeof(OutputId)))
+                {
+                    if (outputId != OutputId.Invalid && allOutputs.HasFlag(outputId))
+                    {
+                        outputs.Add(new GPUOutput(outputId, this));
+                    }
+                }
+
+                return outputs.ToArray();
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU architect information
+        /// </summary>
+        public GPUArchitectInformation ArchitectInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU base clock frequencies
+        /// </summary>
+        public IClockFrequencies BaseClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BaseClock));
+        }
+
+        /// <summary>
+        ///     Gets GPU video BIOS information
+        /// </summary>
+        public VideoBIOS Bios
+        {
+            get => new VideoBIOS(
+                GPUApi.GetVBIOSRevision(Handle),
+                (int) GPUApi.GetVBIOSOEMRevision(Handle),
+                GPUApi.GetVBIOSVersionString(Handle)
+            );
+        }
+
+        /// <summary>
+        ///     Gets the board information
+        /// </summary>
+        public BoardInfo Board
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetBoardInfo(Handle);
+                }
+                catch (NVIDIAApiException ex)
+                {
+                    if (ex.Status == Status.NotSupported)
+                    {
+                        return default;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU boost clock frequencies
+        /// </summary>
+        public IClockFrequencies BoostClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BoostClock));
+        }
+
+        /// <summary>
+        ///     Gets GPU bus information
+        /// </summary>
+        public GPUBusInformation BusInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU coolers information
+        /// </summary>
+        public GPUCoolerInformation CoolerInformation { get; }
+
+        /// <summary>
+        ///     Gets corresponding logical GPU
+        /// </summary>
+        public LogicalGPU CorrespondingLogicalGPU
+        {
+            get => new LogicalGPU(GPUApi.GetLogicalGPUFromPhysicalGPU(Handle));
+        }
+
+        /// <summary>
+        ///     Gets GPU current clock frequencies
+        /// </summary>
+        public IClockFrequencies CurrentClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.CurrentClock));
+        }
+
+        /// <summary>
+        ///     Gets the driver model number for this GPU
+        /// </summary>
+        public uint DriverModel
+        {
+            get => GPUApi.GetDriverModel(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU ECC memory information
+        /// </summary>
+        public ECCMemoryInformation ECCMemoryInformation { get; }
+
+        /// <summary>
+        ///     Gets the chipset foundry
+        /// </summary>
+        public GPUFoundry Foundry
+        {
+            get => GPUApi.GetFoundry(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU full name
+        /// </summary>
+        public string FullName
+        {
+            get => GPUApi.GetFullName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the GPU identification number
+        /// </summary>
+        public uint GPUId
+        {
+            get => GPUApi.GetGPUIDFromPhysicalGPU(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU type
+        /// </summary>
+        public GPUType GPUType
+        {
+            get => GPUApi.GetGPUType(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU handle
+        /// </summary>
+        public PhysicalGPUHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating the Quadro line of products
+        /// </summary>
+        public bool IsQuadro
+        {
+            get => GPUApi.GetQuadroStatus(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU memory and RAM information as well as frame-buffer information
+        /// </summary>
+        public GPUMemoryInformation MemoryInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU performance control status and configurations
+        /// </summary>
+        public GPUPerformanceControl PerformanceControl { get; }
+
+
+        /// <summary>
+        ///     Gets the GPU performance states information and configurations
+        /// </summary>
+        public GPUPerformanceStatesInformation PerformanceStatesInfo
+        {
+            get
+            {
+                var performanceStates20Info = GPUApi.GetPerformanceStates20(Handle);
+                var currentPerformanceState = GPUApi.GetCurrentPerformanceState(Handle);
+                PrivatePCIeInfoV2? pcieInformation = null;
+
+                if (BusInformation.BusType == GPUBusType.PCIExpress)
+                {
+                    try
+                    {
+                        pcieInformation = GPUApi.GetPCIEInfo(Handle);
+                    }
+                    catch
+                    {
+                        // ignore
+                    }
+                }
+
+                return new GPUPerformanceStatesInformation(performanceStates20Info, currentPerformanceState,
+                    pcieInformation);
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU coolers information
+        /// </summary>
+        public GPUPowerTopologyInformation PowerTopologyInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU system type
+        /// </summary>
+        public SystemType SystemType
+        {
+            get => GPUApi.GetSystemType(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU thermal sensors information
+        /// </summary>
+        public GPUThermalInformation ThermalInformation { get; }
+
+        /// <summary>
+        ///     Gets the GPU utilization domains and usages
+        /// </summary>
+        public GPUUsageInformation UsageInformation { get; }
+
+        /// <inheritdoc />
+        public bool Equals(PhysicalGPU other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding <see cref="PhysicalGPU" /> instance from a GPU identification number.
+        /// </summary>
+        /// <param name="gpuId">The GPU identification number.</param>
+        /// <returns>An instance of <see cref="PhysicalGPU" /> or <see langword="null" /> if operation failed.</returns>
+        public static PhysicalGPU FromGPUId(uint gpuId)
+        {
+            var handle = GPUApi.GetPhysicalGPUFromGPUID(gpuId);
+
+            if (handle.IsNull)
+            {
+                return null;
+            }
+
+            return new PhysicalGPU(handle);
+        }
+
+        /// <summary>
+        ///     Gets all physical GPUs
+        /// </summary>
+        /// <returns>An array of physical GPUs</returns>
+        public static PhysicalGPU[] GetPhysicalGPUs()
+        {
+            return GPUApi.EnumPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Gets all physical GPUs in TCC state
+        /// </summary>
+        /// <returns>An array of physical GPUs</returns>
+        public static PhysicalGPU[] GetTCCPhysicalGPUs()
+        {
+            return GPUApi.EnumTCCPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PhysicalGPU left, PhysicalGPU right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PhysicalGPU left, PhysicalGPU right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as PhysicalGPU);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return FullName;
+        }
+
+        /// <summary>
+        ///     Get a list of all active applications for this GPU
+        /// </summary>
+        /// <returns>An array of processes</returns>
+        public Process[] GetActiveApplications()
+        {
+            return GPUApi.QueryActiveApps(Handle).Select(app => Process.GetProcessById(app.ProcessId)).ToArray();
+        }
+
+        /// <summary>
+        ///     Get a list of all connected display devices on this GPU
+        /// </summary>
+        /// <param name="flags">ConnectedIdsFlag flag</param>
+        /// <returns>An array of display devices</returns>
+        public DisplayDevice[] GetConnectedDisplayDevices(ConnectedIdsFlag flags)
+        {
+            return GPUApi.GetConnectedDisplayIds(Handle, flags).Select(display => new DisplayDevice(display)).ToArray();
+        }
+
+        /// <summary>
+        ///     Get the display device connected to a specific GPU output
+        /// </summary>
+        /// <param name="output">The GPU output to get connected display device for</param>
+        /// <returns>DisplayDevice connected to the specified GPU output</returns>
+        public DisplayDevice GetDisplayDeviceByOutput(GPUOutput output)
+        {
+            return new DisplayDevice(GPUApi.GetDisplayIdFromGPUAndOutputId(Handle, output.OutputId));
+        }
+
+        /// <summary>
+        ///     Get a list of all display devices on any possible output
+        /// </summary>
+        /// <returns>An array of display devices</returns>
+        public DisplayDevice[] GetDisplayDevices()
+        {
+            return GPUApi.GetAllDisplayIds(Handle).Select(display => new DisplayDevice(display)).ToArray();
+        }
+
+        /// <summary>
+        ///     Reads EDID data of an output
+        /// </summary>
+        /// <param name="output">The GPU output to read EDID information for</param>
+        /// <returns>A byte array containing EDID data</returns>
+        public byte[] ReadEDIDData(GPUOutput output)
+        {
+            try
+            {
+                var data = new byte[0];
+                var identification = 0;
+                var totalSize = EDIDV3.MaxDataSize;
+
+                for (var offset = 0; offset < totalSize; offset += EDIDV3.MaxDataSize)
+                {
+                    var edid = GPUApi.GetEDID(Handle, output.OutputId, offset, identification);
+                    identification = edid.Identification;
+                    totalSize = edid.TotalSize;
+
+                    var edidData = edid.Data;
+                    Array.Resize(ref data, data.Length + edidData.Length);
+                    Array.Copy(edidData, 0, data, data.Length - edidData.Length, edidData.Length);
+                }
+
+                return data;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status == Status.IncompatibleStructureVersion)
+                {
+                    return GPUApi.GetEDID(Handle, output.OutputId).Data;
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        ///     Reads data from the I2C bus
+        /// </summary>
+        /// <param name="i2cInfo">Information required to read from the I2C bus.</param>
+        /// <returns>The returned payload.</returns>
+        // ReSharper disable once InconsistentNaming
+        public byte[] ReadI2C(II2CInfo i2cInfo)
+        {
+            GPUApi.I2CRead(Handle, ref i2cInfo);
+
+            return i2cInfo.Data;
+        }
+
+        /// <summary>
+        ///     Validates a set of GPU outputs to check if they can be active simultaneously
+        /// </summary>
+        /// <param name="outputs">GPU outputs to check</param>
+        /// <returns>true if all specified outputs can be active simultaneously, otherwise false</returns>
+        public bool ValidateOutputCombination(GPUOutput[] outputs)
+        {
+            var gpuOutpudIds =
+                outputs.Aggregate(OutputId.Invalid, (current, gpuOutput) => current | gpuOutput.OutputId);
+
+            return GPUApi.ValidateOutputCombination(Handle, gpuOutpudIds);
+        }
+
+        /// <summary>
+        ///     Writes EDID data of an output
+        /// </summary>
+        /// <param name="output">The GPU output to write EDID information for</param>
+        /// <param name="edidData">A byte array containing EDID data</param>
+        public void WriteEDIDData(GPUOutput output, byte[] edidData)
+        {
+            WriteEDIDData((uint) output.OutputId, edidData);
+        }
+
+        /// <summary>
+        ///     Writes EDID data of an display
+        /// </summary>
+        /// <param name="display">The display device to write EDID information for</param>
+        /// <param name="edidData">A byte array containing EDID data</param>
+        public void WriteEDIDData(DisplayDevice display, byte[] edidData)
+        {
+            WriteEDIDData(display.DisplayId, edidData);
+        }
+
+        /// <summary>
+        ///     Writes data to the I2C bus
+        /// </summary>
+        /// <param name="i2cInfo">Information required to write to the I2C bus including data payload.</param>
+        // ReSharper disable once InconsistentNaming
+        public void WriteI2C(II2CInfo i2cInfo)
+        {
+            GPUApi.I2CWrite(Handle, i2cInfo);
+        }
+
+        private void WriteEDIDData(uint displayOutputId, byte[] edidData)
+        {
+            try
+            {
+                if (edidData.Length == 0)
+                {
+                    var instance = typeof(EDIDV3).Instantiate<EDIDV3>();
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                for (var offset = 0; offset < edidData.Length; offset += EDIDV3.MaxDataSize)
+                {
+                    var array = new byte[Math.Min(EDIDV3.MaxDataSize, edidData.Length - offset)];
+                    Array.Copy(edidData, offset, array, 0, array.Length);
+                    var instance = EDIDV3.CreateWithData(0, (uint) offset, array, edidData.Length);
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                return;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            try
+            {
+                if (edidData.Length == 0)
+                {
+                    var instance = typeof(EDIDV2).Instantiate<EDIDV2>();
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                for (var offset = 0; offset < edidData.Length; offset += EDIDV2.MaxDataSize)
+                {
+                    var array = new byte[Math.Min(EDIDV2.MaxDataSize, edidData.Length - offset)];
+                    Array.Copy(edidData, offset, array, 0, array.Length);
+                    GPUApi.SetEDID(Handle, displayOutputId, EDIDV2.CreateWithData(array, edidData.Length));
+                }
+
+                return;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            GPUApi.SetEDID(Handle, displayOutputId, EDIDV1.CreateWithData(edidData));
+        }
+    }
+}

app/NvAPIWrapper/GPU/VideoBIOS.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU Video BIOS
+    /// </summary>
+    public class VideoBIOS
+    {
+        internal VideoBIOS(uint revision, int oemRevision, string versionString)
+        {
+            Revision = revision;
+            OEMRevision = oemRevision;
+            VersionString = versionString.ToUpper();
+        }
+
+        /// <summary>
+        ///     Gets the the OEM revision of the video BIOS
+        /// </summary>
+        public int OEMRevision { get; }
+
+        /// <summary>
+        ///     Gets the revision of the video BIOS
+        /// </summary>
+        public uint Revision { get; }
+
+        /// <summary>
+        ///     Gets the full video BIOS version string
+        /// </summary>
+        public string VersionString { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return AsVersion().ToString();
+        }
+
+        /// <summary>
+        ///     Returns the video BIOS version as a .Net Version object
+        /// </summary>
+        /// <returns>A Version object representing the video BIOS version</returns>
+        public Version AsVersion()
+        {
+            return new Version(
+                (int) ((Revision >> 28) + ((Revision << 4) >> 28) * 16), // 8 bit little endian
+                (int) (((Revision << 8) >> 28) + ((Revision << 12) >> 28) * 16), // 8 bit little endian
+                (int) ((Revision << 16) >> 16), // 16 bit big endian
+                OEMRevision // 8 bit integer
+            );
+        }
+    }
+}

app/NvAPIWrapper/NVIDIA.cs

@@ -0,0 +1,81 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Interfaces.General;
+
+namespace NvAPIWrapper
+{
+    /// <summary>
+    ///     .Net friendly version of system and general functions of NVAPI library
+    /// </summary>
+    public static class NVIDIA
+    {
+        /// <summary>
+        ///     Gets information about the system's chipset.
+        /// </summary>
+        public static IChipsetInfo ChipsetInfo
+        {
+            get => GeneralApi.GetChipsetInfo();
+        }
+
+        /// <summary>
+        ///     Gets NVIDIA driver branch version as string
+        /// </summary>
+        public static string DriverBranchVersion
+        {
+            get
+            {
+                GeneralApi.GetDriverAndBranchVersion(out var branchVersion);
+
+                return branchVersion;
+            }
+        }
+
+        /// <summary>
+        ///     Gets NVIDIA driver version
+        /// </summary>
+        public static uint DriverVersion
+        {
+            get => GeneralApi.GetDriverAndBranchVersion(out _);
+        }
+
+        /// <summary>
+        ///     Gets NVAPI interface version as string
+        /// </summary>
+        public static string InterfaceVersionString
+        {
+            get => GeneralApi.GetInterfaceVersionString();
+        }
+
+        /// <summary>
+        ///     Gets the current lid and dock information.
+        /// </summary>
+        public static LidDockParameters LidAndDockParameters
+        {
+            get => GeneralApi.GetLidAndDockInfo();
+        }
+
+        /// <summary>
+        ///     Initializes the NvAPI library (if not already initialized) but always increments the ref-counter.
+        /// </summary>
+        public static void Initialize()
+        {
+            GeneralApi.Initialize();
+        }
+
+        /// <summary>
+        ///     PRIVATE - Requests to restart the display driver
+        /// </summary>
+        public static void RestartDisplayDriver()
+        {
+            GeneralApi.RestartDisplayDriver();
+        }
+
+        /// <summary>
+        ///     Decrements the ref-counter and when it reaches ZERO, unloads NVAPI library.
+        /// </summary>
+        public static void Unload()
+        {
+            GeneralApi.Unload();
+        }
+    }
+}

app/NvAPIWrapper/Native/Attributes/AcceptsAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Delegate)]
+    internal class AcceptsAttribute : Attribute
+    {
+        public AcceptsAttribute(params Type[] types)
+        {
+            Types = types;
+        }
+
+        public Type[] Types { get; set; }
+    }
+}

app/NvAPIWrapper/Native/Attributes/FunctionIdAttribute.cs

@@ -0,0 +1,16 @@
+using System;
+using NvAPIWrapper.Native.Helpers;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Delegate)]
+    internal class FunctionIdAttribute : Attribute
+    {
+        public FunctionIdAttribute(FunctionId functionId)
+        {
+            FunctionId = functionId;
+        }
+
+        public FunctionId FunctionId { get; set; }
+    }
+}

app/NvAPIWrapper/Native/Attributes/StructureVersionAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Struct)]
+    internal class StructureVersionAttribute : Attribute
+    {
+        public StructureVersionAttribute()
+        {
+        }
+
+        public StructureVersionAttribute(int versionNumber)
+        {
+            VersionNumber = versionNumber;
+        }
+
+        public int VersionNumber { get; set; }
+    }
+}

app/NvAPIWrapper/Native/Constants/Display.cs

@@ -0,0 +1,8 @@
+namespace NvAPIWrapper.Native.Constants
+{
+    internal static class Display
+    {
+        public const int AdvancedDisplayHeads = 4;
+        public const int MaxDisplayHeads = 2;
+    }
+}

app/NvAPIWrapper/Native/Constants/General.cs

@@ -0,0 +1,8 @@
+namespace NvAPIWrapper.Native.Constants
+{
+    internal static class General
+    {
+        public const int BinaryDataMax = 4096;
+        public const int UnicodeStringLength = 2048;
+    }
+}

app/NvAPIWrapper/Native/DRS/DRSSettingLocation.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.DRS
+{
+    /// <summary>
+    ///     Holds possible values for the setting location
+    /// </summary>
+    public enum DRSSettingLocation : uint
+    {
+        /// <summary>
+        ///     Setting is part of the current profile
+        /// </summary>
+        CurrentProfile = 0,
+
+        /// <summary>
+        ///     Setting is part of the global profile
+        /// </summary>
+        GlobalProfile,
+
+        /// <summary>
+        ///     Setting is part of the base profile
+        /// </summary>
+        BaseProfile,
+
+        /// <summary>
+        ///     Setting is part of the default profile
+        /// </summary>
+        DefaultProfile
+    }
+}

app/NvAPIWrapper/Native/DRS/DRSSettingType.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.DRS
+{
+    /// <summary>
+    ///     Holds a list of possible setting value types
+    /// </summary>
+    public enum DRSSettingType : uint
+    {
+        /// <summary>
+        ///     Integer value type
+        /// </summary>
+        Integer = 0,
+
+        /// <summary>
+        ///     Binary value type
+        /// </summary>
+        Binary,
+
+        /// <summary>
+        ///     ASCII string value type
+        /// </summary>
+        String,
+
+        /// <summary>
+        ///     Unicode string value type
+        /// </summary>
+        UnicodeString
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV1.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+using NvAPIWrapper.Native.Interfaces.DRS;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <inheritdoc cref="IDRSApplication" />
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(1)]
+    public struct DRSApplicationV1 : IInitializable, IDRSApplication
+    {
+        internal StructureVersion _Version;
+        internal uint _IsPredefined;
+        internal UnicodeString _ApplicationName;
+        internal UnicodeString _FriendlyName;
+        internal UnicodeString _LauncherName;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSApplicationV1" />
+        /// </summary>
+        /// <param name="applicationName">The application file name.</param>
+        /// <param name="friendlyName">The application friendly name.</param>
+        /// <param name="launcherName">The application launcher name.</param>
+        public DRSApplicationV1(
+            string applicationName,
+            string friendlyName = null,
+            string launcherName = null
+        )
+        {
+            this = typeof(DRSApplicationV1).Instantiate<DRSApplicationV1>();
+            IsPredefined = false;
+            ApplicationName = applicationName;
+            FriendlyName = friendlyName ?? string.Empty;
+            LauncherName = launcherName ?? string.Empty;
+        }
+
+        /// <inheritdoc />
+        public bool IsPredefined
+        {
+            get => _IsPredefined > 0;
+            private set => _IsPredefined = value ? 1u : 0u;
+        }
+
+        /// <inheritdoc />
+        public string ApplicationName
+        {
+            get => _ApplicationName.Value;
+            private set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    throw new ArgumentException("Name can not be empty or null.");
+                }
+
+                _ApplicationName = new UnicodeString(value);
+            }
+        }
+
+        /// <inheritdoc />
+        public string FriendlyName
+        {
+            get => _FriendlyName.Value;
+            private set => _FriendlyName = new UnicodeString(value);
+        }
+
+        /// <inheritdoc />
+        public string LauncherName
+        {
+            get => _LauncherName.Value;
+            private set => _LauncherName = new UnicodeString(value);
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV2.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+using NvAPIWrapper.Native.Interfaces.DRS;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <inheritdoc cref="IDRSApplication" />
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(2)]
+    public struct DRSApplicationV2 : IInitializable, IDRSApplication
+    {
+        internal const char FileInFolderSeparator = ':';
+        internal StructureVersion _Version;
+        internal uint _IsPredefined;
+        internal UnicodeString _ApplicationName;
+        internal UnicodeString _FriendlyName;
+        internal UnicodeString _LauncherName;
+        internal UnicodeString _FileInFolder;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSApplicationV2" />
+        /// </summary>
+        /// <param name="applicationName">The application file name.</param>
+        /// <param name="friendlyName">The application friendly name.</param>
+        /// <param name="launcherName">The application launcher name.</param>
+        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
+        // ReSharper disable once TooManyDependencies
+        public DRSApplicationV2(
+            string applicationName,
+            string friendlyName = null,
+            string launcherName = null,
+            string[] fileInFolders = null
+        )
+        {
+            this = typeof(DRSApplicationV2).Instantiate<DRSApplicationV2>();
+            IsPredefined = false;
+            ApplicationName = applicationName;
+            FriendlyName = friendlyName ?? string.Empty;
+            LauncherName = launcherName ?? string.Empty;
+            FilesInFolder = fileInFolders ?? new string[0];
+        }
+
+        /// <inheritdoc />
+        public bool IsPredefined
+        {
+            get => _IsPredefined > 0;
+            private set => _IsPredefined = value ? 1u : 0u;
+        }
+
+        /// <inheritdoc />
+        public string ApplicationName
+        {
+            get => _ApplicationName.Value;
+            private set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    throw new ArgumentException("Name can not be empty or null.");
+                }
+
+                _ApplicationName = new UnicodeString(value);
+            }
+        }
+
+        /// <inheritdoc />
+        public string FriendlyName
+        {
+            get => _FriendlyName.Value;
+            private set => _FriendlyName = new UnicodeString(value);
+        }
+
+        /// <inheritdoc />
+        public string LauncherName
+        {
+            get => _LauncherName.Value;
+            private set => _LauncherName = new UnicodeString(value);
+        }
+
+        /// <summary>
+        ///     Gets the list of files that are necessary to be present in the application parent directory.
+        /// </summary>
+        public string[] FilesInFolder
+        {
+            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
+                   new string[0];
+            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV3.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+using NvAPIWrapper.Native.Interfaces.DRS;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <inheritdoc cref="IDRSApplication" />
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(3)]
+    public struct DRSApplicationV3 : IInitializable, IDRSApplication
+    {
+        internal const char FileInFolderSeparator = DRSApplicationV2.FileInFolderSeparator;
+        internal StructureVersion _Version;
+        internal uint _IsPredefined;
+        internal UnicodeString _ApplicationName;
+        internal UnicodeString _FriendlyName;
+        internal UnicodeString _LauncherName;
+        internal UnicodeString _FileInFolder;
+        internal uint _Flags;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSApplicationV3" />
+        /// </summary>
+        /// <param name="applicationName">The application file name.</param>
+        /// <param name="friendlyName">The application friendly name.</param>
+        /// <param name="launcherName">The application launcher name.</param>
+        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
+        /// <param name="isMetro">A boolean value indicating if this application is a metro application.</param>
+        // ReSharper disable once TooManyDependencies
+        public DRSApplicationV3(
+            string applicationName,
+            string friendlyName = null,
+            string launcherName = null,
+            string[] fileInFolders = null,
+            bool isMetro = false
+        )
+        {
+            this = typeof(DRSApplicationV3).Instantiate<DRSApplicationV3>();
+            IsPredefined = false;
+            ApplicationName = applicationName;
+            FriendlyName = friendlyName ?? string.Empty;
+            LauncherName = launcherName ?? string.Empty;
+            FilesInFolder = fileInFolders ?? new string[0];
+            IsMetroApplication = isMetro;
+        }
+
+        /// <inheritdoc />
+        public bool IsPredefined
+        {
+            get => _IsPredefined > 0;
+            private set => _IsPredefined = value ? 1u : 0u;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this application is a metro application
+        /// </summary>
+        public bool IsMetroApplication
+        {
+            get => _Flags.GetBit(0);
+            private set => _Flags = _Flags.SetBit(0, value);
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this application has command line arguments
+        /// </summary>
+        public bool HasCommandLine
+        {
+            get => _Flags.GetBit(1);
+        }
+
+        /// <inheritdoc />
+        public string ApplicationName
+        {
+            get => _ApplicationName.Value;
+            private set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    throw new ArgumentException("Name can not be empty or null.");
+                }
+
+                _ApplicationName = new UnicodeString(value);
+            }
+        }
+
+        /// <inheritdoc />
+        public string FriendlyName
+        {
+            get => _FriendlyName.Value;
+            private set => _FriendlyName = new UnicodeString(value);
+        }
+
+        /// <inheritdoc />
+        public string LauncherName
+        {
+            get => _LauncherName.Value;
+            private set => _LauncherName = new UnicodeString(value);
+        }
+
+        /// <summary>
+        ///     Gets the list of files that are necessary to be present in the application parent directory.
+        /// </summary>
+        public string[] FilesInFolder
+        {
+            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
+                   new string[0];
+            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV4.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+using NvAPIWrapper.Native.Interfaces.DRS;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <inheritdoc cref="IDRSApplication" />
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(4)]
+    public struct DRSApplicationV4 : IInitializable, IDRSApplication
+    {
+        internal const char FileInFolderSeparator = DRSApplicationV3.FileInFolderSeparator;
+        internal StructureVersion _Version;
+        internal uint _IsPredefined;
+        internal UnicodeString _ApplicationName;
+        internal UnicodeString _FriendlyName;
+        internal UnicodeString _LauncherName;
+        internal UnicodeString _FileInFolder;
+        internal uint _Flags;
+        internal UnicodeString _CommandLine;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSApplicationV4" />
+        /// </summary>
+        /// <param name="applicationName">The application file name.</param>
+        /// <param name="friendlyName">The application friendly name.</param>
+        /// <param name="launcherName">The application launcher name.</param>
+        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
+        /// <param name="isMetro">A boolean value indicating if this application is a metro application.</param>
+        /// <param name="commandLine">The application's command line arguments.</param>
+        // ReSharper disable once TooManyDependencies
+        public DRSApplicationV4(
+            string applicationName,
+            string friendlyName = null,
+            string launcherName = null,
+            string[] fileInFolders = null,
+            bool isMetro = false,
+            string commandLine = null
+        )
+        {
+            this = typeof(DRSApplicationV4).Instantiate<DRSApplicationV4>();
+            IsPredefined = false;
+            ApplicationName = applicationName;
+            FriendlyName = friendlyName ?? string.Empty;
+            LauncherName = launcherName ?? string.Empty;
+            FilesInFolder = fileInFolders ?? new string[0];
+            IsMetroApplication = isMetro;
+            ApplicationCommandLine = commandLine ?? string.Empty;
+        }
+
+        /// <inheritdoc />
+        public bool IsPredefined
+        {
+            get => _IsPredefined > 0;
+            private set => _IsPredefined = value ? 1u : 0u;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this application is a metro application
+        /// </summary>
+        public bool IsMetroApplication
+        {
+            get => _Flags.GetBit(0);
+            private set => _Flags = _Flags.SetBit(0, value);
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this application has command line arguments
+        /// </summary>
+        public bool HasCommandLine
+        {
+            get => _Flags.GetBit(1);
+            private set => _Flags = _Flags.SetBit(1, value);
+        }
+
+        /// <inheritdoc />
+        public string ApplicationName
+        {
+            get => _ApplicationName.Value;
+            private set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    throw new ArgumentException("Name can not be empty or null.");
+                }
+
+                _ApplicationName = new UnicodeString(value);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the application command line arguments
+        /// </summary>
+        public string ApplicationCommandLine
+        {
+            get => (HasCommandLine ? _CommandLine.Value : null) ?? string.Empty;
+            private set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    _CommandLine = new UnicodeString(null);
+
+                    if (HasCommandLine)
+                    {
+                        HasCommandLine = false;
+                    }
+                }
+                else
+                {
+                    _CommandLine = new UnicodeString(value);
+
+                    if (!HasCommandLine)
+                    {
+                        HasCommandLine = true;
+                    }
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public string FriendlyName
+        {
+            get => _FriendlyName.Value;
+            private set => _FriendlyName = new UnicodeString(value);
+        }
+
+        /// <inheritdoc />
+        public string LauncherName
+        {
+            get => _LauncherName.Value;
+            private set => _LauncherName = new UnicodeString(value);
+        }
+
+        /// <summary>
+        ///     Gets the list of files that are necessary to be present in the application parent directory.
+        /// </summary>
+        public string[] FilesInFolder
+        {
+            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
+                   new string[0];
+            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSGPUSupport.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Helpers;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     Contains a list of supported GPU series by a NVIDIA driver setting profile
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    public struct DRSGPUSupport
+    {
+        internal uint _Flags;
+
+        /// <summary>
+        ///     Gets or sets a value indicating if the GeForce line of products are supported
+        /// </summary>
+        public bool IsGeForceSupported
+        {
+            get => _Flags.GetBit(0);
+            set => _Flags = _Flags.SetBit(0, value);
+        }
+
+        /// <summary>
+        ///     Gets or sets a value indicating if the Quadro line of products are supported
+        /// </summary>
+        public bool IsQuadroSupported
+        {
+            get => _Flags.GetBit(1);
+            set => _Flags = _Flags.SetBit(1, value);
+        }
+
+        /// <summary>
+        ///     Gets or sets a value indicating if the NVS line of products are supported
+        /// </summary>
+        public bool IsNVSSupported
+        {
+            get => _Flags.GetBit(2);
+            set => _Flags = _Flags.SetBit(2, value);
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var supportedGPUs = new List<string>();
+
+            if (IsGeForceSupported)
+            {
+                supportedGPUs.Add("GeForce");
+            }
+
+            if (IsQuadroSupported)
+            {
+                supportedGPUs.Add("Quadro");
+            }
+
+            if (IsNVSSupported)
+            {
+                supportedGPUs.Add("NVS");
+            }
+
+            if (supportedGPUs.Any())
+            {
+                return $"[{_Flags}] = {string.Join(", ", supportedGPUs)}";
+            }
+
+            return $"[{_Flags}]";
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSProfileHandle.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     DRSProfileHandle is a reference to a DRS profile.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct DRSProfileHandle : IHandle, IEquatable<DRSProfileHandle>
+    {
+        internal readonly IntPtr _MemoryAddress;
+
+        private DRSProfileHandle(IntPtr memoryAddress)
+        {
+            _MemoryAddress = memoryAddress;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(DRSProfileHandle other)
+        {
+            return _MemoryAddress.Equals(other._MemoryAddress);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is DRSProfileHandle handle && Equals(handle);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return _MemoryAddress.GetHashCode();
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"DRSProfileHandle #{MemoryAddress.ToInt64()}";
+        }
+
+        /// <inheritdoc />
+        public IntPtr MemoryAddress
+        {
+            get => _MemoryAddress;
+        }
+
+        /// <inheritdoc />
+        public bool IsNull
+        {
+            get => _MemoryAddress == IntPtr.Zero;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(DRSProfileHandle left, DRSProfileHandle right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(DRSProfileHandle left, DRSProfileHandle right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Gets default DRSProfileHandle with a null pointer
+        /// </summary>
+        public static DRSProfileHandle DefaultHandle
+        {
+            get => default(DRSProfileHandle);
+        }
+
+        /// <summary>
+        ///     Gets the default global profile handle
+        /// </summary>
+        public static DRSProfileHandle DefaultGlobalProfileHandle
+        {
+            get => new DRSProfileHandle(new IntPtr(-1));
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSProfileV1.cs

@@ -0,0 +1,76 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     Represents a NVIDIA driver settings profile
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(1)]
+    public struct DRSProfileV1 : IInitializable
+    {
+        internal StructureVersion _Version;
+        internal UnicodeString _ProfileName;
+        internal DRSGPUSupport _GPUSupport;
+        internal uint _IsPredefined;
+        internal uint _NumberOfApplications;
+        internal uint _NumberOfSettings;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSProfileV1" /> with the passed name and GPU series support list.
+        /// </summary>
+        /// <param name="name">The name of the profile.</param>
+        /// <param name="gpuSupport">An instance of <see cref="DRSGPUSupport" /> containing the list of supported GPU series.</param>
+        public DRSProfileV1(string name, DRSGPUSupport gpuSupport)
+        {
+            this = typeof(DRSProfileV1).Instantiate<DRSProfileV1>();
+            _ProfileName = new UnicodeString(name);
+            _GPUSupport = gpuSupport;
+        }
+
+        /// <summary>
+        ///     Gets the name of the profile
+        /// </summary>
+        public string Name
+        {
+            get => _ProfileName.Value;
+        }
+
+        /// <summary>
+        ///     Gets or sets the GPU series support list
+        /// </summary>
+        public DRSGPUSupport GPUSupport
+        {
+            get => _GPUSupport;
+            set => _GPUSupport = value;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this profile is predefined
+        /// </summary>
+        public bool IsPredefined
+        {
+            get => _IsPredefined > 0;
+        }
+
+        /// <summary>
+        ///     Gets the number of applications registered under this profile
+        /// </summary>
+        public int NumberOfApplications
+        {
+            get => (int) _NumberOfApplications;
+        }
+
+        /// <summary>
+        ///     Gets the number of setting registered under this profile
+        /// </summary>
+        public int NumberOfSettings
+        {
+            get => (int) _NumberOfSettings;
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSSessionHandle.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     DRSSessionHandle is a reference to a DRS session.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct DRSSessionHandle : IHandle, IEquatable<DRSSessionHandle>
+    {
+        internal readonly IntPtr _MemoryAddress;
+
+        /// <inheritdoc />
+        public bool Equals(DRSSessionHandle other)
+        {
+            return _MemoryAddress.Equals(other._MemoryAddress);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is DRSSessionHandle handle && Equals(handle);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return _MemoryAddress.GetHashCode();
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"DRSSessionHandle #{MemoryAddress.ToInt64()}";
+        }
+
+        /// <inheritdoc />
+        public IntPtr MemoryAddress
+        {
+            get => _MemoryAddress;
+        }
+
+        /// <inheritdoc />
+        public bool IsNull
+        {
+            get => _MemoryAddress == IntPtr.Zero;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(DRSSessionHandle left, DRSSessionHandle right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(DRSSessionHandle left, DRSSessionHandle right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Gets default DRSSessionHandle with a null pointer
+        /// </summary>
+        public static DRSSessionHandle DefaultHandle
+        {
+            get => default(DRSSessionHandle);
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingV1.cs

@@ -0,0 +1,329 @@
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     Represents a NVIDIA driver setting
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(1)]
+    public struct DRSSettingV1 : IInitializable
+    {
+        internal StructureVersion _Version;
+        internal UnicodeString _SettingName;
+        internal uint _SettingId;
+        internal DRSSettingType _SettingType;
+        internal DRSSettingLocation _SettingLocation;
+        internal uint _IsCurrentPredefined;
+        internal uint _IsPredefinedValid;
+        internal DRSSettingValue _PredefinedValue;
+        internal DRSSettingValue _CurrentValue;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
+        /// </summary>
+        /// <param name="id">The setting identification number.</param>
+        /// <param name="settingType">The type of the setting's value</param>
+        /// <param name="value">The setting's value</param>
+        public DRSSettingV1(uint id, DRSSettingType settingType, object value)
+        {
+            this = typeof(DRSSettingV1).Instantiate<DRSSettingV1>();
+            Id = id;
+            IsPredefinedValueValid = false;
+            _SettingType = settingType;
+            CurrentValue = value;
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
+        /// </summary>
+        /// <param name="id">The setting identification number.</param>
+        /// <param name="value">The setting's value</param>
+        public DRSSettingV1(uint id, string value) : this(id, DRSSettingType.String, value)
+        {
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
+        /// </summary>
+        /// <param name="id">The setting identification number.</param>
+        /// <param name="value">The setting's value</param>
+        public DRSSettingV1(uint id, uint value) : this(id, DRSSettingType.Integer, value)
+        {
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
+        /// </summary>
+        /// <param name="id">The setting identification number.</param>
+        /// <param name="value">The setting's value</param>
+        public DRSSettingV1(uint id, byte[] value) : this(id, DRSSettingType.Binary, value)
+        {
+        }
+
+        /// <summary>
+        ///     Gets the name of the setting
+        /// </summary>
+        public string Name
+        {
+            get => _SettingName.Value;
+        }
+
+        /// <summary>
+        ///     Gets the identification number of the setting
+        /// </summary>
+        public uint Id
+        {
+            get => _SettingId;
+            private set => _SettingId = value;
+        }
+
+        /// <summary>
+        ///     Gets the setting's value type
+        /// </summary>
+        public DRSSettingType SettingType
+        {
+            get => _SettingType;
+            private set => _SettingType = value;
+        }
+
+        /// <summary>
+        ///     Gets the setting location
+        /// </summary>
+        public DRSSettingLocation SettingLocation
+        {
+            get => _SettingLocation;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the current value is the predefined value
+        /// </summary>
+        public bool IsCurrentValuePredefined
+        {
+            get => _IsCurrentPredefined > 0;
+            private set => _IsCurrentPredefined = value ? 1u : 0u;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the predefined value is available and valid
+        /// </summary>
+        public bool IsPredefinedValueValid
+        {
+            get => _IsPredefinedValid > 0;
+            private set => _IsPredefinedValid = value ? 1u : 0u;
+        }
+
+        /// <summary>
+        ///     Returns the predefined value as an integer
+        /// </summary>
+        /// <returns>An integer representing the predefined value</returns>
+        public uint GetPredefinedValueAsInteger()
+        {
+            return _PredefinedValue.AsInteger();
+        }
+
+        /// <summary>
+        ///     Returns the predefined value as an array of bytes
+        /// </summary>
+        /// <returns>An byte array representing the predefined value</returns>
+        public byte[] GetPredefinedValueAsBinary()
+        {
+            return _PredefinedValue.AsBinary();
+        }
+
+        /// <summary>
+        ///     Returns the predefined value as an unicode string
+        /// </summary>
+        /// <returns>An unicode string representing the predefined value</returns>
+        public string GetPredefinedValueAsUnicodeString()
+        {
+            return _PredefinedValue.AsUnicodeString();
+        }
+
+        /// <summary>
+        ///     Gets the setting's predefined value
+        /// </summary>
+        public object PredefinedValue
+        {
+            get
+            {
+                if (!IsPredefinedValueValid)
+                {
+                    return null;
+                }
+
+                switch (_SettingType)
+                {
+                    case DRSSettingType.Integer:
+
+                        return GetPredefinedValueAsInteger();
+                    case DRSSettingType.Binary:
+
+                        return GetPredefinedValueAsBinary();
+                    case DRSSettingType.String:
+                    case DRSSettingType.UnicodeString:
+
+                        return GetPredefinedValueAsUnicodeString();
+                    default:
+
+                        throw new ArgumentOutOfRangeException(nameof(SettingType));
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Returns the current value as an integer
+        /// </summary>
+        /// <returns>An integer representing the current value</returns>
+        public uint GetCurrentValueAsInteger()
+        {
+            return _CurrentValue.AsInteger();
+        }
+
+        /// <summary>
+        ///     Returns the current value as an array of bytes
+        /// </summary>
+        /// <returns>An byte array representing the current value</returns>
+        public byte[] GetCurrentValueAsBinary()
+        {
+            return _CurrentValue.AsBinary();
+        }
+
+        /// <summary>
+        ///     Returns the current value as an unicode string
+        /// </summary>
+        /// <returns>An unicode string representing the current value</returns>
+        public string GetCurrentValueAsUnicodeString()
+        {
+            return _CurrentValue.AsUnicodeString();
+        }
+
+        /// <summary>
+        ///     Sets the passed value as the current value
+        /// </summary>
+        /// <param name="value">The new value for the setting</param>
+        public void SetCurrentValueAsInteger(uint value)
+        {
+            if (SettingType != DRSSettingType.Integer)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
+            }
+
+            _CurrentValue = new DRSSettingValue(value);
+            IsCurrentValuePredefined = IsPredefinedValueValid && (uint) CurrentValue == (uint) PredefinedValue;
+        }
+
+        /// <summary>
+        ///     Sets the passed value as the current value
+        /// </summary>
+        /// <param name="value">The new value for the setting</param>
+        public void SetCurrentValueAsBinary(byte[] value)
+        {
+            if (SettingType != DRSSettingType.Binary)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
+            }
+
+            _CurrentValue = new DRSSettingValue(value);
+            IsCurrentValuePredefined =
+                IsPredefinedValueValid &&
+                ((byte[]) CurrentValue)?.SequenceEqual((byte[]) PredefinedValue ?? new byte[0]) == true;
+        }
+
+        /// <summary>
+        ///     Sets the passed value as the current value
+        /// </summary>
+        /// <param name="value">The new value for the setting</param>
+        public void SetCurrentValueAsUnicodeString(string value)
+        {
+            if (SettingType != DRSSettingType.UnicodeString)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
+            }
+
+            _CurrentValue = new DRSSettingValue(value);
+            IsCurrentValuePredefined =
+                IsPredefinedValueValid &&
+                string.Equals(
+                    (string) CurrentValue,
+                    (string) PredefinedValue,
+                    StringComparison.InvariantCulture
+                );
+        }
+
+        /// <summary>
+        ///     Gets or sets the setting's current value
+        /// </summary>
+        public object CurrentValue
+        {
+            get
+            {
+                switch (_SettingType)
+                {
+                    case DRSSettingType.Integer:
+
+                        return GetCurrentValueAsInteger();
+                    case DRSSettingType.Binary:
+
+                        return GetCurrentValueAsBinary();
+                    case DRSSettingType.String:
+                    case DRSSettingType.UnicodeString:
+
+                        return GetCurrentValueAsUnicodeString();
+                    default:
+
+                        throw new ArgumentOutOfRangeException(nameof(SettingType));
+                }
+            }
+            private set
+            {
+                if (value is int intValue)
+                {
+                    SetCurrentValueAsInteger((uint) intValue);
+                }
+                else if (value is uint unsignedIntValue)
+                {
+                    SetCurrentValueAsInteger(unsignedIntValue);
+                }
+                else if (value is short shortValue)
+                {
+                    SetCurrentValueAsInteger((uint) shortValue);
+                }
+                else if (value is ushort unsignedShortValue)
+                {
+                    SetCurrentValueAsInteger(unsignedShortValue);
+                }
+                else if (value is long longValue)
+                {
+                    SetCurrentValueAsInteger((uint) longValue);
+                }
+                else if (value is ulong unsignedLongValue)
+                {
+                    SetCurrentValueAsInteger((uint) unsignedLongValue);
+                }
+                else if (value is byte byteValue)
+                {
+                    SetCurrentValueAsInteger(byteValue);
+                }
+                else if (value is string stringValue)
+                {
+                    SetCurrentValueAsUnicodeString(stringValue);
+                }
+                else if (value is byte[] binaryValue)
+                {
+                    SetCurrentValueAsBinary(binaryValue);
+                }
+                else
+                {
+                    throw new ArgumentException("Unacceptable argument type.", nameof(value));
+                }
+            }
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingValue.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     Represents a setting value
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    public struct DRSSettingValue : IInitializable
+    {
+        private const int UnicodeStringLength = UnicodeString.UnicodeStringLength;
+        private const int BinaryDataMax = 4096;
+
+        // Math.Max(BinaryDataMax + sizeof(uint), UnicodeStringLength * sizeof(ushort))
+        private const int FullStructureSize = 4100;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = FullStructureSize, ArraySubType = UnmanagedType.U1)]
+        internal byte[] _BinaryValue;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed unicode string as the value
+        /// </summary>
+        /// <param name="value">The unicode string value</param>
+        public DRSSettingValue(string value)
+        {
+            if (value?.Length > UnicodeStringLength)
+            {
+                value = value.Substring(0, UnicodeStringLength);
+            }
+
+            _BinaryValue = new byte[FullStructureSize];
+
+            var stringBytes = Encoding.Unicode.GetBytes(value ?? string.Empty);
+            Array.Copy(stringBytes, 0, _BinaryValue, 0, Math.Min(stringBytes.Length, _BinaryValue.Length));
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed byte array as the value
+        /// </summary>
+        /// <param name="value">The byte array value</param>
+        public DRSSettingValue(byte[] value)
+        {
+            _BinaryValue = new byte[FullStructureSize];
+
+            if (value?.Length > 0)
+            {
+                var arrayLength = Math.Min(value.Length, BinaryDataMax);
+                var arrayLengthBytes = BitConverter.GetBytes((uint) arrayLength);
+                Array.Copy(arrayLengthBytes, 0, _BinaryValue, 0, arrayLengthBytes.Length);
+                Array.Copy(value, 0, _BinaryValue, arrayLengthBytes.Length, arrayLength);
+            }
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed integer as the value
+        /// </summary>
+        /// <param name="value">The integer value</param>
+        public DRSSettingValue(uint value)
+        {
+            _BinaryValue = new byte[FullStructureSize];
+            var arrayLengthBytes = BitConverter.GetBytes(value);
+            Array.Copy(arrayLengthBytes, 0, _BinaryValue, 0, arrayLengthBytes.Length);
+        }
+
+        /// <summary>
+        ///     Returns the value as an integer
+        /// </summary>
+        /// <returns>An integer representing the value</returns>
+        public uint AsInteger()
+        {
+            return BitConverter.ToUInt32(_BinaryValue, 0);
+        }
+
+        /// <summary>
+        ///     Returns the value as an array of bytes
+        /// </summary>
+        /// <returns>An array of bytes representing the value</returns>
+        public byte[] AsBinary()
+        {
+            return _BinaryValue.Skip(sizeof(uint)).Take((int) AsInteger()).ToArray();
+        }
+
+        /// <summary>
+        ///     Returns the value as an unicode string
+        /// </summary>
+        /// <returns>An unicode string representing the value</returns>
+        public string AsUnicodeString()
+        {
+            return Encoding.Unicode.GetString(_BinaryValue).TrimEnd('\0');
+        }
+    }
+}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingValues.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Interfaces;
+
+namespace NvAPIWrapper.Native.DRS.Structures
+{
+    /// <summary>
+    ///     Contains a list of all possible values for a setting as well as its default value
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 8)]
+    [StructureVersion(1)]
+    public struct DRSSettingValues : IInitializable
+    {
+        internal const int MaximumNumberOfValues = 100;
+        internal StructureVersion _Version;
+        internal uint _NumberOfValues;
+        internal DRSSettingType _SettingType;
+        internal DRSSettingValue _DefaultValue;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = MaximumNumberOfValues)]
+        internal DRSSettingValue[] _Values;
+
+        /// <summary>
+        ///     Gets the setting's value type
+        /// </summary>
+        public DRSSettingType SettingType
+        {
+            get => _SettingType;
+        }
+
+        /// <summary>
+        ///     Gets a list of possible values for the setting
+        /// </summary>
+        public object[] Values
+        {
+            get
+            {
+                switch (_SettingType)
+                {
+                    case DRSSettingType.Integer:
+
+                        return ValuesAsInteger().Cast<object>().ToArray();
+                    case DRSSettingType.Binary:
+
+                        return ValuesAsBinary().Cast<object>().ToArray();
+                    case DRSSettingType.String:
+                    case DRSSettingType.UnicodeString:
+
+                        return ValuesAsUnicodeString().Cast<object>().ToArray();
+                    default:
+
+                        throw new ArgumentOutOfRangeException(nameof(SettingType));
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the default value of the setting
+        /// </summary>
+        public object DefaultValue
+        {
+            get
+            {
+                switch (_SettingType)
+                {
+                    case DRSSettingType.Integer:
+
+                        return DefaultValueAsInteger();
+                    case DRSSettingType.Binary:
+
+                        return DefaultValueAsBinary();
+                    case DRSSettingType.String:
+                    case DRSSettingType.UnicodeString:
+
+                        return DefaultValueAsUnicodeString();
+                    default:
+
+                        throw new ArgumentOutOfRangeException(nameof(SettingType));
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Returns the default value as an integer
+        /// </summary>
+        /// <returns>An integer representing the default value</returns>
+        public uint DefaultValueAsInteger()
+        {
+            return _DefaultValue.AsInteger();
+        }
+
+        /// <summary>
+        ///     Returns the default value as a byte array
+        /// </summary>
+        /// <returns>An array of bytes representing the default value</returns>
+        public byte[] DefaultValueAsBinary()
+        {
+            return _DefaultValue.AsBinary();
+        }
+
+        /// <summary>
+        ///     Returns the default value as an unicode string
+        /// </summary>
+        /// <returns>A string representing the default value</returns>
+        public string DefaultValueAsUnicodeString()
+        {
+            return _DefaultValue.AsUnicodeString();
+        }
+
+        /// <summary>
+        ///     Returns the setting's possible values as an array of integers
+        /// </summary>
+        /// <returns>An array of integers representing the possible values</returns>
+        public uint[] ValuesAsInteger()
+        {
+            return _Values.Take((int) _NumberOfValues).Select(value => value.AsInteger()).ToArray();
+        }
+
+        /// <summary>
+        ///     Returns the setting's possible values as an array of byte arrays
+        /// </summary>
+        /// <returns>An array of byte arrays representing the possible values</returns>
+        public byte[][] ValuesAsBinary()
+        {
+            return _Values.Take((int) _NumberOfValues).Select(value => value.AsBinary()).ToArray();
+        }
+
+        /// <summary>
+        ///     Returns the setting's possible values as an array of unicode strings
+        /// </summary>
+        /// <returns>An array of unicode strings representing the possible values</returns>
+        public string[] ValuesAsUnicodeString()
+        {
+            return _Values.Take((int) _NumberOfValues).Select(value => value.AsUnicodeString()).ToArray();
+        }
+    }
+}

app/NvAPIWrapper/Native/DRSApi.cs

@@ -0,0 +1,936 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using NvAPIWrapper.Native.DRS.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+using NvAPIWrapper.Native.Interfaces.DRS;
+
+namespace NvAPIWrapper.Native
+{
+    /// <summary>
+    ///     Contains driver settings static functions
+    /// </summary>
+    // ReSharper disable once ClassTooBig
+    public static class DRSApi
+    {
+        /// <summary>
+        ///     This API adds an executable name to a profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="application">Input <see cref="IDRSApplication" /> instance containing the executable name.</param>
+        /// <returns>The newly created instance of <see cref="IDRSApplication" />.</returns>
+        public static IDRSApplication CreateApplication(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            IDRSApplication application)
+        {
+            using (var applicationReference = ValueTypeReference.FromValueType(application, application.GetType()))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateApplication>()(
+                    sessionHandle,
+                    profileHandle,
+                    applicationReference
+                );
+
+                if (status == Status.IncompatibleStructureVersion)
+                {
+                    throw new NVIDIANotSupportedException("This operation is not supported.");
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return applicationReference.ToValueType<IDRSApplication>(application.GetType());
+            }
+        }
+
+        /// <summary>
+        ///     This API creates an empty profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profile">Input to the <see cref="DRSProfileV1" /> instance.</param>
+        /// <returns>The newly created profile handle.</returns>
+        public static DRSProfileHandle CreateProfile(DRSSessionHandle sessionHandle, DRSProfileV1 profile)
+        {
+            using (var profileReference = ValueTypeReference.FromValueType(profile))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateProfile>()(
+                    sessionHandle,
+                    profileReference,
+                    out var profileHandle
+                );
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return profileHandle;
+            }
+        }
+
+        /// <summary>
+        ///     This API allocates memory and initializes the session.
+        /// </summary>
+        /// <returns>The newly created session handle.</returns>
+        public static DRSSessionHandle CreateSession()
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateSession>()(out var sessionHandle);
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return sessionHandle;
+        }
+
+        /// <summary>
+        ///     This API removes an executable from a profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="application">Input all the information about the application to be removed.</param>
+        public static void DeleteApplication(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            IDRSApplication application)
+        {
+            using (var applicationReference = ValueTypeReference.FromValueType(application, application.GetType()))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteApplicationEx>()(
+                    sessionHandle,
+                    profileHandle,
+                    applicationReference
+                );
+
+                if (status == Status.IncompatibleStructureVersion)
+                {
+                    throw new NVIDIANotSupportedException("This operation is not supported.");
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     This API removes an executable name from a profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="applicationName">Input the executable name to be removed.</param>
+        public static void DeleteApplication(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            string applicationName)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteApplication>()(
+                sessionHandle,
+                profileHandle,
+                new UnicodeString(applicationName)
+            );
+
+            if (status == Status.IncompatibleStructureVersion)
+            {
+                throw new NVIDIANotSupportedException("This operation is not supported.");
+            }
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API deletes a profile or sets it back to a predefined value.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        public static void DeleteProfile(DRSSessionHandle sessionHandle, DRSProfileHandle profileHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteProfile>()(
+                sessionHandle,
+                profileHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API deletes a setting or sets it back to predefined value.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="settingId">Input settingId to be deleted.</param>
+        public static void DeleteProfileSetting(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            uint settingId)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteProfileSetting>()(
+                sessionHandle,
+                profileHandle,
+                settingId
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API frees the allocated resources for the session handle.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        public static void DestroySession(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DestroySession>()(sessionHandle);
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API enumerates all the applications in a given profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <returns>Instances of <see cref="IDRSApplication" /> with all the attributes filled.</returns>
+        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
+        public static IEnumerable<IDRSApplication> EnumApplications(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle)
+        {
+            var maxApplicationsPerRequest = 8;
+            var enumApplications = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumApplications>();
+
+            foreach (var acceptType in enumApplications.Accepts())
+            {
+                var i = 0u;
+
+                while (true)
+                {
+                    var instances = acceptType.Instantiate<IDRSApplication>().Repeat(maxApplicationsPerRequest);
+
+                    using (var applicationsReference = ValueTypeArray.FromArray(instances, acceptType))
+                    {
+                        var count = (uint) instances.Length;
+                        var status = enumApplications(
+                            sessionHandle,
+                            profileHandle,
+                            i,
+                            ref count,
+                            applicationsReference
+                        );
+
+                        if (status == Status.IncompatibleStructureVersion)
+                        {
+                            break;
+                        }
+
+                        if (status == Status.EndEnumeration)
+                        {
+                            yield break;
+                        }
+
+                        if (status != Status.Ok)
+                        {
+                            throw new NVIDIAApiException(status);
+                        }
+
+                        foreach (var application in applicationsReference.ToArray<IDRSApplication>(
+                            (int) count,
+                            acceptType))
+                        {
+                            yield return application;
+                            i++;
+                        }
+
+                        if (count < maxApplicationsPerRequest)
+                        {
+                            yield break;
+                        }
+                    }
+                }
+            }
+
+            throw new NVIDIANotSupportedException("This operation is not supported.");
+        }
+
+        /// <summary>
+        ///     This API enumerates all the Ids of all the settings recognized by NVAPI.
+        /// </summary>
+        /// <returns>An array of <see cref="uint" />s filled with the settings identification numbers of available settings.</returns>
+        public static uint[] EnumAvailableSettingIds()
+        {
+            var settingIdsCount = (uint) ushort.MaxValue;
+            var settingIds = 0u.Repeat((int) settingIdsCount);
+
+            using (var settingIdsArray = ValueTypeArray.FromArray(settingIds))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumAvailableSettingIds>()(
+                    settingIdsArray,
+                    ref settingIdsCount
+                );
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return settingIdsArray.ToArray<uint>((int) settingIdsCount);
+            }
+        }
+
+        /// <summary>
+        ///     This API enumerates all available setting values for a given setting.
+        /// </summary>
+        /// <param name="settingId">Input settingId.</param>
+        /// <returns>All available setting values.</returns>
+        public static DRSSettingValues EnumAvailableSettingValues(uint settingId)
+        {
+            var settingValuesCount = (uint) DRSSettingValues.MaximumNumberOfValues;
+            var settingValues = typeof(DRSSettingValues).Instantiate<DRSSettingValues>();
+
+            using (var settingValuesReference = ValueTypeReference.FromValueType(settingValues))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumAvailableSettingValues>()(
+                    settingId,
+                    ref settingValuesCount,
+                    settingValuesReference
+                );
+
+                if (status == Status.IncompatibleStructureVersion)
+                {
+                    throw new NVIDIANotSupportedException("This operation is not supported.");
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return settingValuesReference.ToValueType<DRSSettingValues>(typeof(DRSSettingValues));
+            }
+        }
+
+        /// <summary>
+        ///     This API enumerates through all the profiles in the session.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <returns>Instances of <see cref="DRSProfileHandle" /> each representing a profile.</returns>
+        public static IEnumerable<DRSProfileHandle> EnumProfiles(DRSSessionHandle sessionHandle)
+        {
+            var i = 0u;
+
+            while (true)
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumProfiles>()(
+                    sessionHandle,
+                    i,
+                    out var profileHandle
+                );
+
+                if (status == Status.EndEnumeration)
+                {
+                    yield break;
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                yield return profileHandle;
+                i++;
+            }
+        }
+
+        /// <summary>
+        ///     This API enumerates all the settings of a given profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <returns>Instances of <see cref="DRSSettingV1" />.</returns>
+        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
+        public static IEnumerable<DRSSettingV1> EnumSettings(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle)
+        {
+            var maxSettingsPerRequest = 32;
+            var enumSettings = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumSettings>();
+
+            var i = 0u;
+
+            while (true)
+            {
+                var instances = typeof(DRSSettingV1).Instantiate<DRSSettingV1>().Repeat(maxSettingsPerRequest);
+
+                using (var applicationsReference = ValueTypeArray.FromArray(instances))
+                {
+                    var count = (uint) instances.Length;
+                    var status = enumSettings(
+                        sessionHandle,
+                        profileHandle,
+                        i,
+                        ref count,
+                        applicationsReference
+                    );
+
+                    if (status == Status.IncompatibleStructureVersion)
+                    {
+                        throw new NVIDIANotSupportedException("This operation is not supported.");
+                    }
+
+                    if (status == Status.EndEnumeration)
+                    {
+                        yield break;
+                    }
+
+                    if (status != Status.Ok)
+                    {
+                        throw new NVIDIAApiException(status);
+                    }
+
+                    foreach (var application in applicationsReference.ToArray<DRSSettingV1>(
+                        (int) count,
+                        typeof(DRSSettingV1))
+                    )
+                    {
+                        yield return application;
+                        i++;
+                    }
+
+                    if (count < maxSettingsPerRequest)
+                    {
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     This API searches the application and the associated profile for the given application name.
+        ///     If a fully qualified path is provided, this function will always return the profile
+        ///     the driver will apply upon running the application (on the path provided).
+        /// </summary>
+        /// <param name="sessionHandle">Input to the hSession handle</param>
+        /// <param name="applicationName">Input appName. For best results, provide a fully qualified path of the type</param>
+        /// <param name="profileHandle">The profile handle of the profile that the found application belongs to.</param>
+        /// <returns>An instance of <see cref="IDRSApplication" />.</returns>
+        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
+        public static IDRSApplication FindApplicationByName(
+            DRSSessionHandle sessionHandle,
+            string applicationName,
+            out DRSProfileHandle? profileHandle)
+        {
+            var findApplicationByName = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_FindApplicationByName>();
+
+            foreach (var acceptType in findApplicationByName.Accepts())
+            {
+                var instance = acceptType.Instantiate<IDRSApplication>();
+
+                using (var applicationReference = ValueTypeReference.FromValueType(instance, acceptType))
+                {
+                    var status = findApplicationByName(
+                        sessionHandle,
+                        new UnicodeString(applicationName),
+                        out var applicationProfileHandle,
+                        applicationReference
+                    );
+
+                    if (status == Status.IncompatibleStructureVersion)
+                    {
+                        continue;
+                    }
+
+                    if (status == Status.ExecutableNotFound)
+                    {
+                        profileHandle = null;
+
+                        return null;
+                    }
+
+                    if (status != Status.Ok)
+                    {
+                        throw new NVIDIAApiException(status);
+                    }
+
+                    profileHandle = applicationProfileHandle;
+
+                    return applicationReference.ToValueType<IDRSApplication>(acceptType);
+                }
+            }
+
+            throw new NVIDIANotSupportedException("This operation is not supported.");
+        }
+
+        /// <summary>
+        ///     This API finds a profile in the current session.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileName">Input profileName.</param>
+        /// <returns>The profile handle.</returns>
+        public static DRSProfileHandle FindProfileByName(DRSSessionHandle sessionHandle, string profileName)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_FindProfileByName>()(
+                sessionHandle,
+                new UnicodeString(profileName),
+                out var profileHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return profileHandle;
+        }
+
+        /// <summary>
+        ///     This API gets information about the given application.  The input application name
+        ///     must match exactly what the Profile has stored for the application.
+        ///     This function is better used to retrieve application information from a previous
+        ///     enumeration.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="applicationName">Input application name.</param>
+        /// <returns>
+        ///     An instance of <see cref="IDRSApplication" /> with all attributes filled if found; otherwise
+        ///     <see langword="null" />.
+        /// </returns>
+        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
+        public static IDRSApplication GetApplicationInfo(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            string applicationName)
+        {
+            var getApplicationInfo = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetApplicationInfo>();
+
+            foreach (var acceptType in getApplicationInfo.Accepts())
+            {
+                var instance = acceptType.Instantiate<IDRSApplication>();
+
+                using (var applicationReference = ValueTypeReference.FromValueType(instance, acceptType))
+                {
+                    var status = getApplicationInfo(
+                        sessionHandle,
+                        profileHandle,
+                        new UnicodeString(applicationName),
+                        applicationReference
+                    );
+
+                    if (status == Status.IncompatibleStructureVersion)
+                    {
+                        continue;
+                    }
+
+                    if (status == Status.ExecutableNotFound)
+                    {
+                        return null;
+                    }
+
+                    if (status != Status.Ok)
+                    {
+                        throw new NVIDIAApiException(status);
+                    }
+
+                    return applicationReference.ToValueType<IDRSApplication>(acceptType);
+                }
+            }
+
+            throw new NVIDIANotSupportedException("This operation is not supported.");
+        }
+
+        /// <summary>
+        ///     Returns the handle to the current global profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <returns>Base profile handle.</returns>
+        public static DRSProfileHandle GetBaseProfile(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetBaseProfile>()(
+                sessionHandle,
+                out var profileHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return profileHandle;
+        }
+
+        /// <summary>
+        ///     This API returns the handle to the current global profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <returns>Current global profile handle.</returns>
+        public static DRSProfileHandle GetCurrentGlobalProfile(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetCurrentGlobalProfile>()(
+                sessionHandle,
+                out var profileHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return profileHandle;
+        }
+
+        /// <summary>
+        ///     This API obtains the number of profiles in the current session object.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <returns>Number of profiles in the current session.</returns>
+        public static int GetNumberOfProfiles(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetNumProfiles>()(
+                sessionHandle,
+                out var profileCount
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return (int) profileCount;
+        }
+
+        /// <summary>
+        ///     This API gets information about the given profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <returns>An instance of <see cref="DRSProfileV1" /> with all attributes filled.</returns>
+        public static DRSProfileV1 GetProfileInfo(DRSSessionHandle sessionHandle, DRSProfileHandle profileHandle)
+        {
+            var profile = typeof(DRSProfileV1).Instantiate<DRSProfileV1>();
+
+            using (var profileReference = ValueTypeReference.FromValueType(profile))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetProfileInfo>()(
+                    sessionHandle,
+                    profileHandle,
+                    profileReference
+                );
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return profileReference.ToValueType<DRSProfileV1>().GetValueOrDefault();
+            }
+        }
+
+        /// <summary>
+        ///     This API gets information about the given setting.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="settingId">Input settingId.</param>
+        /// <returns>An instance of <see cref="DRSSettingV1" /> describing the setting if found; otherwise <see langword="null" />.</returns>
+        public static DRSSettingV1? GetSetting(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            uint settingId)
+        {
+            var instance = typeof(DRSSettingV1).Instantiate<DRSSettingV1>();
+
+            using (var settingReference = ValueTypeReference.FromValueType(instance, typeof(DRSSettingV1)))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSetting>()(
+                    sessionHandle,
+                    profileHandle,
+                    settingId,
+                    settingReference
+                );
+
+                if (status == Status.IncompatibleStructureVersion)
+                {
+                    throw new NVIDIANotSupportedException("This operation is not supported.");
+                }
+
+                if (status == Status.SettingNotFound)
+                {
+                    return null;
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+
+                return settingReference.ToValueType<DRSSettingV1>(typeof(DRSSettingV1));
+            }
+        }
+
+        /// <summary>
+        ///     This API gets the binary identification number of a setting given the setting name.
+        /// </summary>
+        /// <param name="settingName">Input Unicode settingName.</param>
+        /// <returns>The corresponding settingId.</returns>
+        public static uint GetSettingIdFromName(string settingName)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSettingIdFromName>()(
+                new UnicodeString(settingName),
+                out var settingId
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return settingId;
+        }
+
+        /// <summary>
+        ///     This API gets the setting name given the binary identification number.
+        /// </summary>
+        /// <param name="settingId">Input settingId.</param>
+        /// <returns>Corresponding settingName.</returns>
+        public static string GetSettingNameFromId(uint settingId)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSettingNameFromId>()(
+                settingId,
+                out var settingName
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+
+            return settingName.Value;
+        }
+
+        /// <summary>
+        ///     This API loads and parses the settings data.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        public static void LoadSettings(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_LoadSettings>()(sessionHandle);
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API loads settings from the given file path.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle</param>
+        /// <param name="fileName">Binary full file path.</param>
+        public static void LoadSettings(DRSSessionHandle sessionHandle, string fileName)
+        {
+            var unicodeFileName = new UnicodeString(fileName);
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_LoadSettingsFromFile>()(
+                sessionHandle,
+                unicodeFileName
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API restores the whole system to predefined(default) values.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        public static void RestoreDefaults(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreAllDefaults>()(
+                sessionHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API restores the given profile to predefined(default) values.
+        ///     Any and all user specified modifications will be removed.
+        ///     If the whole profile was set by the user, the profile will be removed.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        public static void RestoreDefaults(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreProfileDefault>()(
+                sessionHandle,
+                profileHandle
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API restores the given profile setting to predefined(default) values.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="settingId">Input settingId.</param>
+        public static void RestoreDefaults(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            uint settingId)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreProfileDefaultSetting>()(
+                sessionHandle,
+                profileHandle,
+                settingId
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API saves the settings data to the system.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        public static void SaveSettings(DRSSessionHandle sessionHandle)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SaveSettings>()(sessionHandle);
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API saves settings to the given file path.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="fileName">Binary full file path.</param>
+        public static void SaveSettings(DRSSessionHandle sessionHandle, string fileName)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SaveSettingsToFile>()(
+                sessionHandle,
+                new UnicodeString(fileName)
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     This API sets the current global profile in the driver.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileName">Input the new current global profile name.</param>
+        public static void SetCurrentGlobalProfile(DRSSessionHandle sessionHandle, string profileName)
+        {
+            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetCurrentGlobalProfile>()(
+                sessionHandle,
+                new UnicodeString(profileName)
+            );
+
+            if (status != Status.Ok)
+            {
+                throw new NVIDIAApiException(status);
+            }
+        }
+
+        /// <summary>
+        ///     Specifies flags for a given profile. Currently only the GPUSupport is
+        ///     used to update the profile. Neither the name, number of settings or applications
+        ///     or other profile information can be changed with this function.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="profile">Input the new profile info.</param>
+        public static void SetProfileInfo(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            DRSProfileV1 profile)
+        {
+            using (var profileReference = ValueTypeReference.FromValueType(profile))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetProfileInfo>()(
+                    sessionHandle,
+                    profileHandle,
+                    profileReference
+                );
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     This API adds/modifies a setting to a profile.
+        /// </summary>
+        /// <param name="sessionHandle">Input to the session handle.</param>
+        /// <param name="profileHandle">Input profile handle.</param>
+        /// <param name="setting">
+        ///     An instance of <see cref="DRSSettingV1" /> containing the setting identification number and new
+        ///     value for the setting.
+        /// </param>
+        public static void SetSetting(
+            DRSSessionHandle sessionHandle,
+            DRSProfileHandle profileHandle,
+            DRSSettingV1 setting)
+        {
+            using (var settingReference = ValueTypeReference.FromValueType(setting, setting.GetType()))
+            {
+                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetSetting>()(
+                    sessionHandle,
+                    profileHandle,
+                    settingReference
+                );
+
+                if (status == Status.IncompatibleStructureVersion)
+                {
+                    throw new NVIDIANotSupportedException("This operation is not supported.");
+                }
+
+                if (status != Status.Ok)
+                {
+                    throw new NVIDIAApiException(status);
+                }
+            }
+        }
+    }
+}

app/NvAPIWrapper/Native/Delegates/DRS.cs

@@ -0,0 +1,255 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.DRS.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    // ReSharper disable InconsistentNaming
+    internal static class DRS
+    {
+        [FunctionId(FunctionId.NvAPI_DRS_CreateApplication)]
+        public delegate Status NvAPI_DRS_CreateApplication(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In]
+            [Accepts(
+                typeof(DRSApplicationV4),
+                typeof(DRSApplicationV3),
+                typeof(DRSApplicationV2),
+                typeof(DRSApplicationV1)
+            )]
+            ValueTypeReference application
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_CreateProfile)]
+        public delegate Status NvAPI_DRS_CreateProfile(
+            [In] DRSSessionHandle sessionHandle,
+            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile,
+            [Out] out DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_CreateSession)]
+        public delegate Status NvAPI_DRS_CreateSession([Out] out DRSSessionHandle sessionHandle);
+
+        [FunctionId(FunctionId.NvAPI_DRS_DeleteApplication)]
+        public delegate Status NvAPI_DRS_DeleteApplication(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] UnicodeString applicationName
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_DeleteApplicationEx)]
+        public delegate Status NvAPI_DRS_DeleteApplicationEx(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In]
+            [Accepts(typeof(DRSApplicationV1), typeof(DRSApplicationV2), typeof(DRSApplicationV3),
+                typeof(DRSApplicationV4))]
+            ValueTypeReference application
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_DeleteProfile)]
+        public delegate Status NvAPI_DRS_DeleteProfile(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_DeleteProfileSetting)]
+        public delegate Status NvAPI_DRS_DeleteProfileSetting(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] uint settingId
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_DestroySession)]
+        public delegate Status NvAPI_DRS_DestroySession([In] DRSSessionHandle sessionHandle);
+
+        [FunctionId(FunctionId.NvAPI_DRS_EnumApplications)]
+        public delegate Status NvAPI_DRS_EnumApplications(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] uint index,
+            [In] [Out] ref uint count,
+            [In]
+            [Accepts(
+                typeof(DRSApplicationV4),
+                typeof(DRSApplicationV3),
+                typeof(DRSApplicationV2),
+                typeof(DRSApplicationV1)
+            )]
+            ValueTypeArray applications
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_EnumAvailableSettingIds)]
+        public delegate Status NvAPI_DRS_EnumAvailableSettingIds(
+            [In] [Accepts(typeof(uint))] ValueTypeArray settingIds,
+            [In] [Out] ref uint count
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_EnumAvailableSettingValues)]
+        public delegate Status NvAPI_DRS_EnumAvailableSettingValues(
+            [In] uint settingId,
+            [In] [Out] ref uint count,
+            [In] [Out] [Accepts(typeof(DRSSettingValues))]
+            ValueTypeReference settingValues
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_EnumProfiles)]
+        public delegate Status NvAPI_DRS_EnumProfiles(
+            [In] DRSSessionHandle sessionHandle,
+            [In] uint index,
+            [Out] out DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_EnumSettings)]
+        public delegate Status NvAPI_DRS_EnumSettings(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] uint index,
+            [In] [Out] ref uint count,
+            [In] [Out] [Accepts(typeof(DRSSettingV1))]
+            ValueTypeArray settings
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_FindApplicationByName)]
+        public delegate Status NvAPI_DRS_FindApplicationByName(
+            [In] DRSSessionHandle sessionHandle,
+            [In] UnicodeString applicationName,
+            [Out] out DRSProfileHandle profileHandle,
+            [In]
+            [Accepts(
+                typeof(DRSApplicationV4),
+                typeof(DRSApplicationV3),
+                typeof(DRSApplicationV2),
+                typeof(DRSApplicationV1)
+            )]
+            ValueTypeReference application
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_FindProfileByName)]
+        public delegate Status NvAPI_DRS_FindProfileByName(
+            [In] DRSSessionHandle sessionHandle,
+            [In] UnicodeString profileName,
+            [Out] out DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetApplicationInfo)]
+        public delegate Status NvAPI_DRS_GetApplicationInfo(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] UnicodeString applicationName,
+            [In]
+            [Accepts(
+                typeof(DRSApplicationV4),
+                typeof(DRSApplicationV3),
+                typeof(DRSApplicationV2),
+                typeof(DRSApplicationV1)
+            )]
+            ValueTypeReference application
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetBaseProfile)]
+        public delegate Status NvAPI_DRS_GetBaseProfile(
+            [In] DRSSessionHandle sessionHandle,
+            [Out] out DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetCurrentGlobalProfile)]
+        public delegate Status NvAPI_DRS_GetCurrentGlobalProfile(
+            [In] DRSSessionHandle sessionHandle,
+            [Out] out DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetNumProfiles)]
+        public delegate Status NvAPI_DRS_GetNumProfiles([In] DRSSessionHandle sessionHandle, [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetProfileInfo)]
+        public delegate Status NvAPI_DRS_GetProfileInfo(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetSetting)]
+        public delegate Status NvAPI_DRS_GetSetting(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] uint settingId,
+            [Out] [Accepts(typeof(DRSSettingV1))] ValueTypeReference setting
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetSettingIdFromName)]
+        public delegate Status NvAPI_DRS_GetSettingIdFromName(
+            [In] UnicodeString settingName,
+            [Out] out uint settingId
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_GetSettingNameFromId)]
+        public delegate Status NvAPI_DRS_GetSettingNameFromId(
+            [In] uint settingId,
+            [Out] out UnicodeString settingName
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_LoadSettings)]
+        public delegate Status NvAPI_DRS_LoadSettings([In] DRSSessionHandle sessionHandle);
+
+        [FunctionId(FunctionId.NvAPI_DRS_LoadSettingsFromFile)]
+        public delegate Status NvAPI_DRS_LoadSettingsFromFile(
+            [In] DRSSessionHandle sessionHandle,
+            [In] UnicodeString fileName
+        );
+
+
+        [FunctionId(FunctionId.NvAPI_DRS_RestoreAllDefaults)]
+        public delegate Status NvAPI_DRS_RestoreAllDefaults(
+            [In] DRSSessionHandle sessionHandle
+        );
+
+
+        [FunctionId(FunctionId.NvAPI_DRS_RestoreProfileDefault)]
+        public delegate Status NvAPI_DRS_RestoreProfileDefault(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_RestoreProfileDefaultSetting)]
+        public delegate Status NvAPI_DRS_RestoreProfileDefaultSetting(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] uint settingId
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_SaveSettings)]
+        public delegate Status NvAPI_DRS_SaveSettings([In] DRSSessionHandle sessionHandle);
+
+        [FunctionId(FunctionId.NvAPI_DRS_SaveSettingsToFile)]
+        public delegate Status NvAPI_DRS_SaveSettingsToFile(
+            [In] DRSSessionHandle sessionHandle,
+            [In] UnicodeString fileName
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_SetCurrentGlobalProfile)]
+        public delegate Status NvAPI_DRS_SetCurrentGlobalProfile(
+            [In] DRSSessionHandle sessionHandle,
+            [In] UnicodeString profileName
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_SetProfileInfo)]
+        public delegate Status NvAPI_DRS_SetProfileInfo(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile
+        );
+
+        [FunctionId(FunctionId.NvAPI_DRS_SetSetting)]
+        public delegate Status NvAPI_DRS_SetSetting(
+            [In] DRSSessionHandle sessionHandle,
+            [In] DRSProfileHandle profileHandle,
+            [In] [Accepts(typeof(DRSSettingV1))] ValueTypeReference setting
+        );
+    }
+}

app/NvAPIWrapper/Native/Delegates/Display.cs

@@ -0,0 +1,328 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+using Rectangle = NvAPIWrapper.Native.General.Structures.Rectangle;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class Display
+    {
+        [FunctionId(FunctionId.NvAPI_CreateDisplayFromUnAttachedDisplay)]
+        public delegate Status NvAPI_CreateDisplayFromUnAttachedDisplay(
+            [In] UnAttachedDisplayHandle display,
+            [Out] out DisplayHandle newDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_ColorControl)]
+        public delegate Status NvAPI_Disp_ColorControl(
+            [In] uint displayId,
+            [In]
+            [Out]
+            [Accepts(
+                typeof(ColorDataV5),
+                typeof(ColorDataV4),
+                typeof(ColorDataV3),
+                typeof(ColorDataV2),
+                typeof(ColorDataV1)
+            )]
+            ValueTypeReference colorData
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_DeleteCustomDisplay)]
+        public delegate Status NvAPI_DISP_DeleteCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeReference customDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_EnumCustomDisplay)]
+        public delegate Status NvAPI_DISP_EnumCustomDisplay(
+            [In] uint displayId,
+            [In] uint index,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeReference customDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle)]
+        public delegate Status NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle(
+            [In] [MarshalAs(UnmanagedType.LPStr)] string displayName,
+            [Out] out UnAttachedDisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetDisplayConfig)]
+        public delegate Status NvAPI_DISP_GetDisplayConfig(
+            [In] [Out] ref uint pathInfoCount,
+            [In] [Accepts(typeof(PathInfoV2), typeof(PathInfoV1))]
+            ValueTypeArray pathInfos
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetDisplayIdByDisplayName)]
+        public delegate Status NvAPI_DISP_GetDisplayIdByDisplayName([In] string displayName, [Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetGDIPrimaryDisplayId)]
+        public delegate Status NvAPI_DISP_GetGDIPrimaryDisplayId([Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_Disp_GetHdrCapabilities)]
+        public delegate Status NvAPI_Disp_GetHdrCapabilities(
+            [In] uint displayId,
+            [In] [Out] [Accepts(typeof(HDRCapabilitiesV1))]
+            ValueTypeReference hdrCapabilities
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetMonitorCapabilities)]
+        public delegate Status NvAPI_DISP_GetMonitorCapabilities(
+            [In] uint displayId,
+            [In] [Accepts(typeof(MonitorCapabilities))]
+            ValueTypeReference capabilities
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetMonitorColorCapabilities)]
+        public delegate Status NvAPI_DISP_GetMonitorColorCapabilities(
+            [In] uint displayId,
+            [In] [Accepts(typeof(MonitorColorData))]
+            ValueTypeArray capabilities,
+            [In] [Out] ref uint count
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetTiming)]
+        public delegate Status NvAPI_DISP_GetTiming(
+            [In] uint displayId,
+            [In] [Accepts(typeof(TimingInput))] ValueTypeReference timingInput,
+            [In] [Accepts(typeof(Timing))] ValueTypeReference timing
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_HdrColorControl)]
+        public delegate Status NvAPI_Disp_HdrColorControl(
+            [In] uint displayId,
+            [In] [Out] [Accepts(typeof(HDRColorDataV2), typeof(HDRColorDataV1))]
+            ValueTypeReference hdrColorData
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_InfoFrameControl)]
+        public delegate Status NvAPI_Disp_InfoFrameControl(
+            [In] uint displayId,
+            [In] [Accepts(typeof(InfoFrameData))] ValueTypeReference infoFrameData
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_RevertCustomDisplayTrial)]
+        public delegate Status NvAPI_DISP_RevertCustomDisplayTrial(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_SaveCustomDisplay)]
+        public delegate Status NvAPI_DISP_SaveCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] uint isThisOutputIdOnly,
+            [In] uint isThisMonitorIdOnly
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_SetDisplayConfig)]
+        public delegate Status NvAPI_DISP_SetDisplayConfig(
+            [In] uint pathInfoCount,
+            [In] [Accepts(typeof(PathInfoV2), typeof(PathInfoV1))]
+            ValueTypeArray pathInfos,
+            [In] DisplayConfigFlags flags
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_TryCustomDisplay)]
+        public delegate Status NvAPI_DISP_TryCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeArray customDisplays
+        );
+
+        [FunctionId(FunctionId.NvAPI_EnumNvidiaDisplayHandle)]
+        public delegate Status NvAPI_EnumNvidiaDisplayHandle(
+            [In] uint enumId,
+            [Out] out DisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_EnumNvidiaUnAttachedDisplayHandle)]
+        public delegate Status NvAPI_EnumNvidiaUnAttachedDisplayHandle(
+            [In] uint enumId,
+            [Out] out UnAttachedDisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedDisplayOutputId)]
+        public delegate Status NvAPI_GetAssociatedDisplayOutputId(
+            [In] DisplayHandle display,
+            [Out] out OutputId outputId
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedNvidiaDisplayHandle)]
+        public delegate Status NvAPI_GetAssociatedNvidiaDisplayHandle(
+            [In] [MarshalAs(UnmanagedType.LPStr)] string displayName,
+            [Out] out DisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedNvidiaDisplayName)]
+        public delegate Status NvAPI_GetAssociatedNvidiaDisplayName(
+            [In] DisplayHandle display,
+            [Out] out ShortString displayName
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDisplayDriverBuildTitle)]
+        public delegate Status NvAPI_GetDisplayDriverBuildTitle(
+            [In] DisplayHandle displayHandle,
+            [Out] out ShortString name
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDisplayDriverMemoryInfo)]
+        public delegate Status NvAPI_GetDisplayDriverMemoryInfo(
+            [In] DisplayHandle displayHandle,
+            [In]
+            [Accepts(
+                typeof(DisplayDriverMemoryInfoV3),
+                typeof(DisplayDriverMemoryInfoV2),
+                typeof(DisplayDriverMemoryInfoV1)
+            )]
+            ValueTypeReference memoryInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDVCInfo)]
+        public delegate Status NvAPI_GetDVCInfo(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfo))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDVCInfoEx)]
+        public delegate Status NvAPI_GetDVCInfoEx(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfoEx))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetHDMISupportInfo)]
+        public delegate Status NvAPI_GetHDMISupportInfo(
+            [In] DisplayHandle displayHandle,
+            [In] uint displayIdOrOutputId,
+            [In] [Accepts(typeof(HDMISupportInfoV2), typeof(HDMISupportInfoV1))]
+            ValueTypeReference supportInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetHUEInfo)]
+        public delegate Status NvAPI_GetHUEInfo(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayHUEInfo))]
+            ValueTypeReference hueInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetSupportedViews)]
+        public delegate Status NvAPI_GetSupportedViews(
+            [In] DisplayHandle display,
+            [In] [Accepts(typeof(TargetViewMode))] ValueTypeArray viewModes,
+            [Out] [In] ref uint viewCount
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetUnAttachedAssociatedDisplayName)]
+        public delegate Status NvAPI_GetUnAttachedAssociatedDisplayName(
+            [In] UnAttachedDisplayHandle display,
+            [Out] out ShortString displayName
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutCompositionParameter)]
+        public delegate Status NvAPI_GPU_GetScanOutCompositionParameter(
+            [In] uint displayId,
+            [In] ScanOutCompositionParameter parameter,
+            [Out] out ScanOutCompositionParameterValue parameterValue,
+            [Out] out float container
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutConfiguration)]
+        public delegate Status NvAPI_GPU_GetScanOutConfiguration(
+            [In] uint displayId,
+            [In] [Accepts(typeof(Rectangle))] ValueTypeReference desktopRectangle,
+            [In] [Accepts(typeof(Rectangle))] ValueTypeReference scanOutRectangle
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutConfigurationEx)]
+        public delegate Status NvAPI_GPU_GetScanOutConfigurationEx(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutInformationV1))]
+            ValueTypeReference scanOutInformation
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutIntensityState)]
+        public delegate Status NvAPI_GPU_GetScanOutIntensityState(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutIntensityStateV1))]
+            ValueTypeReference scanOutIntensityState
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutWarpingState)]
+        public delegate Status NvAPI_GPU_GetScanOutWarpingState(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutWarpingStateV1))]
+            ValueTypeReference scanOutWarpingState
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutCompositionParameter)]
+        public delegate Status NvAPI_GPU_SetScanOutCompositionParameter(
+            [In] uint displayId,
+            [In] ScanOutCompositionParameter parameter,
+            [In] ScanOutCompositionParameterValue parameterValue,
+            [In] ref float container
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutIntensity)]
+        public delegate Status NvAPI_GPU_SetScanOutIntensity(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutIntensityV2), typeof(ScanOutIntensityV1))]
+            ValueTypeReference scanOutIntensityData,
+            [Out] out int isSticky
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutWarping)]
+        public delegate Status NvAPI_GPU_SetScanOutWarping(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutWarpingV1))]
+            ValueTypeReference scanOutWarping,
+            [In] [Out] ref int maximumNumberOfVertices,
+            [Out] out int isSticky
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetDVCLevel)]
+        public delegate Status NvAPI_SetDVCLevel(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] int dvcLevel
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetDVCLevelEx)]
+        public delegate Status NvAPI_SetDVCLevelEx(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfoEx))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetHUEAngle)]
+        public delegate Status NvAPI_SetHUEAngle(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] int hueAngle
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetRefreshRateOverride)]
+        public delegate Status NvAPI_SetRefreshRateOverride(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId outputMask,
+            [In] float refreshRate,
+            [In] uint isDeferred
+        );
+    }
+}

app/NvAPIWrapper/Native/Delegates/GPU.cs

@@ -0,0 +1,726 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class GPU
+    {
+        [FunctionId(FunctionId.NvAPI_EnumLogicalGPUs)]
+        public delegate Status NvAPI_EnumLogicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = LogicalGPUHandle.MaxLogicalGPUs)]
+            LogicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_EnumPhysicalGPUs)]
+        public delegate Status NvAPI_EnumPhysicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_EnumTCCPhysicalGPUs)]
+        public delegate Status NvAPI_EnumTCCPhysicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GetDriverModel)]
+        public delegate Status NvAPI_GetDriverModel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint model);
+
+        [FunctionId(FunctionId.NvAPI_GetGPUIDfromPhysicalGPU)]
+        public delegate Status NvAPI_GetGPUIDFromPhysicalGPU(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuId);
+
+        [FunctionId(FunctionId.NvAPI_GetLogicalGPUFromDisplay)]
+        public delegate Status NvAPI_GetLogicalGPUFromDisplay(
+            [In] DisplayHandle displayHandle,
+            [Out] out LogicalGPUHandle gpuHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetLogicalGPUFromPhysicalGPU)]
+        public delegate Status NvAPI_GetLogicalGPUFromPhysicalGPU(
+            [In] PhysicalGPUHandle physicalGPUHandle,
+            [Out] out LogicalGPUHandle logicalGPUHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUFromGPUID)]
+        public delegate Status NvAPI_GetPhysicalGPUFromGPUID(
+            [In] uint gpuId,
+            [Out] out PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUFromUnAttachedDisplay)]
+        public delegate Status NvAPI_GetPhysicalGPUFromUnAttachedDisplay(
+            [In] UnAttachedDisplayHandle displayHandle,
+            [Out] out PhysicalGPUHandle gpuHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUsFromDisplay)]
+        public delegate Status NvAPI_GetPhysicalGPUsFromDisplay(
+            [In] DisplayHandle displayHandle,
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUsFromLogicalGPU)]
+        public delegate Status NvAPI_GetPhysicalGPUsFromLogicalGPU(
+            [In] LogicalGPUHandle logicalGPUHandle,
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetControl)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetControl(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersControlV1))] [In]
+            ValueTypeReference control);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetInfo)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersInfoV1))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetStatus)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersSetControl)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersSetControl(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersControlV1))] [In]
+            ValueTypeReference control);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesGetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesGetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceControlParametersV1))] [In]
+            ValueTypeReference illuminationDeviceControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesGetInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceInfoParametersV1))] [In]
+            ValueTypeReference illuminationDevicesInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesSetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesSetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceControlParametersV1))] [In]
+            ValueTypeReference illuminationDeviceControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesGetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesGetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneControlParametersV1))] [In]
+            ValueTypeReference illuminationZoneControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesGetInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneInfoParametersV1))] [In]
+            ValueTypeReference illuminationZoneInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesSetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesSetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneControlParametersV1))] [In]
+            ValueTypeReference illuminationZoneControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesInfoV1))] [In]
+            ValueTypeReference powerInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesGetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesSetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesSetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerTopologyGetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerTopologyGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerTopologiesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_EnableDynamicPstates)]
+        public delegate Status NvAPI_GPU_EnableDynamicPStates([In] PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GPU_EnableOverclockedPstates)]
+        public delegate Status NvAPI_GPU_EnableOverclockedPStates([In] PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetActiveOutputs)]
+        public delegate Status NvAPI_GPU_GetActiveOutputs(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out OutputId outputMask);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAGPAperture)]
+        public delegate Status NvAPI_GPU_GetAGPAperture(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAllClockFrequencies)]
+        public delegate Status NvAPI_GPU_GetAllClockFrequencies(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ClockFrequenciesV3), typeof(ClockFrequenciesV2), typeof(ClockFrequenciesV1))]
+            ValueTypeReference nvClocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAllDisplayIds)]
+        public delegate Status NvAPI_GPU_GetAllDisplayIds(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(DisplayIdsV2))] [In] [Out]
+            ValueTypeArray pDisplayIds,
+            [In] [Out] ref uint displayIdCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetArchInfo)]
+        public delegate Status NvAPI_GPU_GetArchInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateArchitectInfoV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBoardInfo)]
+        public delegate Status NvAPI_GPU_GetBoardInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] [In] ref BoardInfo info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusId)]
+        public delegate Status NvAPI_GPU_GetBusId(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuBusId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusSlotId)]
+        public delegate Status NvAPI_GPU_GetBusSlotId(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuBusSlotId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusType)]
+        public delegate Status NvAPI_GPU_GetBusType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUBusType gpuBusType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostLock)]
+        public delegate Status NvAPI_GPU_GetClockBoostLock(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostLockV2))]
+            ValueTypeReference clockLocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostMask)]
+        public delegate Status NvAPI_GPU_GetClockBoostMask(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostMasksV1))]
+            ValueTypeReference clockMasks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostRanges)]
+        public delegate Status NvAPI_GPU_GetClockBoostRanges(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostRangesV1))]
+            ValueTypeReference clockRanges);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostTable)]
+        public delegate Status NvAPI_GPU_GetClockBoostTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostTableV1))]
+            ValueTypeReference boostTable);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetConnectedDisplayIds)]
+        public delegate Status NvAPI_GPU_GetConnectedDisplayIds(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(DisplayIdsV2))] [In] [Out]
+            ValueTypeArray pDisplayIds,
+            [In] [Out] ref uint displayIdCount,
+            [In] ConnectedIdsFlag flags);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_GetCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerPolicyTableV1))]
+            ValueTypeReference coolerPolicyTable,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoolerSettings)]
+        public delegate Status NvAPI_GPU_GetCoolerSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] CoolerTarget coolerIndex,
+            [In] [Accepts(typeof(PrivateCoolerSettingsV1))]
+            ValueTypeReference coolerSettings);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoreVoltageBoostPercent)]
+        public delegate Status NvAPI_GPU_GetCoreVoltageBoostPercent(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageBoostPercentV1))]
+            ValueTypeReference voltageBoostPercent);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentAGPRate)]
+        public delegate Status NvAPI_GPU_GetCurrentAGPRate(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint rate);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentFanSpeedLevel)]
+        public delegate Status NvAPI_GPU_GetCurrentFanSpeedLevel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint fanLevel);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentPCIEDownstreamWidth)]
+        public delegate Status NvAPI_GPU_GetCurrentPCIEDownstreamWidth(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint width);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentPstate)]
+        public delegate Status NvAPI_GPU_GetCurrentPState(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out PerformanceStateId performanceStateId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentThermalLevel)]
+        public delegate Status NvAPI_GPU_GetCurrentThermalLevel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint thermalLevel);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentVoltage)]
+        public delegate Status NvAPI_GPU_GetCurrentVoltage(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageStatusV1))]
+            ValueTypeReference voltageStatus);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetDynamicPstatesInfoEx)]
+        public delegate Status NvAPI_GPU_GetDynamicPStatesInfoEx(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(DynamicPerformanceStatesInfoV1))]
+            ValueTypeReference performanceStatesInfoEx);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCConfigurationInfo)]
+        public delegate Status NvAPI_GPU_GetECCConfigurationInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCConfigurationInfoV1))]
+            ValueTypeReference eccConfigurationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCErrorInfo)]
+        public delegate Status NvAPI_GPU_GetECCErrorInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCErrorInfoV1))] ValueTypeReference eccErrorInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCStatusInfo)]
+        public delegate Status NvAPI_GPU_GetECCStatusInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCStatusInfoV1))]
+            ValueTypeReference eccStatusInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetEDID)]
+        public delegate Status NvAPI_GPU_GetEDID(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] OutputId outputId,
+            [Accepts(typeof(EDIDV3), typeof(EDIDV2), typeof(EDIDV1))] [In]
+            ValueTypeReference edid);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFBWidthAndLocation)]
+        public delegate Status NvAPI_GPU_GetFBWidthAndLocation(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint width,
+            [Out] out uint location);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFoundry)]
+        public delegate Status NvAPI_GPU_GetFoundry(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUFoundry pFoundry);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFullName)]
+        public delegate Status NvAPI_GPU_GetFullName(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString name);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetGpuCoreCount)]
+        public delegate Status NvAPI_GPU_GetGpuCoreCount(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetGPUType)]
+        public delegate Status NvAPI_GPU_GetGPUType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUType gpuType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetIllumination)]
+        public delegate Status NvAPI_GPU_GetIllumination(
+            [Accepts(typeof(GetIlluminationParameterV1))] [In]
+            ValueTypeReference illuminationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetIRQ)]
+        public delegate Status NvAPI_GPU_GetIRQ(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuIRQ);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetLogicalFBWidthAndLocation)]
+        public delegate Status NvAPI_GPU_GetLogicalFBWidthAndLocation(
+            [In] LogicalGPUHandle logicalGpu,
+            [Out] out uint width,
+            [Out] out uint location);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetMemoryInfo)]
+        public delegate Status NvAPI_GPU_GetMemoryInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In]
+            [Accepts(typeof(DisplayDriverMemoryInfoV3), typeof(DisplayDriverMemoryInfoV2),
+                typeof(DisplayDriverMemoryInfoV1))]
+            ValueTypeReference memoryInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetOutputType)]
+        public delegate Status NvAPI_GPU_GetOutputType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint outputId,
+            [Out] out OutputType outputType);
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPartitionCount)]
+        public delegate Status NvAPI_GPU_GetPartitionCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPCIEInfo)]
+        public delegate Status NvAPI_GPU_GetPCIEInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePCIeInfoV2))] [In]
+            ValueTypeReference pcieInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPCIIdentifiers)]
+        public delegate Status NvAPI_GPU_GetPCIIdentifiers(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint deviceId,
+            [Out] out uint subSystemId,
+            [Out] out uint revisionId,
+            [Out] out uint extDeviceId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPerfDecreaseInfo)]
+        public delegate Status NvAPI_GPU_GetPerfDecreaseInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Out] out PerformanceDecreaseReason performanceDecreaseReason);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPhysicalFrameBufferSize)]
+        public delegate Status NvAPI_GPU_GetPhysicalFrameBufferSize(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPstates20)]
+        public delegate Status NvAPI_GPU_GetPStates20(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(
+                typeof(PerformanceStates20InfoV1),
+                typeof(PerformanceStates20InfoV2),
+                typeof(PerformanceStates20InfoV3)
+            )]
+            [In]
+            ValueTypeReference performanceStatesInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPstatesInfoEx)]
+        public delegate Status NvAPI_GPU_GetPStatesInfoEx(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(
+                typeof(PerformanceStatesInfoV3),
+                typeof(PerformanceStatesInfoV2),
+                typeof(PerformanceStatesInfoV1)
+            )]
+            [In]
+            ValueTypeReference performanceStatesInfo,
+            [In] GetPerformanceStatesInfoFlags flags);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetQuadroStatus)]
+        public delegate Status NvAPI_GPU_GetQuadroStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint isQuadro);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamBankCount)]
+        public delegate Status NvAPI_GPU_GetRamBankCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamBusWidth)]
+        public delegate Status NvAPI_GPU_GetRamBusWidth(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint busWidth);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamMaker)]
+        public delegate Status NvAPI_GPU_GetRamMaker(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUMemoryMaker maker);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamType)]
+        public delegate Status NvAPI_GPU_GetRamType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUMemoryType type);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetROPCount)]
+        public delegate Status NvAPI_GPU_GetROPCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShaderPipeCount)]
+        public delegate Status NvAPI_GPU_GetShaderPipeCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShaderSubPipeCount)]
+        public delegate Status NvAPI_GPU_GetShaderSubPipeCount(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShortName)]
+        public delegate Status NvAPI_GPU_GetShortName(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString name);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetSystemType)]
+        public delegate Status NvAPI_GPU_GetSystemType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out SystemType systemType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTachReading)]
+        public delegate Status NvAPI_GPU_GetTachReading(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint value);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalPoliciesInfo)]
+        public delegate Status NvAPI_GPU_GetThermalPoliciesInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesInfoV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalPoliciesStatus)]
+        public delegate Status NvAPI_GPU_GetThermalPoliciesStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesStatusV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalSettings)]
+        public delegate Status NvAPI_GPU_GetThermalSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] ThermalSettingsTarget sensorIndex,
+            [In] [Accepts(typeof(ThermalSettingsV2), typeof(ThermalSettingsV1))]
+            ValueTypeReference thermalSettings);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalSMCount)]
+        public delegate Status NvAPI_GPU_GetTotalSMCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalSPCount)]
+        public delegate Status NvAPI_GPU_GetTotalSPCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalTPCCount)]
+        public delegate Status NvAPI_GPU_GetTotalTPCCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetUsages)]
+        public delegate Status NvAPI_GPU_GetUsages(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateUsagesInfoV1))]
+            ValueTypeReference usageInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosOEMRevision)]
+        public delegate Status NvAPI_GPU_GetVbiosOEMRevision(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint biosOEMRevision);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosRevision)]
+        public delegate Status NvAPI_GPU_GetVbiosRevision(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint biosRevision);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosVersionString)]
+        public delegate Status NvAPI_GPU_GetVbiosVersionString(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString biosVersion);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVFPCurve)]
+        public delegate Status NvAPI_GPU_GetVFPCurve(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVFPCurveV1))]
+            ValueTypeReference vfpCurve);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVirtualFrameBufferSize)]
+        public delegate Status NvAPI_GPU_GetVirtualFrameBufferSize(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVPECount)]
+        public delegate Status NvAPI_GPU_GetVPECount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_PerfPoliciesGetInfo)]
+        public delegate Status NvAPI_GPU_PerfPoliciesGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivatePerformanceInfoV1))]
+            ValueTypeReference performanceInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_PerfPoliciesGetStatus)]
+        public delegate Status NvAPI_GPU_PerfPoliciesGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivatePerformanceStatusV1))]
+            ValueTypeReference performanceStatus);
+
+        [FunctionId(FunctionId.NvAPI_GPU_QueryActiveApps)]
+        public delegate Status NvAPI_GPU_QueryActiveApps(
+            [In] PhysicalGPUHandle gpu,
+            [In] [Accepts(typeof(PrivateActiveApplicationV2))]
+            ValueTypeArray applications,
+            [In] [Out] ref uint numberOfApplications
+        );
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_QueryIlluminationSupport)]
+        public delegate Status NvAPI_GPU_QueryIlluminationSupport(
+            [Accepts(typeof(QueryIlluminationSupportParameterV1))] [In]
+            ValueTypeReference illuminationSupportInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ResetECCErrorInfo)]
+        public delegate Status NvAPI_GPU_ResetECCErrorInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] byte resetCurrent,
+            [In] byte resetAggregated
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_RestoreCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_RestoreCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint[] indexes,
+            [In] uint indexesCount,
+            [In] CoolerPolicy policy);
+
+        [FunctionId(FunctionId.NvAPI_GPU_RestoreCoolerSettings)]
+        public delegate Status NvAPI_GPU_RestoreCoolerSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint[] indexes,
+            [In] uint indexesCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetClockBoostLock)]
+        public delegate Status NvAPI_GPU_SetClockBoostLock(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostLockV2))]
+            ValueTypeReference clockLocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetClockBoostTable)]
+        public delegate Status NvAPI_GPU_SetClockBoostTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostTableV1))]
+            ValueTypeReference boostTable);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoolerLevels)]
+        public delegate Status NvAPI_GPU_SetCoolerLevels(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerLevelsV1))]
+            ValueTypeReference coolerLevels,
+            [In] uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_SetCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerPolicyTableV1))]
+            ValueTypeReference coolerLevels,
+            [In] uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoreVoltageBoostPercent)]
+        public delegate Status NvAPI_GPU_SetCoreVoltageBoostPercent(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageBoostPercentV1))]
+            ValueTypeReference voltageBoostPercent);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetECCConfiguration)]
+        public delegate Status NvAPI_GPU_SetECCConfiguration(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] byte isEnable,
+            [In] byte isEnableImmediately
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetEDID)]
+        public delegate Status NvAPI_GPU_SetEDID(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint outputId,
+            [Accepts(typeof(EDIDV3), typeof(EDIDV2), typeof(EDIDV1))] [In]
+            ValueTypeReference edid);
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetIllumination)]
+        public delegate Status NvAPI_GPU_SetIllumination(
+            [Accepts(typeof(SetIlluminationParameterV1))] [In]
+            ValueTypeReference illuminationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetPstates20)]
+        public delegate Status NvAPI_GPU_SetPStates20(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PerformanceStates20InfoV3), typeof(PerformanceStates20InfoV2),
+                typeof(PerformanceStates20InfoV1))]
+            [In]
+            ValueTypeReference performanceStatesInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetThermalPoliciesStatus)]
+        public delegate Status NvAPI_GPU_SetThermalPoliciesStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesStatusV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ValidateOutputCombination)]
+        public delegate Status NvAPI_GPU_ValidateOutputCombination(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] OutputId outputMask);
+
+        [FunctionId(FunctionId.NvAPI_I2CRead)]
+        public delegate Status NvAPI_I2CRead(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(I2CInfoV3), typeof(I2CInfoV2))] ValueTypeReference i2cInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_I2CWrite)]
+        public delegate Status NvAPI_I2CWrite(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(I2CInfoV3), typeof(I2CInfoV2))] ValueTypeReference i2cInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetDisplayIdFromGpuAndOutputId)]
+        public delegate Status NvAPI_SYS_GetDisplayIdFromGpuAndOutputId(
+            [In] PhysicalGPUHandle gpu,
+            [In] OutputId outputId,
+            [Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetGpuAndOutputIdFromDisplayId)]
+        public delegate Status NvAPI_SYS_GetGpuAndOutputIdFromDisplayId(
+            [In] uint displayId,
+            [Out] out PhysicalGPUHandle gpu,
+            [Out] out OutputId outputId);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetPhysicalGpuFromDisplayId)]
+        public delegate Status NvAPI_SYS_GetPhysicalGpuFromDisplayId(
+            [In] uint displayId,
+            [Out] out PhysicalGPUHandle gpu);
+    }
+}

app/NvAPIWrapper/Native/Delegates/General.cs

@@ -0,0 +1,43 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class General
+    {
+        [FunctionId(FunctionId.NvAPI_GetErrorMessage)]
+        public delegate Status NvAPI_GetErrorMessage([In] Status status, out ShortString message);
+
+        [FunctionId(FunctionId.NvAPI_GetInterfaceVersionString)]
+        public delegate Status NvAPI_GetInterfaceVersionString(out ShortString version);
+
+        [FunctionId(FunctionId.NvAPI_Initialize)]
+        public delegate Status NvAPI_Initialize();
+
+
+        [FunctionId(FunctionId.NvAPI_RestartDisplayDriver)]
+        public delegate Status NvAPI_RestartDisplayDriver();
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetChipSetInfo)]
+        public delegate Status NvAPI_SYS_GetChipSetInfo(
+            [In] [Accepts(typeof(ChipsetInfoV4), typeof(ChipsetInfoV3), typeof(ChipsetInfoV2), typeof(ChipsetInfoV1))]
+            ValueTypeReference chipsetInfo);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetDriverAndBranchVersion)]
+        public delegate Status NvAPI_SYS_GetDriverAndBranchVersion(
+            out uint driverVersion,
+            out ShortString buildBranchString);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetLidAndDockInfo)]
+        public delegate Status NvAPI_SYS_GetLidAndDockInfo([In] [Out] ref LidDockParameters lidAndDock);
+
+        [FunctionId(FunctionId.NvAPI_Unload)]
+        public delegate Status NvAPI_Unload();
+    }
+}

app/NvAPIWrapper/Native/Delegates/Mosaic.cs

@@ -0,0 +1,88 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+using NvAPIWrapper.Native.Mosaic;
+using NvAPIWrapper.Native.Mosaic.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class Mosaic
+    {
+        [FunctionId(FunctionId.NvAPI_Mosaic_EnableCurrentTopo)]
+        public delegate Status NvAPI_Mosaic_EnableCurrentTopo(uint enable);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_EnumDisplayGrids)]
+        public delegate Status NvAPI_Mosaic_EnumDisplayGrids(
+            [Accepts(typeof(GridTopologyV2), typeof(GridTopologyV1))] [In] [Out]
+            ValueTypeArray gridTopology,
+            [In] [Out] ref uint gridCount);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_EnumDisplayModes)]
+        public delegate Status NvAPI_Mosaic_EnumDisplayModes(
+            [Accepts(typeof(GridTopologyV2), typeof(GridTopologyV1))] [In]
+            ValueTypeReference gridTopology,
+            [Accepts(typeof(DisplaySettingsV2), typeof(DisplaySettingsV1))] [In] [Out]
+            ValueTypeArray
+                displaysSettings,
+            [In] [Out] ref uint displaysCount);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_GetCurrentTopo)]
+        public delegate Status NvAPI_Mosaic_GetCurrentTopo(
+            [In] [Out] ref TopologyBrief topoBrief,
+            [Accepts(typeof(DisplaySettingsV2), typeof(DisplaySettingsV1))] [In] [Out]
+            ValueTypeReference displaySetting,
+            [Out] out int overlapX,
+            [Out] out int overlapY);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_GetOverlapLimits)]
+        public delegate Status NvAPI_Mosaic_GetOverlapLimits(
+            [In] TopologyBrief topoBrief,
+            [Accepts(typeof(DisplaySettingsV2), typeof(DisplaySettingsV1))] [In]
+            ValueTypeReference displaySetting,
+            [Out] out int minOverlapX,
+            [Out] out int maxOverlapX,
+            [Out] out int minOverlapY,
+            [Out] out int maxOverlapY);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_GetSupportedTopoInfo)]
+        public delegate Status NvAPI_Mosaic_GetSupportedTopoInfo(
+            [Accepts(typeof(SupportedTopologiesInfoV2), typeof(SupportedTopologiesInfoV1))] [In] [Out]
+            ValueTypeReference
+                supportedTopoInfo,
+            TopologyType topologyType);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_GetTopoGroup)]
+        public delegate Status NvAPI_Mosaic_GetTopoGroup(
+            [In] TopologyBrief topoBrief,
+            [In] [Out] ref TopologyGroup topoGroup);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_SetCurrentTopo)]
+        public delegate Status NvAPI_Mosaic_SetCurrentTopo(
+            [In] TopologyBrief topoBrief,
+            [Accepts(typeof(DisplaySettingsV2), typeof(DisplaySettingsV1))] [In]
+            ValueTypeReference displaySetting,
+            int overlapX,
+            int overlapY,
+            uint enable
+        );
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_SetDisplayGrids)]
+        public delegate Status NvAPI_Mosaic_SetDisplayGrids(
+            [Accepts(typeof(GridTopologyV2), typeof(GridTopologyV1))] [In]
+            ValueTypeArray gridTopologies,
+            [In] uint gridCount,
+            [In] SetDisplayTopologyFlag setTopoFlags);
+
+        [FunctionId(FunctionId.NvAPI_Mosaic_ValidateDisplayGrids)]
+        public delegate Status NvAPI_Mosaic_ValidateDisplayGrids(
+            [In] SetDisplayTopologyFlag setTopoFlags,
+            [Accepts(typeof(GridTopologyV2), typeof(GridTopologyV1))] [In]
+            ValueTypeArray gridTopologies,
+            [In] [Out] ref DisplayTopologyStatus[] topoStatuses,
+            [In] uint gridCount);
+    }
+}

app/NvAPIWrapper/Native/Delegates/Stereo.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+using NvAPIWrapper.Native.Stereo;
+using NvAPIWrapper.Native.Stereo.Structures;
+
+// ReSharper disable InconsistentNaming
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class Stereo
+    {
+        [FunctionId(FunctionId.NvAPI_D3D1x_CreateSwapChain)]
+        public delegate Status NvAPI_D3D1x_CreateSwapChain(
+            [In] StereoHandle stereoHandle,
+            [In] IntPtr dxgiSwapChainDescription,
+            [Out] out IntPtr dxgiSwapChain,
+            [In] StereoSwapChainMode mode
+        );
+
+        [FunctionId(FunctionId.NvAPI_D3D9_CreateSwapChain)]
+        public delegate Status NvAPI_D3D9_CreateSwapChain(
+            [In] StereoHandle stereoHandle,
+            [In] IntPtr d3dPresentParameters,
+            [Out] out IntPtr direct3DSwapChain9,
+            [In] StereoSwapChainMode mode
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_Activate)]
+        public delegate Status NvAPI_Stereo_Activate(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_CaptureJpegImage)]
+        public delegate Status NvAPI_Stereo_CaptureJpegImage(
+            [In] StereoHandle stereoHandle,
+            [In] uint quality
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_CapturePngImage)]
+        public delegate Status NvAPI_Stereo_CapturePngImage(
+            [In] StereoHandle stereoHandle
+        );
+        
+        [FunctionId(FunctionId.NvAPI_Stereo_CreateConfigurationProfileRegistryKey)]
+        public delegate Status NvAPI_Stereo_CreateConfigurationProfileRegistryKey(
+            [In] StereoRegistryProfileType registryProfileType
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_CreateHandleFromIUnknown)]
+        public delegate Status NvAPI_Stereo_CreateHandleFromIUnknown(
+            [In] IntPtr d3dDevice,
+            [Out] out StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_Deactivate)]
+        public delegate Status NvAPI_Stereo_Deactivate(
+            [In] StereoHandle stereoHandle
+        );
+        
+        [FunctionId(FunctionId.NvAPI_Stereo_Debug_WasLastDrawStereoized)]
+        public delegate Status NvAPI_Stereo_Debug_WasLastDrawStereoized(
+            [In] StereoHandle stereoHandle,
+            [Out] out byte wasStereo
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_DecreaseConvergence)]
+        public delegate Status NvAPI_Stereo_DecreaseConvergence(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_DecreaseSeparation)]
+        public delegate Status NvAPI_Stereo_DecreaseSeparation(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_DeleteConfigurationProfileRegistryKey)]
+        public delegate Status NvAPI_Stereo_DeleteConfigurationProfileRegistryKey(
+            [In] StereoRegistryProfileType registryProfileType
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_DeleteConfigurationProfileValue)]
+        public delegate Status NvAPI_Stereo_DeleteConfigurationProfileValue(
+            [In] StereoRegistryProfileType registryProfileType,
+            [In] StereoRegistryIdentification registryId
+        );
+        
+        [FunctionId(FunctionId.NvAPI_Stereo_DestroyHandle)]
+        public delegate Status NvAPI_Stereo_DestroyHandle(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_Disable)]
+        public delegate Status NvAPI_Stereo_Disable();
+
+        [FunctionId(FunctionId.NvAPI_Stereo_Enable)]
+        public delegate Status NvAPI_Stereo_Enable();
+
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetConvergence)]
+        public delegate Status NvAPI_Stereo_GetConvergence(
+            [In] StereoHandle stereoHandle,
+            [Out] out float convergence
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetDefaultProfile)]
+        public delegate Status NvAPI_Stereo_GetDefaultProfile(
+            [In] uint bufferSize,
+            [In] IntPtr stringBuffer,
+            [Out] out uint stringSize
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetEyeSeparation)]
+        public delegate Status NvAPI_Stereo_GetEyeSeparation(
+            [In] StereoHandle stereoHandle,
+            [Out] out float separation
+        );
+        
+        [FunctionId(FunctionId.NvAPI_Stereo_GetFrustumAdjustMode)]
+        public delegate Status NvAPI_Stereo_GetFrustumAdjustMode(
+            [In] StereoHandle stereoHandle,
+            [Out] out StereoFrustumAdjustMode frustumAdjustMode
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetSeparation)]
+        public delegate Status NvAPI_Stereo_GetSeparation(
+            [In] StereoHandle stereoHandle,
+            [Out] out float separationPercentage
+        );
+
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetStereoSupport)]
+        public delegate Status NvAPI_Stereo_GetStereoSupport(
+            [In] IntPtr monitorHandle,
+            [In] [Accepts(typeof(StereoCapabilitiesV1))]
+            ValueTypeReference capabilities
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_GetSurfaceCreationMode)]
+        public delegate Status NvAPI_Stereo_GetSurfaceCreationMode(
+            [In] StereoHandle stereoHandle,
+            [Out] out StereoSurfaceCreateMode surfaceCreateMode
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_IncreaseConvergence)]
+        public delegate Status NvAPI_Stereo_IncreaseConvergence(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_IncreaseSeparation)]
+        public delegate Status NvAPI_Stereo_IncreaseSeparation(
+            [In] StereoHandle stereoHandle
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_InitActivation)]
+        public delegate Status NvAPI_Stereo_InitActivation(
+            [In] StereoHandle stereoHandle,
+            [In] StereoActivationFlag flag
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_IsActivated)]
+        public delegate Status NvAPI_Stereo_IsActivated(
+            [In] StereoHandle stereoHandle,
+            [Out] out byte isStereoActive
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_IsEnabled)]
+        public delegate Status NvAPI_Stereo_IsEnabled([Out] out byte isEnable);
+
+        [FunctionId(FunctionId.NvAPI_Stereo_IsWindowedModeSupported)]
+        public delegate Status NvAPI_Stereo_IsWindowedModeSupported([Out] out byte isEnable);
+
+        [FunctionId(FunctionId.NvAPI_Stereo_ReverseStereoBlitControl)]
+        public delegate Status NvAPI_Stereo_ReverseStereoBlitControl(
+            [In] StereoHandle stereoHandle,
+            [In] byte turnOn
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetActiveEye)]
+        public delegate Status NvAPI_Stereo_SetActiveEye(
+            [In] StereoHandle stereoHandle,
+            [In] StereoActiveEye activeEye
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetConfigurationProfileValue)]
+        public delegate Status NvAPI_Stereo_SetConfigurationProfileValueFloat(
+            [In] StereoRegistryProfileType registryProfileType,
+            [In] StereoRegistryIdentification registryId,
+            [In] ref float value
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetConfigurationProfileValue)]
+        public delegate Status NvAPI_Stereo_SetConfigurationProfileValueInteger(
+            [In] StereoRegistryProfileType registryProfileType,
+            [In] StereoRegistryIdentification registryId,
+            [In] ref int value
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetConvergence)]
+        public delegate Status NvAPI_Stereo_SetConvergence(
+            [In] StereoHandle stereoHandle,
+            [In] float newConvergence
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetDefaultProfile)]
+        public delegate Status NvAPI_Stereo_SetDefaultProfile(
+            [In] [MarshalAs(UnmanagedType.LPStr)] string profileName
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetDriverMode)]
+        public delegate Status NvAPI_Stereo_SetDriverMode(
+            [In] StereoDriverMode driverMode
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetFrustumAdjustMode)]
+        public delegate Status NvAPI_Stereo_SetFrustumAdjustMode(
+            [In] StereoHandle stereoHandle,
+            [In] StereoFrustumAdjustMode frustumAdjustMode
+        );
+        
+        [FunctionId(FunctionId.NvAPI_Stereo_SetNotificationMessage)]
+        public delegate Status NvAPI_Stereo_SetNotificationMessage(
+            [In] StereoHandle stereoHandle,
+            [In] ulong windowHandle,
+            [In] ulong messageId
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetSeparation)]
+        public delegate Status NvAPI_Stereo_SetSeparation(
+            [In] StereoHandle stereoHandle,
+            [In] float newSeparationPercentage
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_SetSurfaceCreationMode)]
+        public delegate Status NvAPI_Stereo_SetSurfaceCreationMode(
+            [In] StereoHandle stereoHandle,
+            [In] StereoSurfaceCreateMode newSurfaceCreateMode
+        );
+
+        [FunctionId(FunctionId.NvAPI_Stereo_Trigger_Activation)]
+        public delegate Status NvAPI_Stereo_Trigger_Activation(
+            [In] StereoHandle stereoHandle
+        );
+    }
+}

app/NvAPIWrapper/Native/Display/ColorDataColorimetry.cs

@@ -0,0 +1,74 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for color data color space
+    /// </summary>
+    public enum ColorDataColorimetry : uint
+    {
+        /// <summary>
+        ///     RGB color space
+        /// </summary>
+        RGB = 0,
+
+        /// <summary>
+        ///     YCC601 color space
+        /// </summary>
+        YCC601,
+
+        /// <summary>
+        ///     YCC709 color space
+        /// </summary>
+        YCC709,
+
+        /// <summary>
+        ///     XVYCC601 color space
+        /// </summary>
+        XVYCC601,
+
+        /// <summary>
+        ///     XVYCC709 color space
+        /// </summary>
+        XVYCC709,
+
+        /// <summary>
+        ///     SYCC601 color space
+        /// </summary>
+        SYCC601,
+
+        /// <summary>
+        ///     ADOBEYCC601 color space
+        /// </summary>
+        ADOBEYCC601,
+
+        /// <summary>
+        ///     ADOBERGB color space
+        /// </summary>
+        ADOBERGB,
+
+        /// <summary>
+        ///     BT2020RGB color space
+        /// </summary>
+        BT2020RGB,
+
+        /// <summary>
+        ///     BT2020YCC color space
+        /// </summary>
+        BT2020YCC,
+
+        /// <summary>
+        ///     BT2020cYCC color space
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        BT2020cYCC,
+
+        /// <summary>
+        ///     Default color space
+        /// </summary>
+        Default = 0xFE,
+
+        /// <summary>
+        ///     Automatically select color space
+        /// </summary>
+        Auto = 0xFF
+    }
+}

app/NvAPIWrapper/Native/Display/ColorDataCommand.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the color data command
+    /// </summary>
+    public enum ColorDataCommand : uint
+    {
+        /// <summary>
+        ///     Get the current color data
+        /// </summary>
+        Get = 1,
+
+        /// <summary>
+        ///     Set the current color data
+        /// </summary>
+        Set,
+
+        /// <summary>
+        ///     Check if the passed color data is supported
+        /// </summary>
+        IsSupportedColor,
+
+        /// <summary>
+        ///     Get the default color data
+        /// </summary>
+        GetDefault
+    }
+}