From 9d90dd3a29e71fe7126ec0ffa36c59cc809425b8 Mon Sep 17 00:00:00 2001
From: Lesueur Benjamin <benjamin.lesueur@live.com>
Date: Sun, 17 Sep 2023 16:27:50 +0200
Subject: [PATCH] build 0.18.0.3

---
 HandheldCompanion.iss                         |   2 +-
 HandheldCompanion/Actions/GyroActions.cs      |   4 +
 .../Controllers/IController.xaml              | 101 ++--
 .../Controllers/IController.xaml.cs           |  73 ++-
 .../Controls/Mapping/GyroMapping.xaml         |  54 ++
 .../Controls/Mapping/GyroMapping.xaml.cs      |  11 +
 HandheldCompanion/CustomSettingsProvider.cs   |  59 ++-
 HandheldCompanion/Devices/Valve/SteamDeck.cs  |   2 +-
 HandheldCompanion/HandheldCompanion.csproj    |   4 +-
 HandheldCompanion/Helpers/RyzenSMU.cs         | 209 ++++++++
 HandheldCompanion/Helpers/VangoghGPU.cs       | 467 ++++++++++++++++++
 .../Managers/ControllerManager.cs             |  54 +-
 HandheldCompanion/Managers/DeviceManager.cs   | 233 ++++++++-
 HandheldCompanion/Managers/HotkeysManager.cs  |   2 +-
 HandheldCompanion/Managers/LayoutManager.cs   |  22 +-
 .../Managers/PerformanceManager.cs            |  29 +-
 HandheldCompanion/Managers/PlatformManager.cs |  20 +-
 HandheldCompanion/Managers/ProfileManager.cs  |  62 ++-
 HandheldCompanion/Misc/HidHide.cs             |  15 +-
 HandheldCompanion/Misc/PnPDetails.cs          |   2 +-
 HandheldCompanion/Platforms/GOGGalaxy.cs      |   6 +-
 HandheldCompanion/Platforms/HWiNFO.cs         |   6 +-
 HandheldCompanion/Platforms/IPlatform.cs      |  73 +--
 HandheldCompanion/Platforms/RTSS.cs           |  41 +-
 HandheldCompanion/Platforms/SteamPlatform.cs  |  74 ++-
 HandheldCompanion/Platforms/UbisoftConnect.cs |   6 +-
 HandheldCompanion/Processors/AMDProcessor.cs  |  67 ++-
 .../Properties/Resources.Designer.cs          |  54 ++
 HandheldCompanion/Properties/Resources.resx   |  18 +
 HandheldCompanion/Utils/CommonUtils.cs        | 103 ----
 HandheldCompanion/Utils/FileUtils.cs          | 144 ++++++
 HandheldCompanion/Utils/ProcessUtils.cs       |  54 +-
 HandheldCompanion/Utils/RegistryUtils.cs      |  33 ++
 .../Views/Pages/ControllerPage.xaml           | 145 +++---
 .../Views/Pages/ControllerPage.xaml.cs        |  79 ++-
 .../Views/Pages/LayoutPage.xaml.cs            |   3 +
 .../Views/Pages/ProfilesPage.xaml.cs          |  10 -
 .../QuickPages/QuickPerformancePage.xaml      |   2 +-
 .../Views/QuickPages/QuickProfilesPage.xaml   |  63 ++-
 .../QuickPages/QuickProfilesPage.xaml.cs      |  33 +-
 .../Views/Windows/MainWindow.xaml.cs          |   6 +-
 .../Views/Windows/OverlayQuickTools.xaml.cs   |   4 +-
 HandheldCompanion/XInputPlus/XInputPlus.cs    | 200 +++++---
 43 files changed, 2079 insertions(+), 570 deletions(-)
 create mode 100644 HandheldCompanion/Helpers/RyzenSMU.cs
 create mode 100644 HandheldCompanion/Helpers/VangoghGPU.cs
 create mode 100644 HandheldCompanion/Utils/FileUtils.cs

diff --git a/HandheldCompanion.iss b/HandheldCompanion.iss
index 8c9c52ae3..a641b5eba 100644
--- a/HandheldCompanion.iss
+++ b/HandheldCompanion.iss
@@ -389,7 +389,7 @@ end;
 
 #define MyAppSetupName 'Handheld Companion'
 #define MyBuildId 'HandheldCompanion'
-#define MyAppVersion '0.18.0.1'
+#define MyAppVersion '0.18.0.3'
 #define MyAppPublisher 'BenjaminLSR'
 #define MyAppCopyright 'Copyright @ BenjaminLSR'
 #define MyAppURL 'https://github.com/Valkirie/HandheldCompanion'
diff --git a/HandheldCompanion/Actions/GyroActions.cs b/HandheldCompanion/Actions/GyroActions.cs
index 5e2724c60..619748531 100644
--- a/HandheldCompanion/Actions/GyroActions.cs
+++ b/HandheldCompanion/Actions/GyroActions.cs
@@ -12,12 +12,16 @@ public class GyroActions : IActions
 
         public ButtonState MotionTrigger = new();
 
+        public float gyroWeight = DefaultGyroWeight;
+
+        // const vars
         public const int DefaultAxisAntiDeadZone = 15;
         public const AxisLayoutFlags DefaultAxisLayoutFlags = AxisLayoutFlags.RightStick;
 
         public const MouseActionsType DefaultMouseActionsType = MouseActionsType.Move;
         public const int DefaultSensivity = 33;
         public const int DefaultDeadzone = 10;
+        public const float DefaultGyroWeight = 1.2f;
 
         public GyroActions()
         {
diff --git a/HandheldCompanion/Controllers/IController.xaml b/HandheldCompanion/Controllers/IController.xaml
index 96e90617d..b73fc82c9 100644
--- a/HandheldCompanion/Controllers/IController.xaml
+++ b/HandheldCompanion/Controllers/IController.xaml
@@ -1,44 +1,73 @@
-<UserControl x:Class="HandheldCompanion.Controllers.IController"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
-             xmlns:local="clr-namespace:HandheldCompanion.Controllers"
-             xmlns:resx="clr-namespace:HandheldCompanion.Properties"
-             xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern"
-             mc:Ignorable="d" 
-             d:DesignHeight="450" d:DesignWidth="800">
+<UserControl
+    x:Class="HandheldCompanion.Controllers.IController"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:HandheldCompanion.Controllers"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:resx="clr-namespace:HandheldCompanion.Properties"
+    xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    mc:Ignorable="d">
 
     <Border
-                    Padding="15,12,12,12"
-                    Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
-                    CornerRadius="{DynamicResource ControlCornerRadius}">
+        Padding="15,12,12,12"
+        Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
+        CornerRadius="{DynamicResource ControlCornerRadius}">
 
-        <Grid>
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="5*" MinWidth="200" />
-                <ColumnDefinition Width="5*" MinWidth="200" />
-            </Grid.ColumnDefinitions>
+        <StackPanel>
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="5*" MinWidth="200" />
+                    <ColumnDefinition Width="5*" MinWidth="200" />
+                </Grid.ColumnDefinitions>
 
-            <DockPanel>
-                <ui:FontIcon
-                    
-                    Height="40"
-                    HorizontalAlignment="Center"
-                    FontFamily="{DynamicResource SymbolThemeFontFamily}"
-                    Glyph="&#xE7FC;" />
+                <DockPanel>
+                    <ui:FontIcon
+                        Height="40"
+                        HorizontalAlignment="Center"
+                        FontFamily="{DynamicResource SymbolThemeFontFamily}"
+                        Glyph="&#xE7FC;" />
 
-                <TextBlock Name="ui_name" Style="{StaticResource BodyTextBlockStyle}" VerticalAlignment="Center" Margin="12,0,0,0" />
-            </DockPanel>
+                    <TextBlock
+                        Name="ui_name"
+                        Margin="12,0,0,0"
+                        VerticalAlignment="Center"
+                        Style="{StaticResource BodyTextBlockStyle}" />
+                </DockPanel>
 
-            <DockPanel Grid.Column="1" HorizontalAlignment="Right">
-                <Button Name="ui_button_hook"
-                        Style="{DynamicResource AccentButtonStyle}" Width="100" FontSize="14" Click="ui_button_hook_Click"/>
-                <Button Name="ui_button_hide"
-                        Style="{DynamicResource AccentButtonStyle}" Width="100" FontSize="14" Margin="6,0,0,0" Click="ui_button_hide_Click"/>
-                <Button Name="ui_button_calibrate"
-                        Style="{DynamicResource AccentButtonStyle}" Width="100" FontSize="14" Margin="6,0,0,0" Visibility="Collapsed" Click="ui_button_calibrate_Click" Content="Calibrate"/>
-            </DockPanel>
-        </Grid>
+                <DockPanel Grid.Column="1" HorizontalAlignment="Right">
+                    <Button
+                        Name="ui_button_hook"
+                        Width="100"
+                        Click="ui_button_hook_Click"
+                        FontSize="14"
+                        Style="{DynamicResource AccentButtonStyle}" />
+                    <Button
+                        Name="ui_button_hide"
+                        Width="100"
+                        Margin="6,0,0,0"
+                        Click="ui_button_hide_Click"
+                        FontSize="14"
+                        Style="{DynamicResource AccentButtonStyle}" />
+                    <Button
+                        Name="ui_button_calibrate"
+                        Width="100"
+                        Margin="6,0,0,0"
+                        Click="ui_button_calibrate_Click"
+                        Content="Calibrate"
+                        FontSize="14"
+                        Style="{DynamicResource AccentButtonStyle}"
+                        Visibility="Collapsed" />
+                </DockPanel>
+            </Grid>
+
+            <ui:ProgressBar
+                Name="ProgressBarUpdate"
+                d:Visibility="Visible"
+                IsIndeterminate="True"
+                Visibility="Collapsed" />
+        </StackPanel>
     </Border>
 </UserControl>
diff --git a/HandheldCompanion/Controllers/IController.xaml.cs b/HandheldCompanion/Controllers/IController.xaml.cs
index fd1331f13..1315d230c 100644
--- a/HandheldCompanion/Controllers/IController.xaml.cs
+++ b/HandheldCompanion/Controllers/IController.xaml.cs
@@ -156,6 +156,9 @@ protected void RefreshControls()
             // UI thread (async)
             Application.Current.Dispatcher.BeginInvoke(() =>
             {
+                if (!IsEnabled)
+                    return;
+
                 ui_button_hook.Content = IsPlugged() ? Properties.Resources.Controller_Disconnect : Properties.Resources.Controller_Connect;
                 ui_button_hide.Content = IsHidden() ? Properties.Resources.Controller_Unhide : Properties.Resources.Controller_Hide;
                 ui_button_calibrate.Visibility = Capabilities.HasFlag(ControllerCapabilities.Calibration) ? Visibility.Visible : Visibility.Collapsed;
@@ -266,50 +269,78 @@ public bool IsHidden()
 
         public void Hide(bool powerCycle = true)
         {
-            if (IsHidden())
+            HideHID();
+
+            // set flag
+            powerCycle = powerCycle && this is not SteamController;
+
+            if (powerCycle)
+            {
+                // UI thread (async)
+                Application.Current.Dispatcher.BeginInvoke(() =>
+                {
+                    IsEnabled = false;
+                    ProgressBarUpdate.Visibility = Visibility.Visible;
+                });
+
+                ControllerManager.PowerCyclers[Details.baseContainerDeviceInstanceId] = true;
+                Details.CyclePort();
                 return;
+            }
 
-            // get HidHideDevice
-            HidHideDevice hideDevice = HidHide.GetHidHideDevice(Details.baseContainerDeviceInstanceId);
-            if (hideDevice is not null)
-                foreach (HidHideSubDevice subDevice in hideDevice.Devices)
-                    HidHide.HidePath(subDevice.DeviceInstancePath);
+            RefreshControls();
+        }
 
-            HidHide.HidePath(Details.deviceInstanceId);
-            HidHide.HidePath(Details.baseContainerDeviceInstanceId);
+        public void Unhide(bool powerCycle = true)
+        {
+            UnhideHID();
 
             // set flag
+            powerCycle = powerCycle && this is not SteamController;
+
             if (powerCycle)
             {
+                // UI thread (async)
+                Application.Current.Dispatcher.BeginInvoke(() =>
+                {
+                    IsEnabled = false;
+                    ProgressBarUpdate.Visibility = Visibility.Visible;
+                });
+
                 ControllerManager.PowerCyclers[Details.baseContainerDeviceInstanceId] = true;
                 Details.CyclePort();
+                return;
             }
 
             RefreshControls();
         }
 
-        public void Unhide(bool powerCycle = true)
+        public void HideHID()
         {
-            if (!IsHidden())
-                return;
+            HidHide.HidePath(Details.baseContainerDeviceInstanceId);
+            HidHide.HidePath(Details.deviceInstanceId);
 
+            /*
             // get HidHideDevice
             HidHideDevice hideDevice = HidHide.GetHidHideDevice(Details.baseContainerDeviceInstanceId);
             if (hideDevice is not null)
                 foreach (HidHideSubDevice subDevice in hideDevice.Devices)
-                    HidHide.UnhidePath(subDevice.DeviceInstancePath);
+                    HidHide.HidePath(subDevice.DeviceInstancePath);
+            */
+        }
 
-            HidHide.UnhidePath(Details.deviceInstanceId);
+        public void UnhideHID()
+        {
             HidHide.UnhidePath(Details.baseContainerDeviceInstanceId);
+            HidHide.UnhidePath(Details.deviceInstanceId);
 
-            // set flag
-            if (powerCycle)
-            {
-                ControllerManager.PowerCyclers[Details.baseContainerDeviceInstanceId] = true;
-                Details.CyclePort();
-            }
-
-            RefreshControls();
+            /*
+            // get HidHideDevice
+            HidHideDevice hideDevice = HidHide.GetHidHideDevice(Details.baseContainerDeviceInstanceId);
+            if (hideDevice is not null)
+                foreach (HidHideSubDevice subDevice in hideDevice.Devices)
+                    HidHide.UnhidePath(subDevice.DeviceInstancePath);
+            */
         }
 
         protected virtual void Calibrate()
diff --git a/HandheldCompanion/Controls/Mapping/GyroMapping.xaml b/HandheldCompanion/Controls/Mapping/GyroMapping.xaml
index bbdcbcd57..f478dc4c2 100644
--- a/HandheldCompanion/Controls/Mapping/GyroMapping.xaml
+++ b/HandheldCompanion/Controls/Mapping/GyroMapping.xaml
@@ -158,6 +158,60 @@
 
                     <ui:SimpleStackPanel Spacing="6">
                         <ui:SimpleStackPanel Spacing="6">
+
+                            <!--  Separator  -->
+                            <Separator
+                                BorderBrush="{DynamicResource SystemControlBackgroundChromeMediumBrush}"
+                                BorderThickness="0,1,0,0"
+                                Opacity="0.25" />
+
+                            <!--  Gyro Weight  -->
+                            <Grid>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="5*" MinWidth="200" />
+                                    <ColumnDefinition Width="5*" MinWidth="200" />
+                                </Grid.ColumnDefinitions>
+
+                                <StackPanel Orientation="Vertical">
+                                    <TextBlock Style="{StaticResource BodyTextBlockStyle}" Text="Gyrometer weight" />
+                                    <TextBlock
+                                        Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
+                                        Style="{StaticResource CaptionTextBlockStyle}"
+                                        Text="Modify the gyrometer weight when applied against joystick movements"
+                                        TextWrapping="Wrap" />
+                                </StackPanel>
+
+                                <DockPanel
+                                    Grid.Column="1"
+                                    Margin="12,0,0,0"
+                                    ScrollViewer.PanningMode="HorizontalOnly">
+                                    <TextBlock
+                                        Width="35"
+                                        VerticalAlignment="Center"
+                                        Text="{Binding Value, StringFormat=N1, ElementName=Slider_GyroWeight, Mode=OneWay}"
+                                        TextAlignment="Center" />
+                                    <Slider
+                                        x:Name="Slider_GyroWeight"
+                                        Margin="6,0,0,0"
+                                        VerticalAlignment="Center"
+                                        AutoToolTipPrecision="1"
+                                        IsMoveToPointEnabled="True"
+                                        IsSnapToTickEnabled="True"
+                                        Maximum="2.0"
+                                        Minimum="1.0"
+                                        Style="{DynamicResource SliderStyle1}"
+                                        TickFrequency="0.1"
+                                        TickPlacement="BottomRight"
+                                        ValueChanged="Slider_GyroWeight_ValueChanged" />
+                                </DockPanel>
+                            </Grid>
+
+                            <!--  Separator  -->
+                            <Separator
+                                BorderBrush="{DynamicResource SystemControlBackgroundChromeMediumBrush}"
+                                BorderThickness="0,1,0,0"
+                                Opacity="0.25" />
+
                             <!--  Improve circularity  -->
                             <Grid>
                                 <Grid.ColumnDefinitions>
diff --git a/HandheldCompanion/Controls/Mapping/GyroMapping.xaml.cs b/HandheldCompanion/Controls/Mapping/GyroMapping.xaml.cs
index 9c69c9955..b4a19256c 100644
--- a/HandheldCompanion/Controls/Mapping/GyroMapping.xaml.cs
+++ b/HandheldCompanion/Controls/Mapping/GyroMapping.xaml.cs
@@ -160,6 +160,7 @@ private void Action_SelectionChanged(object sender, SelectionChangedEventArgs e)
                 TargetComboBox.SelectedIndex = 0;
 
             // settings
+            Slider_GyroWeight.Value = ((AxisActions)Actions).gyroWeight;
             Axis2AxisImproveCircularity.IsOn = ((AxisActions)Actions).ImproveCircularity;
             Axis2AxisAutoRotate.IsOn = ((AxisActions)Actions).AutoRotate;
             Axis2AxisRotation.Value = (((AxisActions)Actions).AxisInverted ? 180 : 0) +
@@ -452,6 +453,16 @@ private void cB_UMC_MotionDefaultOffOn_SelectionChanged(object sender, Selection
         base.Update();
     }
 
+    private void Slider_GyroWeight_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
+    {
+        if (this.Actions is null)
+            return;
+
+        ((GyroActions)this.Actions).gyroWeight = (float)Slider_GyroWeight.Value;
+
+        base.Update();
+    }
+
     private void TriggerCreated(Hotkey hotkey)
     {
         switch (hotkey.inputsHotkey.Listener)
diff --git a/HandheldCompanion/CustomSettingsProvider.cs b/HandheldCompanion/CustomSettingsProvider.cs
index d8fe970c4..9f99f1b87 100644
--- a/HandheldCompanion/CustomSettingsProvider.cs
+++ b/HandheldCompanion/CustomSettingsProvider.cs
@@ -15,6 +15,7 @@ public class CustomSettingsProvider : SettingsProvider
         private const string NameAttribute = "name";
         private const string SerializeAsAttribute = "serializeAs";
         private const string ValueAttribute = "value";
+        private const string UserConfigFileName = "user.config";
 
         // Define a property to store the location of the user.config file
         public string UserConfigPath { get; set; }
@@ -32,7 +33,11 @@ public override void Initialize(string name, NameValueCollection config)
             base.Initialize(ApplicationName, config);
 
             // Get the path from the config parameter, or use a default value
-            UserConfigPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), ApplicationName, "user.config");
+            string SettingsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), ApplicationName);
+            UserConfigPath = Path.Combine(SettingsPath, UserConfigFileName);
+
+            if (!Directory.Exists(SettingsPath))
+                Directory.CreateDirectory(SettingsPath);
         }
 
         // Override the GetPropertyValues method to read the settings from the user.config file
@@ -101,32 +106,36 @@ public override void SetPropertyValues(SettingsContext context, SettingsProperty
             // Loop through each setting in the collection
             foreach (SettingsPropertyValue value in collection)
             {
-                // Try to find a matching node in the user.config file
-                XmlNode node = document.SelectSingleNode(string.Format("/{0}/{1}/{2}[@{3}='{4}']", RootNodeName, SettingsNodeName, SettingNodeName, NameAttribute, value.Name));
-
-                // If a node is not found, create a new one and append it to the settings node
-                if (node == null)
+                try
                 {
-                    node = document.CreateElement(SettingNodeName);
-                    XmlAttribute nameAttribute = document.CreateAttribute(NameAttribute);
-                    nameAttribute.Value = value.Name;
-                    node.Attributes.Append(nameAttribute);
-                    XmlAttribute serializeAsAttribute = document.CreateAttribute(SerializeAsAttribute);
-                    serializeAsAttribute.Value = value.Property.SerializeAs.ToString();
-                    node.Attributes.Append(serializeAsAttribute);
-                    document.DocumentElement.SelectSingleNode(SettingsNodeName).AppendChild(node);
+                    // Try to find a matching node in the user.config file
+                    XmlNode node = document.SelectSingleNode(string.Format("/{0}/{1}/{2}[@{3}='{4}']", RootNodeName, SettingsNodeName, SettingNodeName, NameAttribute, value.Name));
+
+                    // If a node is not found, create a new one and append it to the settings node
+                    if (node == null)
+                    {
+                        node = document.CreateElement(SettingNodeName);
+                        XmlAttribute nameAttribute = document.CreateAttribute(NameAttribute);
+                        nameAttribute.Value = value.Name;
+                        node.Attributes.Append(nameAttribute);
+                        XmlAttribute serializeAsAttribute = document.CreateAttribute(SerializeAsAttribute);
+                        serializeAsAttribute.Value = value.Property.SerializeAs.ToString();
+                        node.Attributes.Append(serializeAsAttribute);
+                        document.DocumentElement.SelectSingleNode(SettingsNodeName).AppendChild(node);
+                    }
+
+                    // Set or update the value attribute of the node
+                    XmlAttribute valueAttribute = node.Attributes[ValueAttribute];
+                    if (valueAttribute == null)
+                    {
+                        valueAttribute = document.CreateAttribute(ValueAttribute);
+                        node.Attributes.Append(valueAttribute);
+                    }
+
+                    if (value.SerializedValue is not null)
+                        valueAttribute.Value = value.SerializedValue.ToString();
                 }
-
-                // Set or update the value attribute of the node
-                XmlAttribute valueAttribute = node.Attributes[ValueAttribute];
-                if (valueAttribute == null)
-                {
-                    valueAttribute = document.CreateAttribute(ValueAttribute);
-                    node.Attributes.Append(valueAttribute);
-                }
-
-                if (value.SerializedValue is not null)
-                    valueAttribute.Value = value.SerializedValue.ToString();
+                catch { }
             }
 
             // Save the user.config file
diff --git a/HandheldCompanion/Devices/Valve/SteamDeck.cs b/HandheldCompanion/Devices/Valve/SteamDeck.cs
index 006e6685e..8a2200fb7 100644
--- a/HandheldCompanion/Devices/Valve/SteamDeck.cs
+++ b/HandheldCompanion/Devices/Valve/SteamDeck.cs
@@ -60,7 +60,7 @@ public SteamDeck()
         cTDP = new double[] { 4, 15 };
 
         // https://www.techpowerup.com/gpu-specs/steam-deck-gpu.c3897
-        GfxClock = new double[] { 100, 1600 };
+        GfxClock = new double[] { 200, 1600 };
 
         OEMChords.Add(new DeviceChord("...",
             new List<KeyCode>(), new List<KeyCode>(),
diff --git a/HandheldCompanion/HandheldCompanion.csproj b/HandheldCompanion/HandheldCompanion.csproj
index d5c621edf..84c4cb063 100644
--- a/HandheldCompanion/HandheldCompanion.csproj
+++ b/HandheldCompanion/HandheldCompanion.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows10.0.19041.0</TargetFramework>
+    <TargetFrameworks>net8.0-windows10.0.19041.0;net7.0-windows10.0.19041.0</TargetFrameworks>
 	<GenerateRuntimeConfigDevFile>true</GenerateRuntimeConfigDevFile>
 	<AppendTargetFrameworkToOutputPath>true</AppendTargetFrameworkToOutputPath>
 	<PlatformTarget>x64</PlatformTarget>
@@ -12,7 +12,7 @@
     <StartupObject>HandheldCompanion.App</StartupObject>
     <OutputPath>$(SolutionDir)bin\$(Configuration)</OutputPath>
     <ApplicationIcon>Resources\icon.ico</ApplicationIcon>
-    <Version>0.18.0.1</Version>
+    <Version>0.18.0.3</Version>
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
diff --git a/HandheldCompanion/Helpers/RyzenSMU.cs b/HandheldCompanion/Helpers/RyzenSMU.cs
new file mode 100644
index 000000000..50d28b55f
--- /dev/null
+++ b/HandheldCompanion/Helpers/RyzenSMU.cs
@@ -0,0 +1,209 @@
+using HandheldCompanion.Managers;
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace HandheldCompanion.Helpers
+{
+    public class RyzenSMU : IDisposable
+    {
+        public IntPtr MMIO_ADDR;
+        public uint MMIO_SIZE;
+        public uint RES_ADDR, MSG_ADDR, PARAM_ADDR;
+        public uint INDEX_ADDR, DATA_ADDR;
+
+        IntPtr mappedAddress;
+        IntPtr physicalHandle;
+        InpOut? inpOut;
+
+        public RyzenSMU()
+        {
+        }
+
+        ~RyzenSMU()
+        {
+            Dispose();
+        }
+
+        public bool Opened
+        {
+            get { return physicalHandle != IntPtr.Zero && mappedAddress != IntPtr.Zero; }
+        }
+
+        public bool Open()
+        {
+            if (physicalHandle != IntPtr.Zero)
+                return true;
+            if (MMIO_ADDR == IntPtr.Zero || MMIO_SIZE == 0)
+                return false;
+
+            try
+            {
+                inpOut = new InpOut();
+                mappedAddress = inpOut.MapPhysToLin(MMIO_ADDR, MMIO_SIZE, out physicalHandle);
+            }
+            catch (Exception e)
+            {
+                LogManager.LogError("RyzenSMU", e);
+                return false;
+            }
+
+            return Opened;
+        }
+
+        public void Dispose()
+        {
+            if (physicalHandle == IntPtr.Zero)
+                return;
+
+            GC.SuppressFinalize(this);
+            inpOut?.UnmapPhysicalMemory(physicalHandle, mappedAddress);
+            mappedAddress = IntPtr.Zero;
+            physicalHandle = IntPtr.Zero;
+            using (inpOut) { }
+            inpOut = null;
+        }
+
+        private uint RregRaw(uint reg)
+        {
+            return (uint)Marshal.ReadInt32(mappedAddress, (int)reg);
+        }
+
+        private void WregRaw(uint reg, uint value)
+        {
+            Marshal.WriteInt32(mappedAddress, (int)reg, (int)value);
+        }
+
+        private bool WregCheckedRaw(uint reg, uint value)
+        {
+            WregRaw(reg, value);
+            return RregRaw(reg) == value;
+        }
+
+        private bool Wreg(uint reg, uint value)
+        {
+            if (!Opened)
+                return false;
+
+            bool success = false;
+
+            try
+            {
+                if (reg < MMIO_SIZE)
+                {
+                    return success = WregCheckedRaw(reg, value);
+                }
+                else
+                {
+                    if (!WregCheckedRaw(INDEX_ADDR, reg))
+                        return false;
+                    if (!WregCheckedRaw(DATA_ADDR, value))
+                        return false;
+                }
+
+                return success = true;
+            }
+            finally
+            {
+                LogManager.LogTrace("Wreg: reg={0:X}, value={1:X} => success={2}",
+                       reg, value, success);
+            }
+        }
+
+        private bool Rreg(uint reg, out uint value)
+        {
+            value = default;
+
+            if (!Opened)
+                return false;
+
+            bool success = false;
+
+            try
+            {
+                if (reg < MMIO_SIZE)
+                {
+                    value = RregRaw(reg);
+                }
+                else
+                {
+                    if (!WregCheckedRaw(INDEX_ADDR, reg))
+                        return false;
+                    value = RregRaw(DATA_ADDR);
+                }
+
+                return success = true;
+            }
+            finally
+            {
+                LogManager.LogTrace("Rreg: reg={0:X} => read={1}/{1:X}, success={2}",
+                       reg, value, success);
+            }
+        }
+
+        private uint WaitForResponse()
+        {
+            const int timeout = 20;
+            for (int i = 0; i < timeout; i++)
+            {
+                uint value;
+                if (!Rreg(RES_ADDR, out value))
+                    return 0;
+                if (value != 0)
+                    return value;
+                Thread.SpinWait(100);
+            }
+            return 0;
+        }
+
+        public bool SendMsg(ushort msg, uint param)
+        {
+            return SendMsg(msg, param, out _);
+        }
+
+        public bool SendMsg(ushort msg, uint param, out uint arg)
+        {
+            bool success = false;
+
+            arg = 0;
+
+            try
+            {
+                var res = WaitForResponse();
+                if (res != 0x1)
+                {
+                    // Reset SMU state
+                    if (res != 0)
+                        Wreg(RES_ADDR, 1);
+                    return false;
+                }
+
+                Wreg(RES_ADDR, 0);
+                Wreg(PARAM_ADDR, param);
+                Wreg(MSG_ADDR, msg);
+
+                res = WaitForResponse();
+                if (res != 0x1)
+                    return false;
+
+                success = Rreg(PARAM_ADDR, out arg);
+                return success;
+            }
+            finally
+            {
+                LogManager.LogTrace(">> SendMsg: msg={0:X}, param={1:X} => arg={2}/{2:X}, success={3}",
+                       msg, param, arg, success);
+            }
+        }
+
+        public bool SendMsg<T>(T msg, uint param)
+        {
+            return SendMsg((ushort)(object)msg, param, out _);
+        }
+
+        public bool SendMsg<T>(T msg, uint param, out uint arg) where T : unmanaged
+        {
+            return SendMsg((ushort)(object)msg, param, out arg);
+        }
+    }
+}
diff --git a/HandheldCompanion/Helpers/VangoghGPU.cs b/HandheldCompanion/Helpers/VangoghGPU.cs
new file mode 100644
index 000000000..3f358c8c8
--- /dev/null
+++ b/HandheldCompanion/Helpers/VangoghGPU.cs
@@ -0,0 +1,467 @@
+using HandheldCompanion.Managers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Device = System.Tuple<string, ulong, ulong, uint[]>;
+
+namespace HandheldCompanion.Helpers
+{
+    internal class VangoghGPU : IDisposable
+    {
+        public static readonly Device[] SupportedDevices =
+        {
+            // SteamDeck
+            new Device("AMD Custom GPU 0405", 0x80300000, 0x8037ffff, new uint[] { 0x43F3900, 0x43F3C05, 0x43F3E00 }),
+
+            // SteamDeck unofficial APU drivers
+            // https://sourceforge.net/projects/amernimezone/files/Release%20Polaris-Vega-Navi/AMD%20SOC%20Driver%20Variant/
+            new Device("AMD Radeon 670M", 0x80300000, 0x8037ffff, new uint[] { 0x43F3900, 0x43F3C05, 0x43F3E00 }),
+        };
+
+        private static Device? DetectedDevice;
+
+        public static bool IsSupported
+        {
+            get { return DetectedDevice != null; }
+        }
+
+        public static VangoghGPU? Open()
+        {
+            if (DetectedDevice is null)
+                return null;
+
+            return Open(DetectedDevice);
+        }
+
+        public static VangoghGPU? Open(Device device)
+        {
+            if (device is null)
+                return null;
+
+            return OpenMMIO(new IntPtr((long)device.Item2), (uint)(device.Item3 - device.Item2 + 1));
+        }
+
+        public enum DetectionStatus
+        {
+            Detected,
+            Retryable,
+            NotDetected
+        }
+
+        public static DetectionStatus Detect()
+        {
+            var discoveredDevices = new Dictionary<string, string>();
+
+            foreach (var pnp in DeviceManager.GetDevices(DeviceManager.GUID_DISPLAY) ?? new string[0])
+            {
+                // Properly support many devices with the same name (pick the first one)
+                var name = DeviceManager.GetDeviceDesc(pnp);
+                if (name is not null && !discoveredDevices.ContainsKey(name))
+                    discoveredDevices[name] = pnp;
+            }
+
+            foreach (var device in SupportedDevices)
+            {
+                var deviceName = device.Item1;
+
+                if (!discoveredDevices.ContainsKey(deviceName))
+                {
+                    LogManager.LogError("GPU: {0}: Not matched.", deviceName);
+                    continue;
+                }
+
+                var devicePNP = discoveredDevices[deviceName];
+                var ranges = DeviceManager.GetDeviceMemResources(devicePNP);
+                if (ranges is null)
+                {
+                    LogManager.LogError("GPU: {0}: {1}: No memory ranges", deviceName, devicePNP);
+                    continue;
+                }
+                var expectedRange = new Tuple<UIntPtr, UIntPtr>(new UIntPtr(device.Item2), new UIntPtr(device.Item3));
+                if (!ranges.Contains(expectedRange))
+                {
+                    LogManager.LogError("GPU: {0}: {1}: Memory range not found: {2}",
+                        deviceName,
+                        devicePNP,
+                        String.Join(",", ranges.Select((item) => item.ToString()))
+                    );
+                    continue;
+                }
+
+                using (var gpu = Open(device))
+                {
+                    if (gpu is null)
+                    {
+                        LogManager.LogError("GPU: {0}: {1}: Failed to open.", deviceName, devicePNP);
+                        continue;
+                    }
+
+                    var smuVersion = gpu.SMUVersion;
+                    if (!device.Item4.Contains(smuVersion))
+                    {
+                        // Silence SMU_Version = 0 since it happens fairly often
+                        if (smuVersion != 0)
+                        {
+                            LogManager.LogError("GPU: {0}: {1}: SMU not supported: {2:X8} (IO: {3})", deviceName, devicePNP, smuVersion, expectedRange);
+                        }
+                        return DetectionStatus.Retryable;
+                    }
+
+                    LogManager.LogInformation("GPU: {0}: Matched!", deviceName);
+                    DetectedDevice = device;
+                    return DetectionStatus.Detected;
+                }
+            }
+            DetectedDevice = null;
+            return DetectionStatus.Detected;
+        }
+
+        // Addresses:
+        // drivers/gpu/drm/amd/include/vangogh_ip_offset.h => MP1_BASE => 0x00016000
+        // drivers/gpu/drm/amd/pm/swsmu/smu_cmn.c => mmMP1_SMN_C2PMSG_* => 0x0282/0x0292/0x029a
+        // drivers/gpu/drm/amd/include/asic_reg/nbio/nbio_7_4_offset.h => mmPCIE_INDEX2/mmPCIE_DATA2 => 0x000e/0x000f
+        //
+        // Messages:
+        // drivers/gpu/drm/amd/pm/inc/smu_v11_5_ppsmc.h
+
+        private RyzenSMU smu;
+
+        ~VangoghGPU()
+        {
+            Dispose();
+        }
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            if (smu != null)
+                smu.Dispose();
+        }
+
+        private static VangoghGPU? OpenMMIO(IntPtr mmioAddress, uint mmioSize)
+        {
+            var gpu = new VangoghGPU
+            {
+                smu = new RyzenSMU()
+                {
+                    MMIO_ADDR = mmioAddress,
+                    MMIO_SIZE = mmioSize,
+                    RES_ADDR = 0x0001629A * 4,
+                    MSG_ADDR = 0x00016282 * 4,
+                    PARAM_ADDR = 0x00016292 * 4,
+                    INDEX_ADDR = 0xE * 4,
+                    DATA_ADDR = 0xF * 4
+                }
+            };
+
+            if (!gpu.smu.Open())
+                return null;
+
+            return gpu;
+        }
+
+        public UInt32 SMUVersion
+        {
+            get { return getValue(Message.PPSMC_MSG_GetSmuVersion); }
+        }
+
+        public UInt32 IfVersion
+        {
+            get { return getValue(Message.PPSMC_MSG_GetDriverIfVersion); }
+        }
+
+        public Features SmuFeatures
+        {
+            get
+            {
+                UInt64 low = getValue(Message.PPSMC_MSG_GetEnabledSmuFeatures, 0);
+                UInt64 high = getValue(Message.PPSMC_MSG_GetEnabledSmuFeatures, 1);
+                return (Features)((high << 32) | low);
+            }
+        }
+
+        const uint MIN_TDP = 3000;
+        const uint MAX_TDP = 21000;
+
+        public uint SlowTDP
+        {
+            get { return getValue(Message.PPSMC_MSG_GetSlowPPTLimit); }
+            set { setValue(Message.PPSMC_MSG_SetSlowPPTLimit, value, MIN_TDP, MAX_TDP); }
+        }
+
+        public uint FastTDP
+        {
+            get { return getValue(Message.PPSMC_MSG_GetFastPPTLimit); }
+            set { setValue(Message.PPSMC_MSG_SetFastPPTLimit, value, MIN_TDP, MAX_TDP); }
+        }
+
+        public uint GfxClock
+        {
+            get { return getValue(Message.PPSMC_MSG_GetGfxclkFrequency); }
+        }
+
+        public uint FClock
+        {
+            get { return getValue(Message.PPSMC_MSG_GetFclkFrequency); }
+        }
+
+        const uint MIN_CPU_CLOCK = 1400;
+        const uint MAX_CPU_CLOCK = 4000;
+
+        public uint MinCPUClock
+        {
+            set { setCPUValue(Message.PPSMC_MSG_SetSoftMinCclk, value, MIN_CPU_CLOCK, MAX_CPU_CLOCK); }
+        }
+
+        public uint MaxCPUClock
+        {
+            set { setCPUValue(Message.PPSMC_MSG_SetSoftMaxCclk, value, MIN_CPU_CLOCK, MAX_CPU_CLOCK); }
+        }
+
+        const uint MIN_GFX_CLOCK = 200;
+        const uint MAX_GFX_CLOCK = 1900;
+
+        public uint HardMinGfxClock
+        {
+            set { setValue(Message.PPSMC_MSG_SetHardMinGfxClk, value, MIN_GFX_CLOCK, MAX_GFX_CLOCK); }
+        }
+
+        public uint SoftMinGfxClock
+        {
+            set { setValue(Message.PPSMC_MSG_SetSoftMinGfxclk, value, MIN_GFX_CLOCK, MAX_GFX_CLOCK); }
+        }
+
+        public uint SoftMaxGfxClock
+        {
+            set { setValue(Message.PPSMC_MSG_SetSoftMaxGfxClk, value, MIN_GFX_CLOCK, MAX_GFX_CLOCK); }
+        }
+
+        public Dictionary<string, uint> All
+        {
+            get
+            {
+                var dict = new Dictionary<string, uint>();
+
+                foreach (var key in ValuesGetters)
+                {
+                    if (!this.smu.SendMsg(key, 0, out var value))
+                        continue;
+
+                    var keyString = key.ToString().Replace("PPSMC_MSG_Get", "");
+                    dict[keyString] = value;
+                }
+
+                return dict;
+            }
+        }
+
+        private void setCPUValue(Message msg, uint value, uint min = UInt32.MinValue, uint max = UInt32.MaxValue)
+        {
+            // TODO: Hardcode CPUs
+            for (uint i = 0; i < 4; i++)
+            {
+                setValue(msg, value | (i << 20), min, max, (1 << 20) - 1);
+            }
+        }
+
+        private uint getValue(Message msg, UInt32 param = 0)
+        {
+            this.smu.SendMsg(msg, param, out var value);
+            return value;
+        }
+
+        private void setValue(Message msg, uint value, uint min = UInt32.MinValue, uint max = UInt32.MaxValue, uint clampMask = uint.MaxValue)
+        {
+            this.smu.SendMsg(msg, Math.Clamp(value & clampMask, min, max) | (value & ~clampMask));
+        }
+
+        private readonly Message[] ValuesGetters = new Message[]
+        {
+            Message.PPSMC_MSG_GetGfxclkFrequency,
+            Message.PPSMC_MSG_GetFclkFrequency,
+            Message.PPSMC_MSG_GetPptLimit,
+            Message.PPSMC_MSG_GetThermalLimit,
+            Message.PPSMC_MSG_GetFastPPTLimit,
+            Message.PPSMC_MSG_GetSlowPPTLimit,
+
+            // Those values return PPSMC_Result_CmdRejectedPrereq
+            Message.PPSMC_MSG_GetCurrentTemperature,
+            Message.PPSMC_MSG_GetCurrentPower,
+            Message.PPSMC_MSG_GetCurrentCurrent,
+            Message.PPSMC_MSG_GetCurrentFreq,
+            Message.PPSMC_MSG_GetCurrentVoltage,
+            Message.PPSMC_MSG_GetAverageCpuActivity,
+            Message.PPSMC_MSG_GetAverageGfxActivity,
+            Message.PPSMC_MSG_GetAveragePower,
+            Message.PPSMC_MSG_GetAverageTemperature
+        };
+
+        enum Result : byte
+        {
+            PPSMC_Result_OK = 0x1,
+            PPSMC_Result_Failed = 0xFF,
+            PPSMC_Result_UnknownCmd = 0xFE,
+            PPSMC_Result_CmdRejectedPrereq = 0xFD,
+            PPSMC_Result_CmdRejectedBusy = 0xFC
+        }
+
+        enum Tables : byte
+        {
+            TABLE_BIOS_IF = 0, // Called by BIOS
+            TABLE_WATERMARKS = 1, // Called by DAL through VBIOS
+            TABLE_CUSTOM_DPM = 2, // Called by Driver
+            TABLE_SPARE1 = 3,
+            TABLE_DPMCLOCKS = 4, // Called by Driver
+            TABLE_SPARE2 = 5, // Called by Tools
+            TABLE_MODERN_STDBY = 6, // Called by Tools for Modern Standby Log
+            TABLE_SMU_METRICS = 7, // Called by Driver
+            TABLE_COUNT = 8
+        }
+
+        enum Message : ushort
+        {
+            PPSMC_MSG_TestMessage = 0x1,
+            PPSMC_MSG_GetSmuVersion = 0x2,
+            PPSMC_MSG_GetDriverIfVersion = 0x3,
+            PPSMC_MSG_EnableGfxOff = 0x4,
+            PPSMC_MSG_DisableGfxOff = 0x5,
+            PPSMC_MSG_PowerDownIspByTile = 0x6, // ISP is power gated by default
+            PPSMC_MSG_PowerUpIspByTile = 0x7,
+            PPSMC_MSG_PowerDownVcn = 0x8, // VCN is power gated by default
+            PPSMC_MSG_PowerUpVcn = 0x9,
+            PPSMC_MSG_RlcPowerNotify = 0xA,
+            PPSMC_MSG_SetHardMinVcn = 0xB, // For wireless display
+            PPSMC_MSG_SetSoftMinGfxclk = 0xC, //Sets SoftMin for GFXCLK. Arg is in MHz
+            PPSMC_MSG_ActiveProcessNotify = 0xD,
+            PPSMC_MSG_SetHardMinIspiclkByFreq = 0xE,
+            PPSMC_MSG_SetHardMinIspxclkByFreq = 0xF,
+            PPSMC_MSG_SetDriverDramAddrHigh = 0x10,
+            PPSMC_MSG_SetDriverDramAddrLow = 0x11,
+            PPSMC_MSG_TransferTableSmu2Dram = 0x12,
+            PPSMC_MSG_TransferTableDram2Smu = 0x13,
+            PPSMC_MSG_GfxDeviceDriverReset = 0x14, //mode 2 reset during TDR
+            PPSMC_MSG_GetEnabledSmuFeatures = 0x15,
+            PPSMC_MSG_spare1 = 0x16,
+            PPSMC_MSG_SetHardMinSocclkByFreq = 0x17,
+            PPSMC_MSG_SetSoftMinFclk = 0x18, //Used to be PPSMC_MSG_SetMinVideoFclkFreq
+            PPSMC_MSG_SetSoftMinVcn = 0x19,
+            PPSMC_MSG_EnablePostCode = 0x1A,
+            PPSMC_MSG_GetGfxclkFrequency = 0x1B,
+            PPSMC_MSG_GetFclkFrequency = 0x1C,
+            PPSMC_MSG_AllowGfxOff = 0x1D,
+            PPSMC_MSG_DisallowGfxOff = 0x1E,
+            PPSMC_MSG_SetSoftMaxGfxClk = 0x1F,
+            PPSMC_MSG_SetHardMinGfxClk = 0x20,
+            PPSMC_MSG_SetSoftMaxSocclkByFreq = 0x21,
+            PPSMC_MSG_SetSoftMaxFclkByFreq = 0x22,
+            PPSMC_MSG_SetSoftMaxVcn = 0x23,
+            PPSMC_MSG_spare2 = 0x24,
+            PPSMC_MSG_SetPowerLimitPercentage = 0x25,
+            PPSMC_MSG_PowerDownJpeg = 0x26,
+            PPSMC_MSG_PowerUpJpeg = 0x27,
+            PPSMC_MSG_SetHardMinFclkByFreq = 0x28,
+            PPSMC_MSG_SetSoftMinSocclkByFreq = 0x29,
+            PPSMC_MSG_PowerUpCvip = 0x2A,
+            PPSMC_MSG_PowerDownCvip = 0x2B,
+            PPSMC_MSG_GetPptLimit = 0x2C,
+            PPSMC_MSG_GetThermalLimit = 0x2D,
+            PPSMC_MSG_GetCurrentTemperature = 0x2E,
+            PPSMC_MSG_GetCurrentPower = 0x2F,
+            PPSMC_MSG_GetCurrentVoltage = 0x30,
+            PPSMC_MSG_GetCurrentCurrent = 0x31,
+            PPSMC_MSG_GetAverageCpuActivity = 0x32,
+            PPSMC_MSG_GetAverageGfxActivity = 0x33,
+            PPSMC_MSG_GetAveragePower = 0x34,
+            PPSMC_MSG_GetAverageTemperature = 0x35,
+            PPSMC_MSG_SetAveragePowerTimeConstant = 0x36,
+            PPSMC_MSG_SetAverageActivityTimeConstant = 0x37,
+            PPSMC_MSG_SetAverageTemperatureTimeConstant = 0x38,
+            PPSMC_MSG_SetMitigationEndHysteresis = 0x39,
+            PPSMC_MSG_GetCurrentFreq = 0x3A,
+            PPSMC_MSG_SetReducedPptLimit = 0x3B,
+            PPSMC_MSG_SetReducedThermalLimit = 0x3C,
+            PPSMC_MSG_DramLogSetDramAddr = 0x3D,
+            PPSMC_MSG_StartDramLogging = 0x3E,
+            PPSMC_MSG_StopDramLogging = 0x3F,
+            PPSMC_MSG_SetSoftMinCclk = 0x40,
+            PPSMC_MSG_SetSoftMaxCclk = 0x41,
+            PPSMC_MSG_SetDfPstateActiveLevel = 0x42,
+            PPSMC_MSG_SetDfPstateSoftMinLevel = 0x43,
+            PPSMC_MSG_SetCclkPolicy = 0x44,
+            PPSMC_MSG_DramLogSetDramAddrHigh = 0x45,
+            PPSMC_MSG_DramLogSetDramBufferSize = 0x46,
+            PPSMC_MSG_RequestActiveWgp = 0x47,
+            PPSMC_MSG_QueryActiveWgp = 0x48,
+            PPSMC_MSG_SetFastPPTLimit = 0x49,
+            PPSMC_MSG_SetSlowPPTLimit = 0x4A,
+            PPSMC_MSG_GetFastPPTLimit = 0x4B,
+            PPSMC_MSG_GetSlowPPTLimit = 0x4C,
+            PPSMC_Message_Count = 0x4D,
+        }
+
+        [Flags]
+        public enum Features : UInt64
+        {
+            CCLK_DPM_BIT = 0,
+            FAN_CONTROLLER_BIT = 1,
+            DATA_CALCULATION_BIT = 2,
+            PPT_BIT = 3,
+            TDC_BIT = 4,
+            THERMAL_BIT = 5,
+            FIT_BIT = 6,
+            EDC_BIT = 7,
+            PLL_POWER_DOWN_BIT = 8,
+            ULV_BIT = 9,
+            VDDOFF_BIT = 10,
+            VCN_DPM_BIT = 11,
+            CSTATE_BOOST_BIT = 12,
+            FCLK_DPM_BIT = 13,
+            SOCCLK_DPM_BIT = 14,
+            MP0CLK_DPM_BIT = 15,
+            LCLK_DPM_BIT = 16,
+            SHUBCLK_DPM_BIT = 17,
+            DCFCLK_DPM_BIT = 18,
+            GFX_DPM_BIT = 19,
+            DS_GFXCLK_BIT = 20,
+            DS_SOCCLK_BIT = 21,
+            DS_LCLK_BIT = 22,
+            DS_DCFCLK_BIT = 23,
+            DS_SHUBCLK_BIT = 24,
+            GFX_TEMP_VMIN_BIT = 25,
+            S0I2_BIT = 26,
+            WHISPER_MODE_BIT = 27,
+            DS_FCLK_BIT = 28,
+            DS_SMNCLK_BIT = 29,
+            DS_MP1CLK_BIT = 30,
+            DS_MP0CLK_BIT = 31,
+            SMU_LOW_POWER_BIT = 32,
+            FUSE_PG_BIT = 33,
+            GFX_DEM_BIT = 34,
+            PSI_BIT = 35,
+            PROCHOT_BIT = 36,
+            CPUOFF_BIT = 37,
+            STAPM_BIT = 38,
+            S0I3_BIT = 39,
+            DF_CSTATES_BIT = 40,
+            PERF_LIMIT_BIT = 41,
+            CORE_DLDO_BIT = 42,
+            RSMU_LOW_POWER_BIT = 43,
+            SMN_LOW_POWER_BIT = 44,
+            THM_LOW_POWER_BIT = 45,
+            SMUIO_LOW_POWER_BIT = 46,
+            MP1_LOW_POWER_BIT = 47,
+            DS_VCN_BIT = 48,
+            CPPC_BIT = 49,
+            OS_CSTATES_BIT = 50,
+            ISP_DPM_BIT = 51,
+            A55_DPM_BIT = 52,
+            CVIP_DSP_DPM_BIT = 53,
+            MSMU_LOW_POWER_BIT = 54,
+            SOC_VOLTAGE_MON_BIT = 55,
+            ATHUB_PG_BIT = 56,
+            ECO_DEEPCSTATE_BIT = 57,
+            CC6_BIT = 58,
+            GFX_EDC_BIT = 59
+        }
+    }
+}
diff --git a/HandheldCompanion/Managers/ControllerManager.cs b/HandheldCompanion/Managers/ControllerManager.cs
index de2ca28c5..3123992f7 100644
--- a/HandheldCompanion/Managers/ControllerManager.cs
+++ b/HandheldCompanion/Managers/ControllerManager.cs
@@ -179,8 +179,8 @@ public static void Stop()
 
         // uncloak on close, if requested
         if (SettingsManager.GetBoolean("HIDuncloakonclose"))
-            foreach (var controller in Controllers.Values)
-                controller.Unhide();
+            foreach (var controller in GetPhysicalControllers())
+                controller.Unhide(false);
 
         // unplug on close
         var target = GetTargetController();
@@ -433,26 +433,23 @@ private static void HidDeviceArrived(PnPDetails details, DeviceEventArgs obj)
         PowerCyclers.TryGetValue(details.baseContainerDeviceInstanceId, out bool IsPowerCycling);
 
         // power cycling logic
-        if (IsPowerCycling)
-        {
-            // hide new InstanceID (HID)
-            if (controller.IsHidden())
-                HidHide.HidePath(details.deviceInstanceId);
-        }
-
-        // first controller logic
-        if (!controller.IsVirtual() && GetTargetController() is null && DeviceManager.IsInitialized)
-            SetTargetController(controller.GetContainerInstancePath(), IsPowerCycling);
+        // hide new InstanceID (HID)
+        if (IsPowerCycling && controller.IsHidden())
+            controller.HideHID();
 
         LogManager.LogDebug("Generic controller {0} plugged", controller.ToString());
 
         // raise event
         ControllerPlugged?.Invoke(controller, IsHCVirtualController(controller), IsPowerCycling);
 
+        ToastManager.SendToast(controller.ToString(), "detected");
+
         // remove controller from powercyclers
-        PowerCyclers[details.baseContainerDeviceInstanceId] = false;
+        PowerCyclers.Remove(controller.GetContainerInstancePath());
 
-        ToastManager.SendToast(controller.ToString(), "detected");
+        // first controller logic
+        if (!controller.IsVirtual() && GetTargetController() is null && DeviceManager.IsInitialized)
+            SetTargetController(controller.GetContainerInstancePath(), IsPowerCycling);
     }
 
     private static void HidDeviceRemoved(PnPDetails details, DeviceEventArgs obj)
@@ -467,6 +464,10 @@ private static void HidDeviceRemoved(PnPDetails details, DeviceEventArgs obj)
         // are we power cycling ?
         PowerCyclers.TryGetValue(details.baseContainerDeviceInstanceId, out bool IsPowerCycling);
 
+        // unhide on remove 
+        if (!IsPowerCycling)
+            controller.UnhideHID();
+
         // controller was unplugged
         Controllers.Remove(details.baseContainerDeviceInstanceId);
 
@@ -513,26 +514,23 @@ private static void XUsbDeviceArrived(PnPDetails details, DeviceEventArgs obj)
             PowerCyclers.TryGetValue(details.baseContainerDeviceInstanceId, out bool IsPowerCycling);
 
             // power cycling logic
-            if (IsPowerCycling)
-            {
-                // hide new InstanceID (HID)
-                if (controller.IsHidden())
-                    HidHide.HidePath(details.deviceInstanceId);
-            }
-
-            // first controller logic
-            if (!controller.IsVirtual() && GetTargetController() is null && DeviceManager.IsInitialized)
-                SetTargetController(controller.GetContainerInstancePath(), IsPowerCycling);
+            // hide new InstanceID (HID)
+            if (IsPowerCycling && controller.IsHidden())
+                controller.HideHID();
 
             LogManager.LogDebug("XInput controller {0} plugged", controller.ToString());
 
             // raise event
             ControllerPlugged?.Invoke(controller, IsHCVirtualController(controller), IsPowerCycling);
 
+            ToastManager.SendToast(controller.ToString(), "detected");
+
             // remove controller from powercyclers
-            PowerCyclers[details.baseContainerDeviceInstanceId] = false;
+            PowerCyclers.Remove(controller.GetContainerInstancePath());
 
-            ToastManager.SendToast(controller.ToString(), "detected");
+            // first controller logic
+            if (!controller.IsVirtual() && GetTargetController() is null && DeviceManager.IsInitialized)
+                SetTargetController(controller.GetContainerInstancePath(), IsPowerCycling);
         });
     }
 
@@ -544,6 +542,10 @@ private static void XUsbDeviceRemoved(PnPDetails details, DeviceEventArgs obj)
         // are we power cycling ?
         PowerCyclers.TryGetValue(details.baseContainerDeviceInstanceId, out bool IsPowerCycling);
 
+        // unhide on remove
+        if (!IsPowerCycling)
+            controller.UnhideHID();
+
         // controller was unplugged
         Controllers.Remove(details.baseContainerDeviceInstanceId);
 
diff --git a/HandheldCompanion/Managers/DeviceManager.cs b/HandheldCompanion/Managers/DeviceManager.cs
index 5a1f5281c..bfbefaa59 100644
--- a/HandheldCompanion/Managers/DeviceManager.cs
+++ b/HandheldCompanion/Managers/DeviceManager.cs
@@ -452,28 +452,30 @@ private static async void XUsbDevice_DeviceArrived(DeviceEventArgs obj)
             var deviceEx = FindDevice(SymLink);
             if (deviceEx is not null && deviceEx.isGaming)
             {
-                SafeFileHandle handle = CreateFileW(obj.SymLink, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
-
-                if (handle.IsInvalid)
-                    return;
+                deviceEx.isXInput = true;
 
-                byte[] gamepadStateRequest0101 = new byte[3] { 0x01, 0x01, 0x00 };
-                byte[] ledStateData = new byte[3];
-                uint len = 0;
+                using (SafeFileHandle handle = CreateFileW(obj.SymLink, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0))
+                {
+                    if (handle.IsInvalid)
+                        goto Event;
 
-                if (!DeviceIoControl(handle, IOCTL_XUSB_GET_LED_STATE, gamepadStateRequest0101, gamepadStateRequest0101.Length, ledStateData, ledStateData.Length, ref len, 0))
-                    return;
+                    byte[] gamepadStateRequest0101 = new byte[3] { 0x01, 0x01, 0x00 };
+                    byte[] ledStateData = new byte[3];
+                    uint len = 0;
 
-                byte ledState = ledStateData[2];
+                    if (!DeviceIoControl(handle, IOCTL_XUSB_GET_LED_STATE, gamepadStateRequest0101, gamepadStateRequest0101.Length, ledStateData, ledStateData.Length, ref len, 0))
+                        goto Event;
 
-                deviceEx.isXInput = true;
-                deviceEx.XInputUserIndex = XINPUT_LED_TO_PORT_MAP[ledState];
+                    byte ledState = ledStateData[2];
+                    deviceEx.XInputUserIndex = XINPUT_LED_TO_PORT_MAP[ledState];
+                }
 
                 LogManager.LogDebug("XUsbDevice {4} arrived on slot {5}: {0} (VID:{1}, PID:{2}) {3}", deviceEx.Name,
                     deviceEx.GetVendorID(), deviceEx.GetProductID(), deviceEx.deviceInstanceId, deviceEx.isVirtual ? "virtual" : "physical", deviceEx.XInputUserIndex);
 
                 // raise event
-                XUsbDeviceArrived?.Invoke(deviceEx, obj);
+                Event:
+                    XUsbDeviceArrived?.Invoke(deviceEx, obj);
             }
         }
         catch
@@ -556,6 +558,183 @@ private static void UsbDevice_DeviceArrived(DeviceEventArgs obj)
         }
     }
 
+    public static string[]? GetDevices(Guid? classGuid)
+    {
+        string? filter = null;
+        int flags = CM_GETIDLIST_FILTER_PRESENT;
+
+        if (classGuid is not null)
+        {
+            filter = classGuid?.ToString("B").ToUpper();
+            flags |= CM_GETIDLIST_FILTER_CLASS;
+        }
+
+        var res = CM_Get_Device_ID_List_Size(out var size, filter, flags);
+        if (res != CR_SUCCESS)
+            return null;
+
+        char[] data = new char[size];
+        res = CM_Get_Device_ID_List(filter, data, size, flags);
+        if (res != CR_SUCCESS)
+            return null;
+
+        var result = new string(data);
+        var devices = result.Split('\0', StringSplitOptions.RemoveEmptyEntries);
+        return devices.ToArray();
+    }
+
+    public static string? GetDeviceDesc(String PNPString)
+    {
+        if (CM_Locate_DevNode(out var devInst, PNPString, 0) != 0)
+            return null;
+
+        if (!CM_Get_DevNode_Property(devInst, DEVPKEY_Device_DeviceDesc, out var deviceDesc, 0))
+            return null;
+
+        return deviceDesc;
+    }
+
+    public static IList<Tuple<UIntPtr, UIntPtr>>? GetDeviceMemResources(string PNPString)
+    {
+        int res = CM_Locate_DevNode(out var devInst, PNPString, 0);
+        if (res != CR_SUCCESS)
+            return null;
+
+        res = CM_Get_First_Log_Conf(out var logConf, devInst, ALLOC_LOG_CONF);
+        if (res != CR_SUCCESS)
+            res = CM_Get_First_Log_Conf(out logConf, devInst, BOOT_LOG_CONF);
+        if (res != CR_SUCCESS)
+            return null;
+
+        var ranges = new List<Tuple<UIntPtr, UIntPtr>>();
+
+        while (CM_Get_Next_Res_Des(out var newResDes, logConf, ResType_Mem, out _, 0) == 0)
+        {
+            CM_Free_Res_Des_Handle(logConf);
+            logConf = newResDes;
+
+            if (!CM_Get_Res_Des_Data<MEM_RESOURCE>(logConf, out var memResource, 0))
+                continue;
+
+            ranges.Add(new Tuple<UIntPtr, UIntPtr>(
+                memResource.MEM_Header.MD_Alloc_Base, memResource.MEM_Header.MD_Alloc_End));
+        }
+
+        CM_Free_Res_Des_Handle(logConf);
+        return ranges;
+    }
+
+    static bool CM_Get_DevNode_Property(IntPtr devInst, DEVPROPKEY propertyKey, out string result, int flags)
+    {
+        result = default;
+
+        // int length = 0;
+        // int res = CM_Get_DevNode_Property(devInst, ref propertyKey, out var propertyType, null, ref length, flags);
+        // if (res != CR_SUCCESS && res != CR_BUFFER_TOO_SMALL)
+        //     return false;
+
+        char[] buffer = new char[2048];
+        int length = buffer.Length;
+        int res = CM_Get_DevNode_Property(devInst, ref propertyKey, out var propertyType, buffer, ref length, flags);
+        if (res != CR_SUCCESS)
+            return false;
+        if (propertyType != DEVPROP_TYPE_STRING)
+            return false;
+
+        result = new String(buffer, 0, length).Split('\0').First();
+        return true;
+    }
+
+    static bool CM_Get_Res_Des_Data<T>(IntPtr rdResDes, out T buffer, int ulFlags) where T : struct
+    {
+        buffer = default;
+
+        int res = CM_Get_Res_Des_Data_Size(out var size, rdResDes, ulFlags);
+        if (res != CR_SUCCESS)
+            return false;
+
+        int sizeOf = Marshal.SizeOf<T>();
+        if (sizeOf < size)
+            return false;
+
+        var addr = Marshal.AllocHGlobal(sizeOf);
+        try
+        {
+            res = CM_Get_Res_Des_Data(rdResDes, addr, size, 0);
+            if (res != CR_SUCCESS)
+                return false;
+
+            buffer = Marshal.PtrToStructure<T>(addr);
+            return true;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(addr);
+        }
+    }
+
+    #region struct
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct MEM_DES
+    {
+        internal uint MD_Count;
+        internal uint MD_Type;
+        internal UIntPtr MD_Alloc_Base;
+        internal UIntPtr MD_Alloc_End;
+        internal uint MD_Flags;
+        internal uint MD_Reserved;
+    };
+
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    struct MEM_RANGE
+    {
+        internal UIntPtr MR_Align;     // specifies mask for base alignment
+        internal uint MR_nBytes;    // specifies number of bytes required
+        internal UIntPtr MR_Min;       // specifies minimum address of the range
+        internal UIntPtr MR_Max;       // specifies maximum address of the range
+        internal uint MR_Flags;     // specifies flags describing range (fMD flags)
+        internal uint MR_Reserved;
+    };
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct MEM_RESOURCE
+    {
+        internal MEM_DES MEM_Header;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
+        internal MEM_RANGE[] MEM_Data;
+    };
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct DEVPROPKEY
+    {
+        public Guid Guid;
+        public uint Pid;
+
+        public DEVPROPKEY(String guid, uint pid)
+        {
+            this.Guid = new Guid(guid);
+            this.Pid = pid;
+        }
+    };
+
+    const int ALLOC_LOG_CONF = 0x00000002;  // Specifies the Alloc Element.
+    const int BOOT_LOG_CONF = 0x00000003;  // Specifies the RM Alloc Element.
+    const int ResType_Mem = (0x00000001);  // Physical address resource
+
+    const int CM_GETIDLIST_FILTER_PRESENT = 0x00000100;
+    const int CM_GETIDLIST_FILTER_CLASS = 0x00000200;
+    const int CR_SUCCESS = 0x0;
+    const int CR_BUFFER_TOO_SMALL = 0x1A;
+
+    const int DEVPROP_TYPE_STRING = 0x00000012;
+
+    static readonly DEVPROPKEY DEVPKEY_Device_DeviceDesc = new DEVPROPKEY("a45c254e-df1c-4efd-8020-67d146a850e0", 2);
+
+    internal static readonly Guid GUID_DISPLAY = new Guid("{4d36e968-e325-11ce-bfc1-08002be10318}");
+
+    #endregion
+
     #region import
 
     [DllImport("hid.dll", EntryPoint = "HidD_GetHidGuid")]
@@ -590,6 +769,34 @@ private static extern bool DeviceIoControl(
         int nOutBufferSize,
         ref uint pBytesReturned,
         IntPtr overlapped);
+
+    [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
+    static extern int CM_Locate_DevNode(out IntPtr pdnDevInst, string pDeviceID, int ulFlags);
+
+    [DllImport("setupapi.dll", CharSet = CharSet.Unicode)]
+    static extern int CM_Get_Device_ID_List_Size(out int idListlen, string? filter, int ulFlags);
+
+    [DllImport("setupapi.dll", CharSet = CharSet.Unicode)]
+    static extern int CM_Get_Device_ID_List(string? filter, char[] bffr, int bffrLen, int ulFlags);
+
+    [DllImport("CfgMgr32.dll", CharSet = CharSet.Unicode)]
+    static extern int CM_Get_DevNode_Property(IntPtr devInst, ref DEVPROPKEY propertyKey, out int propertyType, char[]? bffr, ref int bffrLen, int flags);
+
+    [DllImport("setupapi.dll")]
+    static extern int CM_Free_Res_Des_Handle(IntPtr rdResDes);
+
+    [DllImport("setupapi.dll")]
+    static extern int CM_Get_First_Log_Conf(out IntPtr rdResDes, IntPtr pdnDevInst, int ulFlags);
+
+    [DllImport("setupapi.dll")]
+    static extern int CM_Get_Next_Res_Des(out IntPtr newResDes, IntPtr rdResDes, int resType, out int resourceID, int ulFlags);
+
+    [DllImport("setupapi.dll")]
+    static extern int CM_Get_Res_Des_Data_Size(out int size, IntPtr rdResDes, int ulFlags);
+
+    [DllImport("setupapi.dll")]
+    static extern int CM_Get_Res_Des_Data(IntPtr rdResDes, IntPtr buffer, int size, int ulFlags);
+
     #endregion
 
     #region events
diff --git a/HandheldCompanion/Managers/HotkeysManager.cs b/HandheldCompanion/Managers/HotkeysManager.cs
index 2a70bcb72..453b37c75 100644
--- a/HandheldCompanion/Managers/HotkeysManager.cs
+++ b/HandheldCompanion/Managers/HotkeysManager.cs
@@ -239,7 +239,7 @@ public static void SerializeHotkey(Hotkey hotkey, bool overwrite = false)
         if (!File.Exists(settingsPath) || overwrite)
         {
             var jsonString = JsonConvert.SerializeObject(hotkey, Formatting.Indented);
-            if (CommonUtils.IsFileWritable(settingsPath))
+            if (FileUtils.IsFileWritable(settingsPath))
                 File.WriteAllText(settingsPath, jsonString);
         }
 
diff --git a/HandheldCompanion/Managers/LayoutManager.cs b/HandheldCompanion/Managers/LayoutManager.cs
index ce5b2efa2..793e8edf8 100644
--- a/HandheldCompanion/Managers/LayoutManager.cs
+++ b/HandheldCompanion/Managers/LayoutManager.cs
@@ -9,6 +9,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Numerics;
 using System.Threading.Tasks;
 using System.Windows;
 
@@ -218,7 +219,7 @@ public static void SerializeLayout(Layout layout, string fileName)
         });
 
         fileName = Path.Combine(LayoutsPath, $"{fileName}.json");
-        if (CommonUtils.IsFileWritable(fileName))
+        if (FileUtils.IsFileWritable(fileName))
             File.WriteAllText(fileName, jsonString);
     }
 
@@ -230,7 +231,7 @@ public static void SerializeLayoutTemplate(LayoutTemplate layoutTemplate)
         });
 
         string fileName = Path.Combine(TemplatesPath, $"{layoutTemplate.Name}_{layoutTemplate.Author}.json");
-        if (CommonUtils.IsFileWritable(fileName))
+        if (FileUtils.IsFileWritable(fileName))
             File.WriteAllText(fileName, jsonString);
     }
 
@@ -455,15 +456,22 @@ public static ControllerState MapController(ControllerState controllerState)
                         AxisActions aAction = action as AxisActions;
                         aAction.Execute(InLayout);
 
-                        // read output axis
+                        // Read output axis
                         AxisLayout OutLayout = AxisLayout.Layouts[aAction.Axis];
                         AxisFlags OutAxisX = OutLayout.GetAxisFlags('X');
                         AxisFlags OutAxisY = OutLayout.GetAxisFlags('Y');
 
-                        outputState.AxisState[OutAxisX] =
-                            (short)Math.Clamp(outputState.AxisState[OutAxisX] + aAction.GetValue().X, short.MinValue, short.MaxValue);
-                        outputState.AxisState[OutAxisY] =
-                            (short)Math.Clamp(outputState.AxisState[OutAxisY] + aAction.GetValue().Y, short.MinValue, short.MaxValue);
+                        Vector2 joystick = new Vector2(outputState.AxisState[OutAxisX], outputState.AxisState[OutAxisY]);
+
+                        // Reduce motion weight based on joystick position
+                        // Get the distance of the joystick from the center
+                        float joystickLength = Math.Clamp(joystick.Length() / short.MaxValue, 0, 1);
+                        float weightFactor = aAction.gyroWeight - joystickLength;
+                        Vector2 result = joystick + aAction.GetValue() * weightFactor;
+
+                        // Apply clamping to the result to stay in range of joystick
+                        outputState.AxisState[OutAxisX] = (short)Math.Clamp(result.X, short.MinValue, short.MaxValue);
+                        outputState.AxisState[OutAxisY] = (short)Math.Clamp(result.Y, short.MinValue, short.MaxValue);
                     }
                     break;
 
diff --git a/HandheldCompanion/Managers/PerformanceManager.cs b/HandheldCompanion/Managers/PerformanceManager.cs
index 365aada60..1c2608213 100644
--- a/HandheldCompanion/Managers/PerformanceManager.cs
+++ b/HandheldCompanion/Managers/PerformanceManager.cs
@@ -57,6 +57,7 @@ public class PerformanceManager : Manager
     private bool AutoTDPFirstRun = true;
     private int AutoTDPFPSSetpointMetCounter;
     private int AutoTDPFPSSmallDipCounter;
+    private double AutoTDPMax;
     private double TDPMax;
     private double TDPMin;
     private int AutoTDPProcessId;
@@ -127,6 +128,7 @@ private void SettingsManagerOnSettingValueChanged(string name, object value)
             case "ConfigurableTDPOverrideUp":
                 {
                     TDPMax = Convert.ToDouble(value);
+                    if (AutoTDPMax == 0d) AutoTDPMax = TDPMax;
                     AutoTDP = (TDPMax + TDPMin) / 2.0d;
                 }
                 break;
@@ -138,16 +140,35 @@ private void ProfileManager_Applied(Profile profile, ProfileUpdateSource source)
         // apply profile defined TDP
         if (profile.TDPOverrideEnabled && profile.TDPOverrideValues is not null)
         {
-            RequestTDP(profile.TDPOverrideValues);
-            StartTDPWatchdog();
+            if (!profile.AutoTDPEnabled)
+            {
+                // Manual TDP is set, use it and set max limit
+                RequestTDP(profile.TDPOverrideValues);
+                StartTDPWatchdog();
+                AutoTDPMax = SettingsManager.GetInt("ConfigurableTDPOverrideUp");
+            }
+            else
+            {
+                // Both manual TDP and AutoTDP are on,
+                // use manual slider as the max limit for AutoTDP
+                AutoTDPMax = profile.TDPOverrideValues[0];
+                StopTDPWatchdog(true);
+            }
         }
         else if (cpuWatchdog.Enabled)
         {
             StopTDPWatchdog(true);
 
-            // restore default TDP (if not AutoTDP is enabled)
             if (!profile.AutoTDPEnabled)
+            {
+                // Neither manual TDP nor AutoTDP is enabled, restore default TDP
                 RestoreTDP(true);
+            }
+            else
+            {
+                // AutoTDP is enabled but manual override is not, use the settings max limit
+                AutoTDPMax = SettingsManager.GetInt("ConfigurableTDPOverrideUp");
+            }
         }
 
         // apply profile defined AutoTDP
@@ -321,7 +342,7 @@ private void AutoTDPWatchdog_Elapsed(object? sender, ElapsedEventArgs e)
             else
                 AutoTDPFirstRun = false;
 
-            AutoTDP = Math.Clamp(AutoTDP, TDPMin, TDPMax);
+            AutoTDP = Math.Clamp(AutoTDP, TDPMin, AutoTDPMax);
 
             // Only update if we have a different TDP value to set
             if (AutoTDP != AutoTDPPrev)
diff --git a/HandheldCompanion/Managers/PlatformManager.cs b/HandheldCompanion/Managers/PlatformManager.cs
index 817e763ef..b1077ca8d 100644
--- a/HandheldCompanion/Managers/PlatformManager.cs
+++ b/HandheldCompanion/Managers/PlatformManager.cs
@@ -11,13 +11,14 @@ public static class PlatformManager
     private const int UpdateInterval = 1000;
 
     // gaming platforms
-    private static readonly SteamPlatform Steam = new();
-    private static readonly GOGGalaxy GOGGalaxy = new();
-    private static readonly UbisoftConnect UbisoftConnect = new();
+    public static readonly SteamPlatform Steam = new();
+    public static readonly GOGGalaxy GOGGalaxy = new();
+    public static readonly UbisoftConnect UbisoftConnect = new();
 
     // misc platforms
     public static RTSS RTSS = new();
     public static HWiNFO HWiNFO = new();
+
     private static Timer UpdateTimer;
 
     private static bool IsInitialized;
@@ -25,6 +26,9 @@ public static class PlatformManager
     private static PlatformNeeds CurrentNeeds = PlatformNeeds.None;
     private static PlatformNeeds PreviousNeeds = PlatformNeeds.None;
 
+    public static event InitializedEventHandler Initialized;
+    public delegate void InitializedEventHandler();
+
     public static void Start()
     {
         if (Steam.IsInstalled)
@@ -60,6 +64,7 @@ public static void Start()
         UpdateTimer.Elapsed += (sender, e) => MonitorPlatforms();
 
         IsInitialized = true;
+        Initialized?.Invoke();
 
         LogManager.LogInformation("{0} has started", "PlatformManager");
     }
@@ -139,9 +144,8 @@ private static void MonitorPlatforms()
                 // Only start RTSS if it was not running before and if it is installed
                 if (RTSS.IsInstalled)
                 {
-                    // Start and enable OSD
+                    // Start RTSS
                     RTSS.Start();
-                    RTSS.SetEnableOSD(true);
                 }
             if (CurrentNeeds.HasFlag(PlatformNeeds.OnScreenDisplayComplex))
             {
@@ -176,9 +180,6 @@ private static void MonitorPlatforms()
             if (PreviousNeeds.HasFlag(PlatformNeeds.OnScreenDisplay))
                 if (HWiNFO.IsInstalled)
                     HWiNFO.Stop(true);
-
-            // Disable OSD
-            RTSS.SetEnableOSD(false);
         }
         else
         {
@@ -190,8 +191,7 @@ private static void MonitorPlatforms()
                 if (HWiNFO.IsInstalled) HWiNFO.Stop(true);
                 if (RTSS.IsInstalled)
                 {
-                    // Disable OSD
-                    RTSS.SetEnableOSD(false);
+                    // Stop RTSS
                     RTSS.Stop();
                 }
             }
diff --git a/HandheldCompanion/Managers/ProfileManager.cs b/HandheldCompanion/Managers/ProfileManager.cs
index 7b3151d91..f704d88b4 100644
--- a/HandheldCompanion/Managers/ProfileManager.cs
+++ b/HandheldCompanion/Managers/ProfileManager.cs
@@ -369,7 +369,7 @@ public static void DeleteProfile(Profile profile)
                 ApplyProfile(GetDefault());
         }
 
-        File.Delete(profilePath);
+        FileUtils.FileDelete(profilePath);
     }
 
     public static void SerializeProfile(Profile profile)
@@ -387,7 +387,7 @@ public static void SerializeProfile(Profile profile)
 
         try
         {
-            if (CommonUtils.IsFileWritable(profilePath))
+            if (FileUtils.IsFileWritable(profilePath))
                 File.WriteAllText(profilePath, jsonString);
         }
         catch { }
@@ -411,7 +411,7 @@ private static void SanitizeProfile(Profile profile)
             if (!File.Exists(profile.Path))
                 profile.ErrorCode |= ProfileErrorCode.MissingExecutable;
 
-            if (!CommonUtils.IsDirectoryWritable(processpath))
+            if (!FileUtils.IsDirectoryWritable(processpath))
                 profile.ErrorCode |= ProfileErrorCode.MissingPermission;
 
             if (ProcessManager.GetProcesses(profile.Executable).Capacity > 0)
@@ -441,6 +441,13 @@ public static void UpdateOrCreateProfile(Profile profile,
         // refresh error code
         SanitizeProfile(profile);
 
+        // used to get and store a few previous values
+        XInputPlusMethod prevWrapper = XInputPlusMethod.Disabled;
+        if (profiles.TryGetValue(profile.Path, out Profile prevProfile))
+        {
+            prevWrapper = prevProfile.XInputPlus;
+        }
+
         // update database
         profiles[profile.Path] = profile;
 
@@ -450,46 +457,50 @@ public static void UpdateOrCreateProfile(Profile profile,
         if (source == ProfileUpdateSource.Serializer)
             return;
 
-        // serialize profile
-        SerializeProfile(profile);
+        // do not update wrapper and cloaking from default profile
+        if (!profile.Default)
+        {
+            // update wrapper
+            if (!UpdateProfileWrapper(profile))
+            {
+                // restore previous XInputPlus mode if failed to update
+                profile.XInputPlus = prevWrapper;
+                source = ProfileUpdateSource.Background;
+            }
+
+            // update cloaking
+            UpdateProfileCloaking(profile);
+        }
 
         // apply profile (silently)
         if (isCurrent)
             ApplyProfile(profile, source);
 
-        // do not update wrapper and cloaking from default profile
-        if (profile.Default)
-            return;
-
-        // update wrapper
-        UpdateProfileWrapper(profile);
-
-        // update cloaking
-        UpdateProfileCloaking(profile);
+        // serialize profile
+        SerializeProfile(profile);
     }
 
-    public static void UpdateProfileCloaking(Profile profile)
+    public static bool UpdateProfileCloaking(Profile profile)
     {
         switch (profile.ErrorCode)
         {
             case ProfileErrorCode.MissingExecutable:
             case ProfileErrorCode.MissingPath:
             case ProfileErrorCode.Default:
-                return;
+                return false;
         }
 
         switch (profile.Whitelisted)
         {
             case true:
-                HidHide.RegisterApplication(profile.Path);
-                break;
+                return HidHide.RegisterApplication(profile.Path);
+            default:
             case false:
-                HidHide.UnregisterApplication(profile.Path);
-                break;
+                return HidHide.UnregisterApplication(profile.Path);
         }
     }
 
-    public static void UpdateProfileWrapper(Profile profile)
+    public static bool UpdateProfileWrapper(Profile profile)
     {
         switch (profile.ErrorCode)
         {
@@ -497,18 +508,17 @@ public static void UpdateProfileWrapper(Profile profile)
             case ProfileErrorCode.MissingPath:
             case ProfileErrorCode.Running:
             case ProfileErrorCode.Default:
-                return;
+                return false;
         }
 
         switch (profile.XInputPlus)
         {
             case XInputPlusMethod.Redirection:
-                XInputPlus.RegisterApplication(profile);
-                break;
+                return XInputPlus.RegisterApplication(profile);
+            default:
             case XInputPlusMethod.Disabled:
             case XInputPlusMethod.Injection:
-                XInputPlus.UnregisterApplication(profile);
-                break;
+                return XInputPlus.UnregisterApplication(profile);
         }
     }
 
diff --git a/HandheldCompanion/Misc/HidHide.cs b/HandheldCompanion/Misc/HidHide.cs
index 5f16e855f..ad2db0b4a 100644
--- a/HandheldCompanion/Misc/HidHide.cs
+++ b/HandheldCompanion/Misc/HidHide.cs
@@ -89,7 +89,7 @@ public static bool IsRegistered(string InstanceId)
         return false;
     }
 
-    public static void UnregisterApplication(string fileName)
+    public static bool UnregisterApplication(string fileName)
     {
         try
         {
@@ -103,7 +103,7 @@ public static void UnregisterApplication(string fileName)
         catch
         {
             if (process is null)
-                return;
+                return false;
 
             process.StartInfo.Arguments = $"--app-unreg \"{fileName}\"";
             process.Start();
@@ -112,9 +112,11 @@ public static void UnregisterApplication(string fileName)
 
             LogManager.LogInformation("HideDevice RemoveApplicationPath: {0}", fileName);
         }
+
+        return true;
     }
 
-    public static void RegisterApplication(string fileName)
+    public static bool RegisterApplication(string fileName)
     {
         try
         {
@@ -128,7 +130,7 @@ public static void RegisterApplication(string fileName)
         catch
         {
             if (process is null)
-                return;
+                return false;
 
             process.StartInfo.Arguments = $"--app-reg \"{fileName}\"";
             process.Start();
@@ -137,6 +139,8 @@ public static void RegisterApplication(string fileName)
 
             LogManager.LogInformation("HideDevice AddApplicationPath: {0}", fileName);
         }
+
+        return true;
     }
 
     public static void SetCloaking(bool status)
@@ -197,7 +201,8 @@ public static List<HidHideDevice> GetHidHideDevices()
             if (process is null)
                 return null;
 
-            process.StartInfo.Arguments = $"--dev-gaming";
+            // using --dev-gaming sometimes doesn't report controllers or have empty BaseContainerDeviceInstancePath
+            process.StartInfo.Arguments = $"--dev-all";
             process.Start();
             process.WaitForExit(TimeSpan.FromSeconds(3));
             string jsonString = process.StandardOutput.ReadToEnd().Trim();
diff --git a/HandheldCompanion/Misc/PnPDetails.cs b/HandheldCompanion/Misc/PnPDetails.cs
index 14e6d23bf..0bcd30082 100644
--- a/HandheldCompanion/Misc/PnPDetails.cs
+++ b/HandheldCompanion/Misc/PnPDetails.cs
@@ -29,7 +29,7 @@ public class PnPDetails : IDisposable
 
     // XInput
     public bool isXInput;
-    public byte XInputUserIndex;
+    public byte XInputUserIndex = byte.MaxValue;
 
     public void Dispose()
     {
diff --git a/HandheldCompanion/Platforms/GOGGalaxy.cs b/HandheldCompanion/Platforms/GOGGalaxy.cs
index 693b0223f..4b6123829 100644
--- a/HandheldCompanion/Platforms/GOGGalaxy.cs
+++ b/HandheldCompanion/Platforms/GOGGalaxy.cs
@@ -11,7 +11,7 @@ public class GOGGalaxy : IPlatform
     public GOGGalaxy()
     {
         Name = "GOG Galaxy";
-        ExecutableName = "GalaxyClient.exe";
+        ExecutableName = RunningName = "GalaxyClient.exe";
 
         // store specific modules
         Modules = new List<string>
@@ -42,7 +42,7 @@ public override bool StartProcess()
         if (!IsInstalled)
             return false;
 
-        if (IsRunning())
+        if (IsRunning)
             return false;
 
         var process = Process.Start(new ProcessStartInfo
@@ -61,7 +61,7 @@ public override bool StopProcess()
         if (!IsInstalled)
             return false;
 
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         KillProcess();
diff --git a/HandheldCompanion/Platforms/HWiNFO.cs b/HandheldCompanion/Platforms/HWiNFO.cs
index e21c46ed6..bfc1806c9 100644
--- a/HandheldCompanion/Platforms/HWiNFO.cs
+++ b/HandheldCompanion/Platforms/HWiNFO.cs
@@ -63,7 +63,7 @@ public HWiNFO()
         Url = "https://www.hwinfo.com/files/hwi_742.exe";
 
         Name = "HWiNFO64";
-        ExecutableName = "HWiNFO64.exe";
+        ExecutableName = RunningName = "HWiNFO64.exe";
 
         // check if platform is installed
         InstallPath = RegistryUtils.GetString(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\HWiNFO64_is1",
@@ -117,7 +117,7 @@ public override bool Start()
     {
         // start HWiNFO if not running or Shared Memory is disabled
         var hasSensorsSM = GetProperty("SensorsSM");
-        if (!IsRunning() || !hasSensorsSM)
+        if (!IsRunning || !hasSensorsSM)
         {
             StopProcess();
             StartProcess();
@@ -490,7 +490,7 @@ public override bool StartProcess()
         if (!IsInstalled)
             return false;
 
-        if (IsRunning())
+        if (IsRunning)
             KillProcess();
 
         // (re)set elements
diff --git a/HandheldCompanion/Platforms/IPlatform.cs b/HandheldCompanion/Platforms/IPlatform.cs
index 39cab25ce..5a52dfa03 100644
--- a/HandheldCompanion/Platforms/IPlatform.cs
+++ b/HandheldCompanion/Platforms/IPlatform.cs
@@ -29,7 +29,9 @@ public enum PlatformStatus
     Ready = 1,
     Started = 2,
     Stopped = 3,
-    Stalled = 4
+    Stalled = 4,
+    Starting = 5,
+    Stopping = 6,
 }
 
 public abstract class IPlatform : IDisposable
@@ -40,6 +42,7 @@ public abstract class IPlatform : IDisposable
 
     private Process _Process;
     protected string ExecutableName;
+    protected string RunningName;
     protected string ExecutablePath;
     protected Version ExpectedVersion;
 
@@ -70,13 +73,15 @@ protected Process Process
                 if (_Process is not null)
                     return _Process;
 
-                var processes = Process.GetProcessesByName(Name);
+                var processes = ProcessUtils.GetProcessesByExecutable(RunningName);
                 if (processes.Length == 0)
                     return null;
 
                 _Process = processes.FirstOrDefault();
                 _Process.EnableRaisingEvents = true;
 
+                SetStatus(PlatformStatus.Started);
+
                 _Process.Exited += _Process_Exited;
 
                 return _Process;
@@ -96,15 +101,34 @@ public bool IsInstalled
         {
             _IsInstalled = value;
 
+            // raise event
             if (value)
-                // raise event
                 SetStatus(PlatformStatus.Ready);
             else
-                // raise event
                 SetStatus(PlatformStatus.Stalled);
         }
     }
 
+    public bool IsRunning
+    {
+        get
+        {
+            try
+            {
+                if (Process is null)
+                    return false;
+
+                SetStatus(PlatformStatus.Started);
+                return !Process.HasExited;
+            }
+            catch
+            {
+            }
+
+            return false;
+        }
+    }
+
     public bool HasModules
     {
         get
@@ -134,12 +158,16 @@ private void _Process_Exited(object sender, EventArgs e)
         if (_Process is null)
             return;
 
-        _Process.Dispose();
+        SetStatus(PlatformStatus.Stopped);
+
         _Process = null;
     }
 
     protected void SetStatus(PlatformStatus status)
     {
+        if (Status == status)
+            return;
+
         Status = status;
         Updated?.Invoke(status);
     }
@@ -182,22 +210,6 @@ public virtual bool IsRelated(Process proc)
         return false;
     }
 
-    public virtual bool IsRunning()
-    {
-        try
-        {
-            if (Process is null)
-                return false;
-
-            return !Process.HasExited;
-        }
-        catch
-        {
-        }
-
-        return false;
-    }
-
     public virtual bool Start()
     {
         KeepAlive = true;
@@ -206,9 +218,6 @@ public virtual bool Start()
         if (PlatformWatchdog is not null)
             PlatformWatchdog.Start();
 
-        // raise event
-        SetStatus(PlatformStatus.Started);
-
         return true;
     }
 
@@ -216,6 +225,9 @@ public virtual bool Stop(bool kill = false)
     {
         KeepAlive = false;
 
+        // raise event
+        SetStatus(PlatformStatus.Stopping);
+
         // stop watchdog
         if (PlatformWatchdog is not null)
             PlatformWatchdog.Stop();
@@ -223,9 +235,6 @@ public virtual bool Stop(bool kill = false)
         if (kill)
             KillProcess();
 
-        // raise event
-        SetStatus(PlatformStatus.Stopped);
-
         return true;
     }
 
@@ -268,6 +277,9 @@ public virtual bool StartProcess()
 
                 LogManager.LogDebug("Starting {0}, tentative: {1}/{2}", GetType(), Tentative, MaxTentative);
 
+                // raise event
+                SetStatus(PlatformStatus.Starting);
+
                 process = Process.Start(new ProcessStartInfo
                 {
                     FileName = ExecutablePath,
@@ -317,6 +329,10 @@ public bool KillProcess()
         try
         {
             Process.Kill();
+
+            // raise event
+            SetStatus(PlatformStatus.Stopped);
+
             return true;
         }
         catch
@@ -394,7 +410,7 @@ public bool OverwriteFile(string FilePath, byte[] content, bool backup)
         try
         {
             var configPath = Path.Combine(InstallPath, FilePath);
-            if (!CommonUtils.IsFileWritable(configPath))
+            if (!FileUtils.IsFileWritable(configPath))
                 return false;
 
             // file has already been overwritten
@@ -433,7 +449,6 @@ public bool OverwriteFile(string FilePath, byte[] content, bool backup)
     #region events
 
     public event StartedEventHandler Updated;
-
     public delegate void StartedEventHandler(PlatformStatus status);
 
     #endregion
diff --git a/HandheldCompanion/Platforms/RTSS.cs b/HandheldCompanion/Platforms/RTSS.cs
index 7c650b0a3..e4527c845 100644
--- a/HandheldCompanion/Platforms/RTSS.cs
+++ b/HandheldCompanion/Platforms/RTSS.cs
@@ -55,7 +55,7 @@ public RTSS()
         Url = "https://www.guru3d.com/files-details/rtss-rivatuner-statistics-server-download.html";
 
         Name = "RTSS";
-        ExecutableName = "RTSS.exe";
+        ExecutableName = RunningName = "RTSS.exe";
 
         // store specific modules
         Modules = new List<string>
@@ -111,7 +111,7 @@ public RTSS()
     public override bool Start()
     {
         // start RTSS if not running
-        if (!IsRunning())
+        if (!IsRunning)
             StartProcess();
         else
             // hook into current process
@@ -228,6 +228,9 @@ private void Watchdog_Elapsed(object? sender, ElapsedEventArgs e)
             if (GetTargetFPS() != RequestedFramerate)
                 SetTargetFPS(RequestedFramerate);
 
+            if (GetEnableOSD() != true)
+                SetEnableOSD(true);
+
             Monitor.Exit(updateLock);
         }
     }
@@ -323,9 +326,33 @@ public uint EnableFlag(uint flag, bool status)
         return current;
     }
 
+    public bool GetEnableOSD()
+    {
+        if (!IsRunning)
+            return false;
+
+        try
+        {
+            // load default profile
+            if (!ProfileLoaded)
+            {
+                LoadProfile();
+                ProfileLoaded = true;
+            }
+
+            if (GetProfileProperty("EnableOSD", out int enabled))
+                return Convert.ToBoolean(enabled);
+        }
+        catch
+        {
+        }
+
+        return false;
+    }
+
     public bool SetEnableOSD(bool enable)
     {
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         try
@@ -353,7 +380,7 @@ public bool SetEnableOSD(bool enable)
 
     private bool SetTargetFPS(int Limit)
     {
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         try
@@ -393,7 +420,7 @@ private bool SetTargetFPS(int Limit)
 
     private int GetTargetFPS()
     {
-        if (!IsRunning())
+        if (!IsRunning)
             return 0;
 
         try
@@ -437,7 +464,7 @@ public override bool StartProcess()
         if (!IsInstalled)
             return false;
 
-        if (IsRunning())
+        if (IsRunning)
             KillProcess();
 
         return base.StartProcess();
@@ -449,7 +476,7 @@ public override bool StopProcess()
             return false;
         if (!IsInstalled)
             return false;
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         KillProcess();
diff --git a/HandheldCompanion/Platforms/SteamPlatform.cs b/HandheldCompanion/Platforms/SteamPlatform.cs
index 43944a697..e3dd41205 100644
--- a/HandheldCompanion/Platforms/SteamPlatform.cs
+++ b/HandheldCompanion/Platforms/SteamPlatform.cs
@@ -2,11 +2,14 @@
 using HandheldCompanion.Managers;
 using HandheldCompanion.Properties;
 using HandheldCompanion.Utils;
+using Nefarius.Utilities.DeviceManagement.Drivers;
+using Nefarius.Utilities.DeviceManagement.PnP;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
@@ -14,7 +17,7 @@ namespace HandheldCompanion.Platforms;
 
 public class SteamPlatform : IPlatform
 {
-    private string RunningName;
+    public bool IsControllerDriverInstalled;
 
     private static readonly Regex ControllerBlacklistRegex =
         new("^(\\s*\"controller_blacklist\"\\s*\")([^\"]*)(\"\\s*)$");
@@ -32,8 +35,6 @@ public SteamPlatform()
 
         Name = "Steam";
         ExecutableName = "steam.exe";
-
-        // this is for detecting steam start/stop, for some reason steam.exe often doesn't work
         RunningName = "steamwebhelper.exe";
 
         // store specific modules
@@ -58,21 +59,61 @@ public SteamPlatform()
             // check executable
             IsInstalled = File.Exists(ExecutablePath);
         }
+
+        IsControllerDriverInstalled = HasXboxDriversInstalled();
     }
 
-    public void Start()
+    public override bool Start()
     {
+        // hook into current process
+        if (IsRunning)
+            Process.Exited += Process_Exited;
+
         ProcessManager.ProcessStarted += ProcessManager_ProcessStarted;
-        ProcessManager.ProcessStopped += ProcessManager_ProcessStopped;
+
+        return base.Start();
     }
 
-    public void Stop()
+    public override bool Stop(bool kill = false)
     {
         ProcessManager.ProcessStarted -= ProcessManager_ProcessStarted;
-        ProcessManager.ProcessStopped -= ProcessManager_ProcessStopped;
 
         // restore files even if Steam is still running
         RestoreFiles();
+        
+        return base.Stop();
+    }
+
+    protected override void Process_Exited(object? sender, EventArgs e)
+    {
+        LogManager.LogDebug("Steam stopped, restoring files");
+        RestoreFiles();
+    }
+
+    public bool HasXboxDriversInstalled()
+    {
+        return FilterDrivers
+            .GetDeviceClassUpperFilters(DeviceClassIds.XnaComposite)
+            .Any(f => f.Equals("steamxbox"));
+
+        return RegistryUtils.SearchForKeyValue(@"SYSTEM\CurrentControlSet\Enum\ROOT\SYSTEM", "Service", "steamxbox");
+    }
+
+    public bool HasDesktopProfileApplied()
+    {
+        string filePath = ControllerFiles.Keys.FirstOrDefault();
+        string configPath = Path.Combine(InstallPath, filePath);
+
+        if (!File.Exists(configPath))
+            return false;
+
+        string configText = File.ReadAllText(configPath);
+        string fileText = Encoding.UTF8.GetString(Resources.empty_neptune, 0, Resources.empty_neptune.Length);
+
+        if (!configText.Equals(fileText, StringComparison.InvariantCultureIgnoreCase))
+            return true;
+
+        return false;
     }
 
     private void ReplaceFiles()
@@ -93,18 +134,11 @@ private async void ProcessManager_ProcessStarted(ProcessEx processEx, bool OnSta
     {
         if (!OnStartup && processEx.Executable == RunningName)
         {
-            LogManager.LogDebug("Steam started, replacing files in 3 seconds");
             await Task.Delay(3000);
             ReplaceFiles();
-        }
-    }
 
-    private void ProcessManager_ProcessStopped(ProcessEx processEx)
-    {
-        if (processEx.Executable == RunningName)
-        {
-            LogManager.LogDebug("Steam stopped, restoring files");
-            RestoreFiles();
+            // hook into current process
+            Process.Exited += Process_Exited;
         }
     }
 
@@ -142,10 +176,10 @@ private void ProcessManager_ProcessStopped(ProcessEx processEx)
 
     public bool UpdateControllerBlacklist(ushort vendorId, ushort productId, bool add)
     {
-        if (IsRunning())
+        if (IsRunning)
             return false;
 
-        if (!CommonUtils.IsFileWritable(SettingsPath))
+        if (!FileUtils.IsFileWritable(SettingsPath))
             return false;
 
         try
@@ -213,7 +247,7 @@ public override bool StartProcess()
         if (!IsInstalled)
             return false;
 
-        if (IsRunning())
+        if (IsRunning)
             return false;
 
         var process = Process.Start(new ProcessStartInfo
@@ -233,7 +267,7 @@ public override bool StopProcess()
         if (!IsInstalled)
             return false;
 
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         var process = Process.Start(new ProcessStartInfo
diff --git a/HandheldCompanion/Platforms/UbisoftConnect.cs b/HandheldCompanion/Platforms/UbisoftConnect.cs
index 912a84467..39e378233 100644
--- a/HandheldCompanion/Platforms/UbisoftConnect.cs
+++ b/HandheldCompanion/Platforms/UbisoftConnect.cs
@@ -13,7 +13,7 @@ public UbisoftConnect()
         PlatformType = PlatformType.UbisoftConnect;
 
         Name = "Ubisoft Connect";
-        ExecutableName = "UbisoftConnect.exe";
+        ExecutableName = RunningName = "UbisoftConnect.exe";
 
         // store specific modules
         Modules = new List<string>
@@ -45,7 +45,7 @@ public override bool StartProcess()
         if (!IsInstalled)
             return false;
 
-        if (IsRunning())
+        if (IsRunning)
             return false;
 
         var process = Process.Start(new ProcessStartInfo
@@ -64,7 +64,7 @@ public override bool StopProcess()
         if (!IsInstalled)
             return false;
 
-        if (!IsRunning())
+        if (!IsRunning)
             return false;
 
         KillProcess();
diff --git a/HandheldCompanion/Processors/AMDProcessor.cs b/HandheldCompanion/Processors/AMDProcessor.cs
index bb0f530d6..219244746 100644
--- a/HandheldCompanion/Processors/AMDProcessor.cs
+++ b/HandheldCompanion/Processors/AMDProcessor.cs
@@ -1,4 +1,6 @@
-using HandheldCompanion.Processors.AMD;
+using HandheldCompanion.Helpers;
+using HandheldCompanion.Processors.AMD;
+using HandheldCompanion.Views;
 using System;
 using System.Threading;
 using System.Timers;
@@ -21,7 +23,6 @@ public AMDProcessor()
         else
         {
             family = RyzenAdj.get_cpu_family(ry);
-            IsInitialized = true;
 
             switch (family)
             {
@@ -37,6 +38,9 @@ public AMDProcessor()
                 case RyzenFamily.FAM_PHEONIX:
                     CanChangeGPU = true;
                     break;
+                case RyzenFamily.FAM_VANGOGH:
+                    CanChangeGPU = VangoghGPU.Detect() == VangoghGPU.DetectionStatus.Detected;
+                    break;
             }
 
             switch (family)
@@ -58,6 +62,8 @@ public AMDProcessor()
                     CanChangeTDP = true;
                     break;
             }
+
+            IsInitialized = true;
         }
 
         foreach (var type in (PowerType[])Enum.GetValues(typeof(PowerType)))
@@ -167,18 +173,55 @@ public override void SetGPUClock(double clock, int result)
     {
         if (Monitor.TryEnter(IsBusy))
         {
-            // reset default var
-            if (clock == 12750)
+            switch(family)
             {
-                Monitor.Exit(IsBusy);
-                return;
-            }
-
-            var error1 = RyzenAdj.set_gfx_clk(ry, (uint)clock);
-            var error2 = RyzenAdj.set_min_gfxclk_freq(ry, (uint)clock);
-            var error3 = RyzenAdj.set_max_gfxclk_freq(ry, (uint)clock);
+                case RyzenFamily.FAM_VANGOGH:
+                    {
+                        using (var sd = VangoghGPU.Open())
+                        {
+                            if (sd is null)
+                            {
+                                base.SetGPUClock(clock, 1);
+                                return;
+                            }
+
+                            if (clock == 12750)
+                            {
+                                sd.HardMinGfxClock = (uint)MainWindow.CurrentDevice.GfxClock[0]; //hardMin
+                                sd.SoftMaxGfxClock = (uint)MainWindow.CurrentDevice.GfxClock[1]; //softMax
+                            }
+                            else
+                            {
+                                sd.HardMinGfxClock = (uint)clock; //hardMin
+                                sd.SoftMaxGfxClock = (uint)clock; //softMax
+                            }
+
+                            base.SetGPUClock(clock, 0);
+                        }
+                    }
+                    break;
 
-            base.SetGPUClock(clock, error1 + error2 + error3);
+                default:
+                    {
+                        int error1, error2, error3;
+
+                        if (clock == 12750)
+                        {
+                            error1 = RyzenAdj.set_gfx_clk(ry, (uint)clock);
+                            error2 = RyzenAdj.set_min_gfxclk_freq(ry, (uint)MainWindow.CurrentDevice.GfxClock[0]);
+                            error3 = RyzenAdj.set_max_gfxclk_freq(ry, (uint)MainWindow.CurrentDevice.GfxClock[1]);
+                        }
+                        else
+                        {
+                            error1 = RyzenAdj.set_gfx_clk(ry, (uint)clock);
+                            error2 = RyzenAdj.set_min_gfxclk_freq(ry, (uint)clock);
+                            error3 = RyzenAdj.set_max_gfxclk_freq(ry, (uint)clock);
+                        }
+
+                        base.SetGPUClock(clock, error1 + error2 + error3);
+                    }
+                    break;
+            }
 
             Monitor.Exit(IsBusy);
         }
diff --git a/HandheldCompanion/Properties/Resources.Designer.cs b/HandheldCompanion/Properties/Resources.Designer.cs
index d351a1160..556e0310d 100644
--- a/HandheldCompanion/Properties/Resources.Designer.cs
+++ b/HandheldCompanion/Properties/Resources.Designer.cs
@@ -673,6 +673,60 @@ public static string ControllerPage_SteamControllerSettings {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to You should restart Steam, so that Handheld Companion can automatically adjust Steam Desktop Layout and prevent double input..
+        /// </summary>
+        public static string ControllerPage_SteamNeptuneDesktopAction {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamNeptuneDesktopAction", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to It appears that Steam is already running and Steam Desktop Layout is applied. This may result in double input..
+        /// </summary>
+        public static string ControllerPage_SteamNeptuneDesktopDesc {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamNeptuneDesktopDesc", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Steam Desktop Layout is applied.
+        /// </summary>
+        public static string ControllerPage_SteamNeptuneDesktopWarning {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamNeptuneDesktopWarning", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to You might want to uninstall Steam Xbox Controller Enhanced Features Driver.
+        /// </summary>
+        public static string ControllerPage_SteamXboxDriversAction {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamXboxDriversAction", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to It appears you have installed Steam Xbox Controller Enhanced Features Driver which are breaking HidHide capacities to hide/unhide your physical controller.
+        /// </summary>
+        public static string ControllerPage_SteamXboxDriversDesc {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamXboxDriversDesc", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Steam Xbox Controller Enhanced Features Driver is installed.
+        /// </summary>
+        public static string ControllerPage_SteamXboxDriversWarning {
+            get {
+                return ResourceManager.GetString("ControllerPage_SteamXboxDriversWarning", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Unhide controller on close.
         /// </summary>
diff --git a/HandheldCompanion/Properties/Resources.resx b/HandheldCompanion/Properties/Resources.resx
index 53b2e6c7d..d6f59b9ac 100644
--- a/HandheldCompanion/Properties/Resources.resx
+++ b/HandheldCompanion/Properties/Resources.resx
@@ -2327,4 +2327,22 @@ with motion input enabled, use selected button(s) to disable motion.</value>
   <data name="MainWindow_Select" xml:space="preserve">
     <value>Select</value>
   </data>
+  <data name="ControllerPage_SteamNeptuneDesktopAction" xml:space="preserve">
+    <value>You should restart Steam, so that Handheld Companion can automatically adjust Steam Desktop Layout and prevent double input.</value>
+  </data>
+  <data name="ControllerPage_SteamNeptuneDesktopDesc" xml:space="preserve">
+    <value>It appears that Steam is already running and Steam Desktop Layout is applied. This may result in double input.</value>
+  </data>
+  <data name="ControllerPage_SteamNeptuneDesktopWarning" xml:space="preserve">
+    <value>Steam Desktop Layout is applied</value>
+  </data>
+  <data name="ControllerPage_SteamXboxDriversAction" xml:space="preserve">
+    <value>You might want to uninstall Steam Xbox Controller Enhanced Features Driver</value>
+  </data>
+  <data name="ControllerPage_SteamXboxDriversDesc" xml:space="preserve">
+    <value>It appears you have installed Steam Xbox Controller Enhanced Features Driver which are breaking HidHide capacities to hide/unhide your physical controller</value>
+  </data>
+  <data name="ControllerPage_SteamXboxDriversWarning" xml:space="preserve">
+    <value>Steam Xbox Controller Enhanced Features Driver is installed</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/HandheldCompanion/Utils/CommonUtils.cs b/HandheldCompanion/Utils/CommonUtils.cs
index ddaeeac95..1dd155fb2 100644
--- a/HandheldCompanion/Utils/CommonUtils.cs
+++ b/HandheldCompanion/Utils/CommonUtils.cs
@@ -3,7 +3,6 @@
 using System.IO;
 using System.Net;
 using System.Runtime.InteropServices;
-using System.Security.AccessControl;
 using System.Security.Principal;
 using System.Text.RegularExpressions;
 
@@ -79,106 +78,4 @@ public static void OpenUrl(string url)
             }
         }
     }
-
-    public static bool IsFileWritable(string filePath, bool deleteMe = false)
-    {
-        try
-        {
-            if (File.Exists(filePath))
-            {
-                using (var fs = new FileStream(filePath, FileMode.Open))
-                {
-                    return fs.CanWrite;
-                }
-            }
-
-            var CanWrite = false;
-            using (var fs = new FileStream(filePath, FileMode.Create))
-            {
-                CanWrite = fs.CanWrite;
-            }
-
-            if (deleteMe)
-                File.Delete(filePath);
-
-            return CanWrite;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static bool IsDirectoryWritable(string dirPath)
-    {
-        try
-        {
-            using (var fs = File.Create(Path.Combine(dirPath, Path.GetRandomFileName()), 1, FileOptions.DeleteOnClose))
-            {
-                return true;
-            }
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static void SetDirectoryWritable(string processpath)
-    {
-        var rootDirectory = new DirectoryInfo(processpath);
-        var directorySecurity = rootDirectory.GetAccessControl();
-
-        var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
-        var adminitrators = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
-
-        directorySecurity.AddAccessRule(
-            new FileSystemAccessRule(
-                everyone,
-                FileSystemRights.FullControl,
-                InheritanceFlags.None,
-                PropagationFlags.NoPropagateInherit,
-                AccessControlType.Allow));
-
-        directorySecurity.AddAccessRule(
-            new FileSystemAccessRule(
-                WindowsIdentity.GetCurrent().Name,
-                FileSystemRights.FullControl,
-                InheritanceFlags.None,
-                PropagationFlags.NoPropagateInherit,
-                AccessControlType.Allow));
-
-        directorySecurity.SetAccessRuleProtection(true, false);
-
-        rootDirectory.SetAccessControl(directorySecurity);
-    }
-
-    public static void SetFileWritable(string processpath)
-    {
-        var rootFile = new FileInfo(processpath);
-        var fileSecurity = rootFile.GetAccessControl();
-
-        var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
-        var adminitrators = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
-
-        fileSecurity.AddAccessRule(
-            new FileSystemAccessRule(
-                everyone,
-                FileSystemRights.FullControl,
-                InheritanceFlags.None,
-                PropagationFlags.NoPropagateInherit,
-                AccessControlType.Allow));
-
-        fileSecurity.AddAccessRule(
-            new FileSystemAccessRule(
-                WindowsIdentity.GetCurrent().Name,
-                FileSystemRights.FullControl,
-                InheritanceFlags.None,
-                PropagationFlags.NoPropagateInherit,
-                AccessControlType.Allow));
-
-        fileSecurity.SetAccessRuleProtection(true, false);
-
-        rootFile.SetAccessControl(fileSecurity);
-    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Utils/FileUtils.cs b/HandheldCompanion/Utils/FileUtils.cs
new file mode 100644
index 000000000..012597303
--- /dev/null
+++ b/HandheldCompanion/Utils/FileUtils.cs
@@ -0,0 +1,144 @@
+using System.IO;
+using System.IO.Packaging;
+using System.Security.AccessControl;
+using System.Security.Principal;
+
+namespace HandheldCompanion.Utils
+{
+    static class FileUtils
+    {
+        public static bool IsFileWritable(string fileName)
+        {
+            try
+            {
+                if (File.Exists(fileName))
+                {
+                    using (var fs = new FileStream(fileName, FileMode.Open))
+                    {
+                        return fs.CanWrite;
+                    }
+                }
+
+                string dirPath = Path.GetDirectoryName(fileName);
+                return IsDirectoryWritable(dirPath);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static bool IsDirectoryWritable(string dirPath)
+        {
+            try
+            {
+                using (var fs = File.Create(Path.Combine(dirPath, Path.GetRandomFileName()), 1, FileOptions.DeleteOnClose))
+                {
+                    return true;
+                }
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static bool IsFileUsed(string fileName)
+        {
+            // Check if the file exists
+            if (File.Exists(fileName))
+            {
+                // Try to open the file for reading
+                try
+                {
+                    using (StreamReader sr = new StreamReader(fileName))
+                    {
+                        // If no exception is thrown, the file is being used
+                        return false;
+                    }
+                }
+                catch (IOException)
+                {
+                    // If an exception is thrown, the file is not being used
+                    return true;
+                }
+            }
+            else
+            {
+                // If the file does not exist, it is not being used
+                return false;
+            }
+        }
+
+        public static void SetDirectoryWritable(string dirPath)
+        {
+            var rootDirectory = new DirectoryInfo(dirPath);
+            var directorySecurity = rootDirectory.GetAccessControl();
+
+            var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
+            var adminitrators = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
+
+            directorySecurity.AddAccessRule(
+                new FileSystemAccessRule(
+                    everyone,
+                    FileSystemRights.FullControl,
+                    InheritanceFlags.None,
+                    PropagationFlags.NoPropagateInherit,
+                    AccessControlType.Allow));
+
+            directorySecurity.AddAccessRule(
+                new FileSystemAccessRule(
+                    WindowsIdentity.GetCurrent().Name,
+                    FileSystemRights.FullControl,
+                    InheritanceFlags.None,
+                    PropagationFlags.NoPropagateInherit,
+                    AccessControlType.Allow));
+
+            directorySecurity.SetAccessRuleProtection(true, false);
+
+            rootDirectory.SetAccessControl(directorySecurity);
+        }
+
+        public static void SetFileWritable(string fileName)
+        {
+            var rootFile = new FileInfo(fileName);
+            var fileSecurity = rootFile.GetAccessControl();
+
+            var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
+            var adminitrators = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
+
+            fileSecurity.AddAccessRule(
+                new FileSystemAccessRule(
+                    everyone,
+                    FileSystemRights.FullControl,
+                    InheritanceFlags.None,
+                    PropagationFlags.NoPropagateInherit,
+                    AccessControlType.Allow));
+
+            fileSecurity.AddAccessRule(
+                new FileSystemAccessRule(
+                    WindowsIdentity.GetCurrent().Name,
+                    FileSystemRights.FullControl,
+                    InheritanceFlags.None,
+                    PropagationFlags.NoPropagateInherit,
+                    AccessControlType.Allow));
+
+            fileSecurity.SetAccessRuleProtection(true, false);
+
+            rootFile.SetAccessControl(fileSecurity);
+        }
+
+        public static bool FileDelete(string fileName)
+        {
+            if (IsFileUsed(fileName))
+                return false;
+
+            try
+            {
+                File.Delete(fileName);
+                return true;
+            }
+            catch { return false; }
+        }
+    }
+}
diff --git a/HandheldCompanion/Utils/ProcessUtils.cs b/HandheldCompanion/Utils/ProcessUtils.cs
index d0a577aec..5efd3ce7e 100644
--- a/HandheldCompanion/Utils/ProcessUtils.cs
+++ b/HandheldCompanion/Utils/ProcessUtils.cs
@@ -5,6 +5,7 @@
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Drawing;
+using System.IO;
 using System.Linq;
 using System.Management;
 using System.Reflection;
@@ -77,13 +78,18 @@ public static Dictionary<string, string> GetAppProperties(string filePath1)
         return AppProperties;
     }
 
-    public static string GetPathToApp(Process process)
+    public static string GetPathToApp(Process process, bool fast = true)
     {
-        try
+        if (fast)
         {
-            return process.MainModule.FileName;
+            try
+            {
+                // fast but might trigger Win32Exception
+                return process.MainModule.FileName;
+            }
+            catch { }
         }
-        catch
+        else
         {
             var query = $"SELECT ExecutablePath, ProcessID FROM Win32_Process WHERE ProcessID = {process.Id}";
             ManagementObjectSearcher searcher = new(query);
@@ -107,6 +113,46 @@ public static string GetPathToApp(int pid)
         return sb.ToString();
     }
 
+    // A function that takes an executable name as a parameter and returns an array of Process objects
+    public static Process[] GetProcessesByExecutable(string executableName)
+    {
+        // Get all the processes running on the system
+        Process[] allProcesses = Process.GetProcesses();
+
+        // Create a list to store the matching processes
+        List<Process> matchingProcesses = new List<Process>();
+
+        // Loop through each process and check if its executable name matches the parameter
+        foreach (Process process in allProcesses)
+        {
+            try
+            {
+                // Get the full path of the process executable
+                string processPath = GetPathToApp(process.Id);
+                if (string.IsNullOrEmpty(processPath))
+                    continue;
+
+                // Get the file name of the process executable
+                string processFileName = Path.GetFileName(processPath);
+
+                // Compare the file name with the parameter, ignoring case
+                if (string.Equals(processFileName, executableName, StringComparison.OrdinalIgnoreCase))
+                {
+                    // Add the process to the list of matching processes
+                    matchingProcesses.Add(process);
+                }
+            }
+            catch (Exception e)
+            {
+                // Ignore any exceptions that may occur when accessing the process properties
+                Console.WriteLine(e.Message);
+            }
+        }
+
+        // Convert the list to an array and return it
+        return matchingProcesses.ToArray();
+    }
+
     public static List<Process> GetChildProcesses(Process process)
     {
         return new ManagementObjectSearcher($"select processid from win32_process Where parentprocessid=={process.Id}")
diff --git a/HandheldCompanion/Utils/RegistryUtils.cs b/HandheldCompanion/Utils/RegistryUtils.cs
index a0d1b3720..8784ba6ee 100644
--- a/HandheldCompanion/Utils/RegistryUtils.cs
+++ b/HandheldCompanion/Utils/RegistryUtils.cs
@@ -43,4 +43,37 @@ public static bool GetBoolean(string key, string value)
 
         return false;
     }
+
+    public static bool SearchForKeyValue(string key, string value, string content)
+    {
+        // Open the root registry key for reading
+        RegistryKey root = Registry.LocalMachine.OpenSubKey(key);
+
+        // Check if the root key exists
+        if (root != null)
+        {
+            // Get the names of the subkeys under the root key
+            string[] subkeys = root.GetSubKeyNames();
+
+            // Loop through each subkey
+            foreach (string subkey in subkeys)
+            {
+                // Open the subkey for reading
+                RegistryKey subKey = root.OpenSubKey(subkey);
+
+                // Check if the subkey exists and has a value named DeviceDesc
+                if (subKey != null && subKey.GetValue(value) != null)
+                {
+                    // Get the value of DeviceDesc as a string
+                    string subKeyDesc = subKey.GetValue(value).ToString();
+
+                    // Check if the value contains the target strings
+                    if (subKeyDesc.Contains(content, StringComparison.InvariantCultureIgnoreCase))
+                        return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Views/Pages/ControllerPage.xaml b/HandheldCompanion/Views/Pages/ControllerPage.xaml
index b67d58ef1..8d9acf0e3 100644
--- a/HandheldCompanion/Views/Pages/ControllerPage.xaml
+++ b/HandheldCompanion/Views/Pages/ControllerPage.xaml
@@ -54,20 +54,14 @@
                 <ui:SimpleStackPanel Name="Hints" Spacing="6">
 
                     <!--  Has physical controller but none are connected  -->
-                    <Border
+                    <Expander
                         Name="HintsNoPhysicalConnected"
                         Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
                         d:Visibility="Visible"
-                        ui:ThemeManager.RequestedTheme="{Binding Source={x:Static ui:ThemeManager.Current}, Path=ActualApplicationTheme, Converter={StaticResource InverseAppThemeConverter}}"
-                        Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
-                        CornerRadius="{DynamicResource ControlCornerRadius}"
                         Visibility="Collapsed">
 
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition MinWidth="200" />
-                            </Grid.ColumnDefinitions>
-
+                        <Expander.Header>
                             <DockPanel>
                                 <ui:FontIcon
                                     Height="40"
@@ -86,31 +80,21 @@
                                         Style="{StaticResource CaptionTextBlockStyle}"
                                         Text="{x:Static resx:Resources.ControllerPage_NoPhysicalControllerDesc}"
                                         TextWrapping="Wrap" />
-                                    <TextBlock
-                                        Foreground="{DynamicResource AccentFillColorDefaultBrush}"
-                                        Style="{StaticResource CaptionTextBlockStyle}"
-                                        Text="{x:Static resx:Resources.ControllerPage_NoPhysicalControllerAction}"
-                                        TextWrapping="Wrap" />
                                 </ui:SimpleStackPanel>
                             </DockPanel>
-                        </Grid>
-                    </Border>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_NoPhysicalControllerAction}" TextWrapping="Wrap" />
+                    </Expander>
 
                     <!--  Has hidden physical controller but no virtual controller  -->
-                    <Border
+                    <Expander
                         Name="HintsNoVirtual"
                         Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
                         d:Visibility="Visible"
-                        ui:ThemeManager.RequestedTheme="{Binding Source={x:Static ui:ThemeManager.Current}, Path=ActualApplicationTheme, Converter={StaticResource InverseAppThemeConverter}}"
-                        Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
-                        CornerRadius="{DynamicResource ControlCornerRadius}"
                         Visibility="Collapsed">
 
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition MinWidth="200" />
-                            </Grid.ColumnDefinitions>
-
+                        <Expander.Header>
                             <DockPanel>
                                 <ui:FontIcon
                                     Height="40"
@@ -129,31 +113,21 @@
                                         Style="{StaticResource CaptionTextBlockStyle}"
                                         Text="{x:Static resx:Resources.ControllerPage_NoVirtualControllerDesc}"
                                         TextWrapping="Wrap" />
-                                    <TextBlock
-                                        Foreground="{DynamicResource AccentFillColorDefaultBrush}"
-                                        Style="{StaticResource CaptionTextBlockStyle}"
-                                        Text="{x:Static resx:Resources.ControllerPage_NoVirtualControllerAction}"
-                                        TextWrapping="Wrap" />
                                 </ui:SimpleStackPanel>
                             </DockPanel>
-                        </Grid>
-                    </Border>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_NoVirtualControllerAction}" TextWrapping="Wrap" />
+                    </Expander>
 
                     <!--  Has hidden Neptune controller but virtual controller is muted  -->
-                    <Border
+                    <Expander
                         Name="HintsNeptuneHidden"
                         Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
                         d:Visibility="Visible"
-                        ui:ThemeManager.RequestedTheme="{Binding Source={x:Static ui:ThemeManager.Current}, Path=ActualApplicationTheme, Converter={StaticResource InverseAppThemeConverter}}"
-                        Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
-                        CornerRadius="{DynamicResource ControlCornerRadius}"
                         Visibility="Collapsed">
 
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition MinWidth="200" />
-                            </Grid.ColumnDefinitions>
-
+                        <Expander.Header>
                             <DockPanel>
                                 <ui:FontIcon
                                     Height="40"
@@ -172,31 +146,21 @@
                                         Style="{StaticResource CaptionTextBlockStyle}"
                                         Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerHiddenDesc}"
                                         TextWrapping="Wrap" />
-                                    <TextBlock
-                                        Foreground="{DynamicResource AccentFillColorDefaultBrush}"
-                                        Style="{StaticResource CaptionTextBlockStyle}"
-                                        Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerHiddenAction}"
-                                        TextWrapping="Wrap" />
                                 </ui:SimpleStackPanel>
                             </DockPanel>
-                        </Grid>
-                    </Border>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerHiddenAction}" TextWrapping="Wrap" />
+                    </Expander>
 
                     <!--  Physical controller is not hidden and virtual controller detected  -->
-                    <Border
+                    <Expander
                         Name="HintsNotMuted"
                         Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
                         d:Visibility="Visible"
-                        ui:ThemeManager.RequestedTheme="{Binding Source={x:Static ui:ThemeManager.Current}, Path=ActualApplicationTheme, Converter={StaticResource InverseAppThemeConverter}}"
-                        Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}"
-                        CornerRadius="{DynamicResource ControlCornerRadius}"
                         Visibility="Collapsed">
 
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition MinWidth="200" />
-                            </Grid.ColumnDefinitions>
-
+                        <Expander.Header>
                             <DockPanel>
                                 <ui:FontIcon
                                     Height="40"
@@ -206,24 +170,75 @@
                                     Glyph="&#xe7ba;" />
 
                                 <ui:SimpleStackPanel Margin="12,0,0,0" VerticalAlignment="Center">
-                                    <TextBlock
-                                        Foreground="{DynamicResource SystemControlForegroundBaseHighBrush}"
-                                        Style="{StaticResource BodyTextBlockStyle}"
-                                        Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerNotHiddenWarning}" />
+                                    <TextBlock Style="{StaticResource BodyTextBlockStyle}" Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerNotHiddenWarning}" />
                                     <TextBlock
                                         Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
                                         Style="{StaticResource CaptionTextBlockStyle}"
                                         Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerNotHiddenDesc}"
                                         TextWrapping="Wrap" />
+                                </ui:SimpleStackPanel>
+                            </DockPanel>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerNotHiddenAction}" TextWrapping="Wrap" />
+                    </Expander>
+
+                    <!--  Steam Xbox Controller Enhanced Features Driver  -->
+                    <Expander
+                        Name="HintsSteamXboxDrivers"
+                        Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
+                        d:Visibility="Visible"
+                        Visibility="Collapsed">
+
+                        <Expander.Header>
+                            <DockPanel Margin="0,12,12,12">
+                                <ui:FontIcon
+                                    Height="40"
+                                    HorizontalAlignment="Center"
+                                    FontFamily="{DynamicResource SymbolThemeFontFamily}"
+                                    Glyph="&#xe7ba;" />
+
+                                <ui:SimpleStackPanel Margin="12,0,0,0" VerticalAlignment="Center">
+                                    <TextBlock Style="{StaticResource BodyTextBlockStyle}" Text="{x:Static resx:Resources.ControllerPage_SteamXboxDriversWarning}" />
+                                    <TextBlock
+                                        Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
+                                        Style="{StaticResource CaptionTextBlockStyle}"
+                                        Text="{x:Static resx:Resources.ControllerPage_SteamXboxDriversDesc}"
+                                        TextWrapping="Wrap" />
+                                </ui:SimpleStackPanel>
+                            </DockPanel>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_SteamXboxDriversAction}" TextWrapping="Wrap" />
+                    </Expander>
+
+                    <!--  Steam Xbox Controller Enhanced Features Driver  -->
+                    <Expander
+                        Name="HintsSteamNeptuneDeskop"
+                        Padding="15,12,12,12"
+                        HorizontalAlignment="Stretch"
+                        d:Visibility="Visible"
+                        Visibility="Collapsed">
+
+                        <Expander.Header>
+                            <DockPanel Margin="0,12,12,12">
+                                <ui:FontIcon
+                                    Height="40"
+                                    HorizontalAlignment="Center"
+                                    FontFamily="{DynamicResource SymbolThemeFontFamily}"
+                                    Glyph="&#xe7ba;" />
+
+                                <ui:SimpleStackPanel Margin="12,0,0,0" VerticalAlignment="Center">
+                                    <TextBlock Style="{StaticResource BodyTextBlockStyle}" Text="{x:Static resx:Resources.ControllerPage_SteamNeptuneDesktopWarning}" />
                                     <TextBlock
-                                        Foreground="{DynamicResource AccentFillColorDefaultBrush}"
+                                        Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
                                         Style="{StaticResource CaptionTextBlockStyle}"
-                                        Text="{x:Static resx:Resources.ControllerPage_PhysicalControllerNotHiddenAction}"
+                                        Text="{x:Static resx:Resources.ControllerPage_SteamNeptuneDesktopDesc}"
                                         TextWrapping="Wrap" />
                                 </ui:SimpleStackPanel>
                             </DockPanel>
-                        </Grid>
-                    </Border>
+                        </Expander.Header>
+                        <TextBlock Text="{x:Static resx:Resources.ControllerPage_SteamNeptuneDesktopAction}" TextWrapping="Wrap" />
+                    </Expander>
                 </ui:SimpleStackPanel>
 
                 <!--  Input devices  -->
diff --git a/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs b/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
index 2d9578215..1b78c42fe 100644
--- a/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
+++ b/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
@@ -1,6 +1,7 @@
 using HandheldCompanion.Controllers;
 using HandheldCompanion.Controls;
 using HandheldCompanion.Managers;
+using HandheldCompanion.Platforms;
 using HandheldCompanion.Utils;
 using System;
 using System.Linq;
@@ -18,15 +19,12 @@ namespace HandheldCompanion.Views.Pages;
 public partial class ControllerPage : Page
 {
     public delegate void HIDchangedEventHandler(HIDmode HID);
+    public event HIDchangedEventHandler HIDchanged;
 
     // controllers vars
     private HIDmode controllerMode = HIDmode.NoController;
     private HIDstatus controllerStatus = HIDstatus.Disconnected;
 
-    // pipe vars
-    private bool isConnected;
-    private bool isLoading;
-
     public ControllerPage()
     {
         InitializeComponent();
@@ -43,6 +41,9 @@ public ControllerPage()
         ControllerManager.ControllerPlugged += ControllerPlugged;
         ControllerManager.ControllerUnplugged += ControllerUnplugged;
         ControllerManager.ControllerSelected += ControllerManager_ControllerSelected;
+
+        PlatformManager.Initialized += PlatformManager_Initialized;
+        PlatformManager.Steam.Updated += Steam_Updated;
     }
 
     public ControllerPage(string Tag) : this()
@@ -50,7 +51,29 @@ public ControllerPage(string Tag) : this()
         this.Tag = Tag;
     }
 
-    public event HIDchangedEventHandler HIDchanged;
+    private void PlatformManager_Initialized()
+    {
+        HintsSteamXboxDrivers.Visibility = PlatformManager.Steam.HasXboxDriversInstalled() ? Visibility.Visible : Visibility.Collapsed;
+        Steam_Updated(PlatformManager.Steam.IsRunning ? PlatformStatus.Started : PlatformStatus.Stopped);
+    }
+
+    private void Steam_Updated(PlatformStatus status)
+    {
+        // UI thread (async)
+        Application.Current.Dispatcher.BeginInvoke(() =>
+        {
+            switch (status)
+            {
+                case PlatformStatus.Stopping:
+                case PlatformStatus.Stopped:
+                    HintsSteamNeptuneDeskop.Visibility = Visibility.Collapsed;
+                    break;
+                case PlatformStatus.Started:
+                    HintsSteamNeptuneDeskop.Visibility = PlatformManager.Steam.HasDesktopProfileApplied() ? Visibility.Visible : Visibility.Collapsed;
+                    break;
+            }
+        });
+    }
 
     private void SettingsManager_SettingValueChanged(string name, object value)
     {
@@ -109,36 +132,34 @@ private void ControllerUnplugged(IController Controller, bool IsPowerCycling)
             {
                 if (ctrl.GetContainerInstancePath() == Controller.GetContainerInstancePath())
                 {
-                    InputDevices.Children.Remove(ctrl);
-                    break;
+                    if (!IsPowerCycling)
+                    {
+                        InputDevices.Children.Remove(ctrl);
+                        ControllerRefresh();
+                        break;
+                    }
                 }
             }
-
-            ControllerRefresh();
         });
     }
 
     private void ControllerPlugged(IController Controller, bool isHCVirtualController, bool IsPowerCycling)
     {
-        // we assume this is HC virtual controller
-        if (Controller.IsVirtual() && isHCVirtualController)
+        // UI thread (async)
+        Application.Current.Dispatcher.BeginInvoke(() =>
         {
-            if (SettingsManager.GetBoolean("VirtualControllerForceOrder"))
+            // Search for an existing controller, remove it
+            foreach (IController ctrl in InputDevices.Children)
             {
-                // enable physical controller(s) after virtual controller to ensure first order
-                foreach (var physicalControllerInstanceId in SettingsManager.GetStringCollection("PhysicalControllerInstanceIds"))
+                if (ctrl.GetContainerInstancePath() == Controller.GetContainerInstancePath())
                 {
-                    PnPUtil.EnableDevice(physicalControllerInstanceId);
+                    InputDevices.Children.Remove(ctrl);
+                    break;
                 }
             }
-        }
 
-        // UI thread (async)
-        Application.Current.Dispatcher.BeginInvoke(() =>
-        {
             // Add new controller to list if no existing controller was found
-            IController control = Controller;
-            InputDevices.Children.Add(control);
+            InputDevices.Children.Add(Controller);
 
             // todo: move me
             var ui_button_hook = Controller.GetButtonHook();
@@ -149,6 +170,19 @@ private void ControllerPlugged(IController Controller, bool isHCVirtualControlle
 
             ControllerRefresh();
         });
+
+        // we assume this is HC virtual controller
+        if (Controller.IsVirtual() && isHCVirtualController)
+        {
+            if (SettingsManager.GetBoolean("VirtualControllerForceOrder"))
+            {
+                // enable physical controller(s) after virtual controller to ensure first order
+                foreach (var physicalControllerInstanceId in SettingsManager.GetStringCollection("PhysicalControllerInstanceIds"))
+                {
+                    PnPUtil.EnableDevice(physicalControllerInstanceId);
+                }
+            }
+        }
     }
 
     private void ControllerManager_ControllerSelected(IController Controller)
@@ -177,7 +211,8 @@ private void ControllerHideClicked(IController Controller)
         else
             Controller.Hide();
 
-        ControllerRefresh();
+        if (!ControllerManager.PowerCyclers.ContainsKey(Controller.GetContainerInstancePath()))
+            ControllerRefresh();
     }
 
     private void ControllerRefresh()
diff --git a/HandheldCompanion/Views/Pages/LayoutPage.xaml.cs b/HandheldCompanion/Views/Pages/LayoutPage.xaml.cs
index c47aaf72c..a7ba5fe67 100644
--- a/HandheldCompanion/Views/Pages/LayoutPage.xaml.cs
+++ b/HandheldCompanion/Views/Pages/LayoutPage.xaml.cs
@@ -101,6 +101,9 @@ public LayoutPage(string Tag, NavigationView parent) : this()
 
     private void ProfileManager_Updated(Profile profile, ProfileUpdateSource source, bool isCurrent)
     {
+        if (!MainWindow.CurrentPageName.Equals("LayoutPage"))
+            return;
+
         // update layout page if layout was updated elsewhere
         // good enough
         switch(source)
diff --git a/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs b/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
index f77e10f41..c3d018db2 100644
--- a/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
+++ b/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
@@ -544,11 +544,6 @@ private void Toggle_EnableProfile_Toggled(object sender, RoutedEventArgs e)
 
     private void TDPToggle_Toggled(object sender, RoutedEventArgs e)
     {
-        // TDP and AutoTDP are mutually exclusive
-        var toggled = TDPToggle.IsOn;
-        if (toggled)
-            AutoTDPToggle.IsOn = false;
-
         // wait until lock is released
         if (updateLock)
             return;
@@ -636,11 +631,6 @@ private void FramerateSlider_ValueChanged(object sender, RoutedPropertyChangedEv
 
     private void AutoTDPToggle_Toggled(object sender, RoutedEventArgs e)
     {
-        // TDP and AutoTDP are mutually exclusive
-        var toggled = AutoTDPToggle.IsOn;
-        if (toggled)
-            TDPToggle.IsOn = false;
-
         // wait until lock is released
         if (updateLock)
             return;
diff --git a/HandheldCompanion/Views/QuickPages/QuickPerformancePage.xaml b/HandheldCompanion/Views/QuickPages/QuickPerformancePage.xaml
index 96526d77c..c5bfffec4 100644
--- a/HandheldCompanion/Views/QuickPages/QuickPerformancePage.xaml
+++ b/HandheldCompanion/Views/QuickPages/QuickPerformancePage.xaml
@@ -152,7 +152,7 @@
             CornerRadius="{DynamicResource ControlCornerRadius}"
             Visibility="{Binding ElementName=QuietModeToggle, Path=IsOn, Converter={StaticResource BooleanToVisibilityConverter}}">
 
-            <DockPanel Margin="0,0,0,0" ScrollViewer.PanningMode="HorizontalOnly">
+            <DockPanel ScrollViewer.PanningMode="HorizontalOnly">
                 <TextBlock
                     Width="35"
                     VerticalAlignment="Center"
diff --git a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml
index 928ca0d37..a412bb363 100644
--- a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml
+++ b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml
@@ -97,9 +97,7 @@
 
         <Separator Background="{DynamicResource ExpanderHeaderBackground}" />
 
-        <ui:SimpleStackPanel
-            Name="GridProfile"
-            Spacing="10">
+        <ui:SimpleStackPanel Name="GridProfile" Spacing="10">
 
             <Expander HorizontalAlignment="Stretch" IsExpanded="True">
                 <Expander.Header>
@@ -344,7 +342,7 @@
                                 HorizontalAlignment="Left"
                                 VerticalAlignment="Center"
                                 Text="{x:Static resx:Resources.ProfilesPage_EPPBalance}" />
-                            <DockPanel Margin="0,0,0,0" ScrollViewer.PanningMode="HorizontalOnly">
+                            <DockPanel ScrollViewer.PanningMode="HorizontalOnly">
 
                                 <ui:SimpleStackPanel
                                     Margin="0,0,0,0"
@@ -427,7 +425,7 @@
                                 HorizontalAlignment="Left"
                                 VerticalAlignment="Center"
                                 Text="{x:Static resx:Resources.ProfilesPage_GPUMhz}" />
-                            <DockPanel Margin="0,0,0,0" ScrollViewer.PanningMode="HorizontalOnly">
+                            <DockPanel ScrollViewer.PanningMode="HorizontalOnly">
                                 <TextBlock
                                     Width="35"
                                     VerticalAlignment="Center"
@@ -618,14 +616,10 @@
                                 Margin="12,0,0,0"
                                 ScrollViewer.PanningMode="HorizontalOnly">
                                 <TextBlock
-                                    Width="17"
+                                    Width="30"
                                     HorizontalAlignment="Left"
                                     VerticalAlignment="Center"
                                     Text="{Binding Value, StringFormat=N0, ElementName=SliderUMCAntiDeadzone, Mode=OneWay}" />
-                                <TextBlock
-                                    HorizontalAlignment="Left"
-                                    VerticalAlignment="Center"
-                                    Text="{x:Static resx:Resources.ProfilesPage_AntiDeadzoneUnitPercentage}" />
                                 <Slider
                                     x:Name="SliderUMCAntiDeadzone"
                                     Margin="8,0,0,0"
@@ -645,6 +639,50 @@
 
                         <Separator Background="{DynamicResource ExpanderHeaderBackground}" Visibility="{Binding ElementName=GridAntiDeadzone, Path=Visibility}" />
 
+                        <!--  Gyro Weight  -->
+                        <Grid Name="GridGyroWeight">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="1*" />
+                                <ColumnDefinition Width="1*" />
+                            </Grid.ColumnDefinitions>
+
+                            <StackPanel Orientation="Vertical">
+                                <TextBlock Style="{StaticResource BodyTextBlockStyle}" Text="Gyrometer weight" />
+                                <TextBlock
+                                    Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
+                                    Style="{StaticResource CaptionTextBlockStyle}"
+                                    Text="Modify the gyrometer weight when applied against joystick movements"
+                                    TextWrapping="Wrap" />
+                            </StackPanel>
+
+                            <DockPanel
+                                Grid.Column="1"
+                                Margin="12,0,0,0"
+                                ScrollViewer.PanningMode="HorizontalOnly">
+                                <TextBlock
+                                    Width="30"
+                                    HorizontalAlignment="Left"
+                                    VerticalAlignment="Center"
+                                    Text="{Binding Value, StringFormat=N1, ElementName=Slider_GyroWeight, Mode=OneWay}" />
+                                <Slider
+                                    x:Name="Slider_GyroWeight"
+                                    Margin="8,0,0,0"
+                                    HorizontalAlignment="Stretch"
+                                    VerticalAlignment="Center"
+                                    AutoToolTipPrecision="1"
+                                    IsMoveToPointEnabled="True"
+                                    IsSnapToTickEnabled="True"
+                                    Maximum="2.0"
+                                    Minimum="1.0"
+                                    Style="{DynamicResource SliderStyle1}"
+                                    TickFrequency="0.1"
+                                    TickPlacement="BottomRight"
+                                    ValueChanged="Slider_GyroWeight_ValueChanged" />
+                            </DockPanel>
+                        </Grid>
+
+                        <Separator Background="{DynamicResource ExpanderHeaderBackground}" Visibility="{Binding ElementName=GridGyroWeight, Path=Visibility}" />
+
                         <!--  Sensivity  -->
                         <Grid>
                             <Grid.ColumnDefinitions>
@@ -652,7 +690,6 @@
                                 <ColumnDefinition Width="1*" />
                             </Grid.ColumnDefinitions>
 
-
                             <StackPanel Orientation="Vertical">
                                 <TextBlock
                                     Style="{StaticResource BodyTextBlockStyle}"
@@ -668,7 +705,7 @@
                             <StackPanel Grid.Column="1" Margin="12,0,0,0">
                                 <StackPanel>
                                     <TextBlock Text="Horizontal sensitivity" />
-                                    <DockPanel Margin="0,0,0,0" ScrollViewer.PanningMode="HorizontalOnly">
+                                    <DockPanel ScrollViewer.PanningMode="HorizontalOnly">
                                         <TextBlock
                                             Width="30"
                                             HorizontalAlignment="Left"
@@ -697,7 +734,7 @@
 
                                 <StackPanel>
                                     <TextBlock Text="Vertical sensitivity" />
-                                    <DockPanel Margin="0,0,0,0" ScrollViewer.PanningMode="HorizontalOnly">
+                                    <DockPanel ScrollViewer.PanningMode="HorizontalOnly">
                                         <TextBlock
                                             Width="30"
                                             HorizontalAlignment="Left"
diff --git a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
index a05e41601..99610badd 100644
--- a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
+++ b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
@@ -353,11 +353,13 @@ private void ProfileApplied(Profile profile, ProfileUpdateSource source)
                     {
                         // IActions
                         GridAntiDeadzone.Visibility = currentAction is AxisActions ? Visibility.Visible : Visibility.Collapsed;
+                        GridGyroWeight.Visibility = currentAction is AxisActions ? Visibility.Visible : Visibility.Collapsed;
 
                         if (currentAction is AxisActions)
                         {
                             cB_Output.SelectedIndex = (int)((AxisActions)currentAction).Axis;
                             SliderUMCAntiDeadzone.Value = ((AxisActions)currentAction).AxisAntiDeadZone;
+                            Slider_GyroWeight.Value = ((AxisActions)currentAction).gyroWeight;
                         }
                         else if (currentAction is MouseActions)
                         {
@@ -566,12 +568,7 @@ private void TDPToggle_Toggled(object sender, RoutedEventArgs e)
         if (updateLock)
             return;
 
-        // TDP and AutoTDP are mutually exclusive
-        var toggled = TDPToggle.IsOn;
-        if (toggled)
-            AutoTDPToggle.IsOn = false;
-
-        currentProfile.TDPOverrideEnabled = toggled;
+        currentProfile.TDPOverrideEnabled = TDPToggle.IsOn;
         RequestUpdate();
     }
 
@@ -600,12 +597,7 @@ private void AutoTDPToggle_Toggled(object sender, RoutedEventArgs e)
         if (updateLock)
             return;
 
-        // TDP and AutoTDP are mutually exclusive
-        var toggled = AutoTDPToggle.IsOn;
-        if (toggled)
-            TDPToggle.IsOn = false;
-
-        currentProfile.AutoTDPEnabled = toggled;
+        currentProfile.AutoTDPEnabled = AutoTDPToggle.IsOn;
         AutoTDPRequestedFPSSlider.Value = currentProfile.AutoTDPRequestedFPS;
 
         RequestUpdate();
@@ -640,6 +632,23 @@ private void SliderUMCAntiDeadzone_ValueChanged(object sender, RoutedPropertyCha
         RequestUpdate();
     }
 
+    private void Slider_GyroWeight_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
+    {
+        if (currentProfile is null)
+            return;
+
+        if (updateLock)
+            return;
+
+        if (!currentProfile.Layout.GyroLayout.TryGetValue(AxisLayoutFlags.Gyroscope, out IActions currentAction))
+            return;
+
+        if (currentAction is AxisActions)
+            ((AxisActions)currentAction).gyroWeight = (float)Slider_GyroWeight.Value;
+
+        RequestUpdate();
+    }
+
     private void SliderSensitivityX_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
     {
         if (currentProfile is null)
diff --git a/HandheldCompanion/Views/Windows/MainWindow.xaml.cs b/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
index e1135274d..b70c90a23 100644
--- a/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
+++ b/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
@@ -66,9 +66,9 @@ public partial class MainWindow : GamepadWindow
     private static MainWindow CurrentWindow;
     public static FileVersionInfo fileVersionInfo;
 
-    public static string InstallPath;
-    public static string SettingsPath;
-    public static string CurrentPageName;
+    public static string InstallPath = string.Empty;
+    public static string SettingsPath = string.Empty;
+    public static string CurrentPageName = string.Empty;
 
     private bool appClosing;
     private bool IsReady;
diff --git a/HandheldCompanion/Views/Windows/OverlayQuickTools.xaml.cs b/HandheldCompanion/Views/Windows/OverlayQuickTools.xaml.cs
index 324f70880..12e8229a0 100644
--- a/HandheldCompanion/Views/Windows/OverlayQuickTools.xaml.cs
+++ b/HandheldCompanion/Views/Windows/OverlayQuickTools.xaml.cs
@@ -7,17 +7,17 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Globalization;
 using System.Linq;
 using System.Windows;
 using System.Windows.Forms;
 using System.Windows.Input;
 using System.Windows.Interop;
 using System.Windows.Navigation;
+using System.Windows.Threading;
 using Windows.System.Power;
 using WpfScreenHelper;
 using WpfScreenHelper.Enum;
-using System.Windows.Threading;
-using System.Globalization;
 using Application = System.Windows.Application;
 using KeyEventArgs = System.Windows.Input.KeyEventArgs;
 using Page = System.Windows.Controls.Page;
diff --git a/HandheldCompanion/XInputPlus/XInputPlus.cs b/HandheldCompanion/XInputPlus/XInputPlus.cs
index 9b5e947e2..1cc5a52ac 100644
--- a/HandheldCompanion/XInputPlus/XInputPlus.cs
+++ b/HandheldCompanion/XInputPlus/XInputPlus.cs
@@ -205,119 +205,159 @@ public static void InjectXInputPlus(Process targetProcess, bool x64bit)
         }
     }
 
-    public static void RegisterApplication(Profile profile)
+    private static bool CheckDeployment(string DirectoryPath)
     {
-        var DirectoryPath = Path.GetDirectoryName(profile.Path);
-
-        // get binary type (x64, x86)
-        BinaryType bt;
-        GetBinaryType(profile.Path, out bt);
-        bool x64bit = bt == BinaryType.SCS_64BIT_BINARY;
-
-        // prepare ini file
-        WriteXInputPlusINI(DirectoryPath, x64bit);
-
         for (var i = 0; i < 5; i++)
         {
-            var XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.dll");
-            var XInputPlusDLLTargetBackPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.back");
+            string XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.dll");
 
             // dll has a different naming format
             if (i == 4)
-            {
                 XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, "xinput9_1_0.dll");
-                XInputPlusDLLTargetBackPath = Path.Combine(DirectoryPath, "xinput9_1_0.back");
-            }
-
-            var dllexist = File.Exists(XInputPlusDLLTargetPath);
-            var backexist = File.Exists(XInputPlusDLLTargetBackPath);
-
-            byte[] inputData = { 0 };
-
-            // check CRC32
-            if (dllexist) inputData = File.ReadAllBytes(XInputPlusDLLTargetPath);
-            var crc = Crc32Algorithm.Compute(inputData);
-            var is_x360ce = CRCs[x64bit] == crc;
-
-            // pull data from dll
-            var XInputPlusDLLSrcPath = x64bit ? XInputPlus_XInputx64 : XInputPlus_XInputx86;
 
-            if (dllexist && is_x360ce) continue; // skip to next file
+            if (FileUtils.IsFileUsed(XInputPlusDLLTargetPath))
+                return false;
 
-            if (!dllexist)
-            {
-                //File.WriteAllBytes(dllpath, outputData);
-                File.Copy(XInputPlusDLLSrcPath, XInputPlusDLLTargetPath);
-            }
-            else if (dllexist && !is_x360ce)
-            {
-                // create backup of current dll
-                if (!backexist)
-                    File.Move(XInputPlusDLLTargetPath, XInputPlusDLLTargetBackPath, true);
-
-                // deploy wrapper
-                if (CommonUtils.IsFileWritable(XInputPlusDLLTargetPath))
-                    File.Copy(XInputPlusDLLSrcPath, XInputPlusDLLTargetPath, true);
-            }
+            if (!FileUtils.IsFileWritable(XInputPlusDLLTargetPath))
+                return false;
         }
+
+        return true;
     }
 
-    public static void UnregisterApplication(Profile profile)
+    public static bool RegisterApplication(Profile profile)
     {
-        var DirectoryPath = Path.GetDirectoryName(profile.Path);
-        var IniPath = Path.Combine(DirectoryPath, "XInputPlus.ini");
+        string DirectoryPath = Path.GetDirectoryName(profile.Path);
 
         // get binary type (x64, x86)
         BinaryType bt;
         GetBinaryType(profile.Path, out bt);
-        var x64 = bt == BinaryType.SCS_64BIT_BINARY;
+        bool x64bit = bt == BinaryType.SCS_64BIT_BINARY;
 
-        for (var i = 0; i < 5; i++)
+        // prepare ini file
+        if (!WriteXInputPlusINI(DirectoryPath, x64bit))
+            return false;
+
+        // check if dll files can be deployed
+        if (!CheckDeployment(DirectoryPath))
         {
-            var XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.dll");
-            var XInputPlusDLLTargetBackupPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.back");
+            LogManager.LogError("XInputPlus, RegisterApplication failed: {0}", DirectoryPath);
+            return false;
+        }
 
-            // dll has a different naming format
-            if (i == 4)
+        // prepare dll files
+        try
+        {
+            for (var i = 0; i < 5; i++)
             {
-                XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, "xinput9_1_0.dll");
-                XInputPlusDLLTargetBackupPath = Path.Combine(DirectoryPath, "xinput9_1_0.back");
+                string XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.dll");
+                string XInputPlusDLLTargetBackPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.back");
+
+                // dll has a different naming format
+                if (i == 4)
+                {
+                    XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, "xinput9_1_0.dll");
+                    XInputPlusDLLTargetBackPath = Path.Combine(DirectoryPath, "xinput9_1_0.back");
+                }
+
+                bool dllexist = File.Exists(XInputPlusDLLTargetPath);
+                bool backexist = File.Exists(XInputPlusDLLTargetBackPath);
+
+                byte[] inputData = { 0 };
+
+                // check CRC32
+                if (dllexist) inputData = File.ReadAllBytes(XInputPlusDLLTargetPath);
+                uint crc = Crc32Algorithm.Compute(inputData);
+                bool is_x360ce = CRCs[x64bit] == crc;
+
+                // pull data from dll
+                string XInputPlusDLLSrcPath = x64bit ? XInputPlus_XInputx64 : XInputPlus_XInputx86;
+
+                if (dllexist && is_x360ce) continue; // skip to next file
+
+                if (!dllexist)
+                {
+                    //File.WriteAllBytes(dllpath, outputData);
+                    File.Copy(XInputPlusDLLSrcPath, XInputPlusDLLTargetPath);
+                }
+                else if (dllexist && !is_x360ce)
+                {
+                    // create backup of current dll
+                    if (!backexist)
+                        File.Move(XInputPlusDLLTargetPath, XInputPlusDLLTargetBackPath, true);
+
+                    // deploy wrapper
+                    File.Copy(XInputPlusDLLSrcPath, XInputPlusDLLTargetPath, true);
+                }
             }
 
-            var dllexist = File.Exists(XInputPlusDLLTargetPath);
-            var backexist = File.Exists(XInputPlusDLLTargetBackupPath);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
 
-            byte[] inputData = { 0 };
+    public static bool UnregisterApplication(Profile profile)
+    {
+        string DirectoryPath = Path.GetDirectoryName(profile.Path);
 
-            // check CRC32
-            if (dllexist) inputData = File.ReadAllBytes(XInputPlusDLLTargetPath);
-            var crc = Crc32Algorithm.Compute(inputData);
-            var is_x360ce = CRCs[x64] == crc;
+        // check if dll files can be deployed
+        if (!CheckDeployment(DirectoryPath))
+        {
+            LogManager.LogError("XInputPlus, UnregisterApplication failed: {0}", DirectoryPath);
+            return false;
+        }
 
-            if (backexist)
-            {
-                // restore original DLL
-                File.Move(XInputPlusDLLTargetBackupPath, XInputPlusDLLTargetPath, true);
-            }
-            else
+        // remove dll files
+        try
+        {
+            for (var i = 0; i < 5; i++)
             {
-                // clean up XInputPlus files
-                if (dllexist)
-                    File.Delete(XInputPlusDLLTargetPath);
+                string XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.dll");
+                string XInputPlusDLLTargetBackupPath = Path.Combine(DirectoryPath, $"xinput1_{i + 1}.back");
+
+                // dll has a different naming format
+                if (i == 4)
+                {
+                    XInputPlusDLLTargetPath = Path.Combine(DirectoryPath, "xinput9_1_0.dll");
+                    XInputPlusDLLTargetBackupPath = Path.Combine(DirectoryPath, "xinput9_1_0.back");
+                }
+
+                bool dllexist = File.Exists(XInputPlusDLLTargetPath);
+                bool backexist = File.Exists(XInputPlusDLLTargetBackupPath);
+
+                if (backexist)
+                {
+                    // restore original DLL
+                    File.Move(XInputPlusDLLTargetBackupPath, XInputPlusDLLTargetPath, true);
+                }
+                else if (dllexist)
+                {
+                    // clean up XInputPlus files
+                    FileUtils.FileDelete(XInputPlusDLLTargetPath);
+                }
             }
+
+            // remove XInputPlus INI file
+            string IniPath = Path.Combine(DirectoryPath, "XInputPlus.ini");
+            FileUtils.FileDelete(IniPath);
+        }
+        catch
+        {
+            return false;
         }
 
-        // remove XInputPlus INI file
-        if (File.Exists(IniPath))
-            File.Delete(IniPath);
+        return true;
     }
 
-    public static void WriteXInputPlusINI(string directoryPath, bool x64bit)
+    public static bool WriteXInputPlusINI(string directoryPath, bool x64bit)
     {
         var IniPath = Path.Combine(directoryPath, "XInputPlus.ini");
 
-        if (!CommonUtils.IsFileWritable(IniPath))
-            return;
+        if (!FileUtils.IsFileWritable(IniPath))
+            return false;
 
         // prepare index array
         List<int> userIndex = new() { 1, 2, 3, 4 };
@@ -334,7 +374,7 @@ public static void WriteXInputPlusINI(string directoryPath, bool x64bit)
         // we need to define Controller index overwrite
         XInputController vController = ControllerManager.GetVirtualControllers().OfType<XInputController>().FirstOrDefault();
         if (vController is null)
-            return;
+            return false;
 
         // get virtual controller index and update IniFile
         int idx = vController.GetUserIndex() + 1;
@@ -355,6 +395,8 @@ public static void WriteXInputPlusINI(string directoryPath, bool x64bit)
 
         LogManager.LogDebug("XInputPlus INI wrote in {0}. Controller1 set to UserIndex: {1}",
             directoryPath, idx);
+
+        return true;
     }
 
     // https://msdn.microsoft.com/en-us/library/windows/desktop/ms684139%28v=vs.85%29.aspx