init prop (no ui logic)

src/MSCFixer/Features/AI/CopilotTaskbar.cs

@@ -0,0 +1,64 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.AI
+{
+    internal class CopilotTaskbar : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\WindowsCopilot";
+        private const string valueName = "TurnOffWindowsCopilot";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Don't Show Copilot in Taskbar";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable Copilot in Taskbar.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 1);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/AI/RecallMachine.cs

@@ -0,0 +1,74 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.AI
+{
+    internal class RecallMachine : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsAI";
+        private const string valueName = "DisableAIDataAnalysis";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Don't Allow system-wide snapshots";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable system-wide snapshots.";
+        }
+
+        public override bool CheckFeature()
+        {
+            // Check if reg key exists
+            object value = Registry.GetValue(keyName, valueName, null);
+            if (value == null)
+            {
+                // Key does not exist, turn off feature
+                return false;
+            }
+
+            // Key exists, check if value is desired value
+            return (int)value != recommendedValue;
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+                Logger.Log("You've even disabled system-wide Snapshots for all users now.", LogLevel.Info);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, Microsoft.Win32.RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/AI/RecallUser.cs

@@ -0,0 +1,74 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.AI
+{
+    internal class RecallUser : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\WindowsAI";
+        private const string valueName = "DisableAIDataAnalysis";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Don't Allow Windows to save snapshots of your screen";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable Recall from saving snapshots of your screen.";
+        }
+
+        public override bool CheckFeature()
+        {
+            // Check if reg key exists
+            object value = Registry.GetValue(keyName, valueName, null);
+            if (value == null)
+            {
+                // Key does not exist, turn off feature
+                return false;
+            }
+
+            // Key exists, check if value is desired value
+            return (int)value != recommendedValue;
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+                Logger.Log("You've got snapshots disabled.", LogLevel.Info);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, Microsoft.Win32.RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/FileExlorerAds.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class FileExplorerAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "ShowSyncProviderNotifications";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable File Explorer Ads";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable ads in File Explorer.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                Logger.Log("File Explorer Ads disabled", LogLevel.Info);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                Logger.Log("File Explorer Ads enabled", LogLevel.Info);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/FinishSetupAds.cs

@@ -0,0 +1,61 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class FinishSetupAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\UserProfileEngagement";
+        private const string valueName = "ScoobeSystemSettingEnabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Finish Setup Ads";
+
+        public override string Info() => "This feature will disable the \"Lets finish setting up your device\" and other advertising.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return
+                Utils.IntEquals(keyName, valueName, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/LockScreenAds.cs

@@ -0,0 +1,65 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class LockScreenAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\ContentDeliveryManager";
+        private const string valueName = "RotatingLockScreenOverlayEnabled";
+        private const string valueName2 = "SubscribedContent-338387Enabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Lock Screen Tips and Ads";
+
+        public override string Info() => "This feature will disable tips and ads on the lock screen.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (Utils.IntEquals(keyName, valueName, recommendedValue) &&
+                   Utils.IntEquals(keyName, valueName2, recommendedValue)
+            );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+                
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/PersonalizedAds.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    public class PersonalizedAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\AdvertisingInfo";
+        private const string valueName = "Enabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Personalized Ads";
+
+        public override string Info() => "This feature will disable personalized ads.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/SettingsAds.cs

@@ -0,0 +1,70 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class SettingsAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\ContentDeliveryManager";
+        private const string valueName = "SubscribedContent-338393Enabled";
+        private const string valueName2 = "SubscribedContent-353694Enabled";
+        private const string valueName3 = "SubscribedContent-353696Enabled";
+
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Settings Ads";
+
+        public override string Info() => "This feature will disable ads in settings.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} + {valueName2} + {valueName3} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (Utils.IntEquals(keyName, valueName, recommendedValue) &&
+                   Utils.IntEquals(keyName, valueName2, recommendedValue) &&
+                   Utils.IntEquals(keyName, valueName3, recommendedValue)
+            );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 0, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName3, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 1, Microsoft.Win32.RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName3, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/StartmenuAds.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class StartmenuAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "Start_IrisRecommendations";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Start menu Ads";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable ads in the start menu.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/TailoredExperiences.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class TailoredExperiences : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Privacy";
+        private const string valueName = "TailoredExperiencesWithDiagnosticDataEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Tailored experiences";
+        }
+
+        public override string Info()
+        {
+            return "Tailored Experiences allows Microsoft to get information from you to deliver personalized tips, ads, and recommendations. Many people would call this telemetry, or even spying.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/TipsAndSuggestions.cs

@@ -0,0 +1,61 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    internal class TipsAndSuggestions : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\ContentDeliveryManager";
+        private const string valueName = "SubscribedContent-338389Enabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable General Tips and Ads";
+
+        public override string Info() => "This feature will disable general tips and ads.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (Utils.IntEquals(keyName, valueName, recommendedValue)
+                 );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Ads/WelcomeExperienceAds.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Ads
+{
+    public class WelcomeExperienceAds : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\ContentDeliveryManager";
+        private const string valueName = "SubscribedContent-310093Enabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Welcome Experience Ads";
+
+        public override string Info() => "This feature will disable ads in the welcome experience.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/BrowserSignin.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class BrowserSignin : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "BrowserSignin";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Browser sign in and sync services";
+
+        public override string Info() => "This setting controls whether a user can sign into Microsoft Edge with an account to use services such as sync and single sign on";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/DefaultTopSites.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class DefaultTopSites : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "NewTabPageHideDefaultTopSites";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Don't Show Sponsored links in new tab page";
+
+        public override string Info() => "Hide default top sites from the new tab page in Microsoft Edge";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/DefautBrowserSetting.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class DefautBrowserSetting : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "DefaultBrowserSettingEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Microsoft Edge as default browser";
+
+        public override string Info() => "Force Edge to stop asking to change default browser";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/EdgeCollections.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class EdgeCollections : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "EdgeCollectionsEnabled";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Access to Collections feature";
+
+        public override string Info() => "Enables users to access the Collections feature, allowing them to gather, organize, share, and export content more efficiently with Office integration";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/EdgeShoppingAssistant.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class EdgeShoppingAssistant : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "EdgeShoppingAssistantEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Shopping assistant";
+
+        public override string Info() => "Shopping in Microsoft Edge feature will automatically find you the best prices and coupons from across the web as you shop";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/FirstRunExperience.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class FirstRunExperience : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "HideFirstRunExperience";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Don't Show First Run Experience";
+
+        public override string Info() => "Hide home screen and 'Getting Started' on initial launch (from version 80 onwards)";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/GamerMode.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class GamerMode : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "GamerModeEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Gamer Mode";
+
+        public override string Info() => "Microsoft Edge Gamer Mode allows gamers to personalize their browser with gaming themes and gives them the option of enabling Efficiency Mode for PC gaming, the Gaming feed on new tabs, sidebar apps for gamers, and more";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/HubsSidebar.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class HubsSidebar : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Policies\Microsoft\Edge";
+        private const string valueName = "HubsSidebarEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Copilot Symbol in Edge";
+
+        public override string Info() => "This feature will disable Copilot in Microsoft Edge.";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/ImportOnEachLaunch.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class ImportOnEachLaunch : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "ImportOnEachLaunch";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Don't Allow to Import of data from other browsers on each launch";
+
+        public override string Info() => "Allow import of data from other browsers on each Microsoft Edge launch";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/StartupBoost.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class StartupBoost : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "StartupBoostEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Disable Start Boost";
+
+        public override string Info() => "Enables Microsoft Edge processes to initialize at operating system startup and restart in the background after the last browser window has been closed";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/TabPageQuickLinks.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class TabPageQuickLinks : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "NewTabPageQuickLinksEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Don't Show Quick links in new tab page";
+
+        public override string Info() => "By default, when you open a new tab, you see a Bing search bar, Bing image of the day set as the page background. For supported websites, Quick Links on the New Tab page can display recent updates right in the tile";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Edge/UserFeedback.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Edge
+{
+    public class UserFeedback : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge";
+        private const string valueName = "UserFeedbackAllowed";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID() => "Don't Submit user feedback option";
+
+        public override string Info() => "Allow the submission of feedback, suggestions, or customer surveys, as well as reporting issues with the browser";
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Gaming/GameDVR.cs

@@ -0,0 +1,77 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Gaming
+{
+    internal class GameDVR : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\System\GameConfigStore";
+
+        // 0 = Enabled, 2 = Disabled
+        private const string keyName2 = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\PolicyManager\default\ApplicationManagement\AllowGameDVR";
+
+        private const string valueName = "GameDVR_Enabled";
+        private const string valueName2 = "GameDVR_FSEBehaviorMode";
+        private const string valueName3 = "value";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} |Value: {valueName} | {valueName2} | {keyName2} | {valueName3} ";
+        }
+
+        public override string ID()
+        {
+            return "Disable Game DVR";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable Game DVR.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 0) &&
+                       Utils.IntEquals(keyName, valueName2, 2) &&
+                       Utils.IntEquals(keyName2, valueName3, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 2, RegistryValueKind.DWord);
+                Registry.SetValue(keyName2, valueName3, 0, RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 0, RegistryValueKind.DWord);
+                Registry.SetValue(keyName2, valueName3, 1, RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Gaming/PowerThrotteling.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Gaming
+{
+    internal class PowerThrottling : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power\PowerThrottling";
+        private const string valueName = "PowerThrottlingOff";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Power Throttling";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable Power Throttling.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Gaming/VisualFX.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Gaming
+{
+    internal class VisualFX : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\VisualEffects";
+        private const string valueName = "VisualFXSetting";
+        private const int recommendedValue = 2;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Visual Effects";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable visual effects in Windows.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, 0);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 2, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Issues/BasicCleanup.cs

@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using Crapfixer;
+
+namespace Settings.Issues
+{
+    internal class BasicCleanup : FeatureBase
+    {
+        private readonly string tempPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Temp");
+        private const int cleanupSetNumber = 1;
+
+        public override string ID() => "Basic Cleanup";
+
+        public override string Info() => "Deletes all temporary files from the user's Temp folder. Then, the built-in Disk Cleanup utility (cleanmgr) is run.";
+
+        public override bool CheckFeature()
+        {
+            try
+            {
+                var totalSize = GetDirectorySize(tempPath);
+
+                bool isOk = totalSize <= 50;
+                if (!isOk)
+                {
+                    Logger.Log($"Temp folder size is {totalSize} MB (cleanup recommended!) We need also to include cleanup in the next run.", LogLevel.Warning);
+
+                }
+
+                return isOk;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error checking Temp folder: {ex.Message}", LogLevel.Error);
+                return false;
+            }
+        }
+
+
+        public override string GetFeatureDetails()
+        {
+            try
+            {
+                var totalSize = GetDirectorySize(tempPath);
+                return $"Temp folder size: {totalSize} MB";
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error accessing Temp folder: {ex.Message}", LogLevel.Error);
+                return $"Temp folder not accessible: {tempPath}";
+            }
+        }
+
+        public override async Task<bool> DoFeature()
+        {
+            try
+            {
+                await CleanTempFolderAsync(); 
+                await RunDiskCleanup();
+                Logger.Log("Basic Cleanup completed successfully.", LogLevel.Info);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error cleaning Temp folder: {ex.Message}", LogLevel.Warning);
+                return false;
+            }
+        }
+
+
+        private async Task CleanTempFolderAsync()
+        {
+            var files = await Task.Run(() => Directory.GetFiles(tempPath, "*", SearchOption.AllDirectories));
+            var dirs = await Task.Run(() => Directory.GetDirectories(tempPath, "*", SearchOption.AllDirectories));
+
+            foreach (var file in files)
+            {
+                try
+                {
+                await Task.Run(() => File.Delete(file)); 
+                    Logger.Log($"Deleted file: {file}", LogLevel.Info);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Log($"Error deleting file {file}: {ex.Message}", LogLevel.Warning);
+                }
+            }
+
+            foreach (var dir in dirs)
+            {
+                try
+                {
+                    await Task.Run(() => Directory.Delete(dir, true));
+                    Logger.Log($"Deleted directory: {dir}", LogLevel.Info);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Log($"Error deleting directory {dir}: {ex.Message}", LogLevel.Warning);
+                }
+            }
+        }
+
+
+        // calculate the size of the directory in MB
+        private long GetDirectorySize(string directory)
+        {
+            try
+            {
+                var directoryInfo = new DirectoryInfo(directory);
+                long size = 0;
+
+                // Calculate size of all files
+                size += directoryInfo.GetFiles("*", SearchOption.AllDirectories).Sum(file => file.Length);
+
+
+                return size / (1024 * 1024);                 // return size in MB
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error calculating directory size: {ex.Message}", LogLevel.Warning);
+                return 0;
+            }
+        }
+
+        private async Task RunDiskCleanup()
+        {
+            try
+            {
+                Logger.Log("Running Disk Cleanup utility (cleanmgr)...", LogLevel.Info);
+
+                var sageSetCmd = $"cleanmgr.exe /sageset:{cleanupSetNumber}";
+                var startInfo1 = new ProcessStartInfo("cmd", $"/c {sageSetCmd}")
+                {
+                    CreateNoWindow = true,
+                    UseShellExecute = false
+                };
+
+                var sageRunCmd = $"cleanmgr.exe /sagerun:{cleanupSetNumber}";
+                var veryLowDiskCmd = $"cleanmgr.exe /verylowdisk";
+                var startInfo2 = new ProcessStartInfo("cmd", $"/c {sageRunCmd} {veryLowDiskCmd}")
+                {
+                    CreateNoWindow = true,
+                    UseShellExecute = false
+                };
+
+                using (var process1 = Process.Start(startInfo1))
+                {
+                    if (process1 != null)
+                        await Task.Run(() => process1.WaitForExit());  
+                }
+
+                using (var process2 = Process.Start(startInfo2))
+                {
+                    if (process2 != null)
+                        await Task.Run(() => process2.WaitForExit()); 
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error running Disk Cleanup: {ex.Message}", LogLevel.Warning);
+            }
+        }
+
+
+        // Undo method: Cleanup cannot be undone, so return false
+        public override bool UndoFeature() => false;
+    }
+}

src/MSCFixer/Features/Privacy/ActivityHistory.cs

@@ -0,0 +1,67 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Privacy
+{
+    internal class ActivityHistory : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Privacy";
+        private const string valueName = "ActivityHistoryEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable activity history";
+        }
+
+        public override string Info()
+        {
+            return "Disable activity history (prevents Windows from tracking and storing your activity)";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+               Utils.IntEquals(keyName, valueName, recommendedValue)
+         );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Privacy/LocationTracking.cs

@@ -0,0 +1,65 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Privacy
+{
+    internal class LocationTracking : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\LocationAndSensors";
+        private const string valueName = "LocationEnabled";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable location tracking";
+        }
+
+        public override string Info()
+        {
+            return "Disable location tracking (prevents Windows from accessing your location)";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Privacy/PrivacyExperience.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Privacy
+{
+    public class PrivacyExperience : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\OOBE";
+        private const string valueName = "DisablePrivacyExperience";
+        private const int recommendedValue = 0;
+
+        public override string ID() => "Disable Privacy Settings Experience at sign-in";
+
+        public override string Info() => "This feature will disable Privacy Settings Experience at sign-in.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return !Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/Privacy/Telemetry.cs

@@ -0,0 +1,64 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Privacy
+{
+    public class Telemetry : FeatureBase
+    {
+        private const string dataCollection = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\DataCollection";
+        private const string diagTrack = @"HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\DiagTrack";
+
+        public override string ID() => "Turn off Telemetry data collection";
+
+        public override string Info() => "This feature will turn off telemetry data collection and prevent the data from being sent to Microsoft.";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{dataCollection} | {diagTrack}";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+               Utils.IntEquals(dataCollection, "AllowTelemetry", 0) &&
+                Utils.IntEquals(diagTrack, "Start", 2)
+
+           );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(dataCollection, "AllowTelemetry", 0, RegistryValueKind.DWord);
+                Registry.SetValue(diagTrack, "Start", 2, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(dataCollection, "AllowTelemetry", 1, RegistryValueKind.DWord);
+                Registry.SetValue(diagTrack, "Start", 4, RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/System/BSODDetails.cs

@@ -0,0 +1,70 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.System
+{
+    internal class BSODDetails : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\CrashControl";
+        private const string valueName1 = "DisplayParameters";
+        private const string valueName2 = "DisableEmoticon";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Values: {valueName1}, {valueName2} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Show BSOD details instead of sad smiley";
+        }
+
+        public override string Info()
+        {
+            return "This method displays the full classic BSOD with technical error details instead of the simplified sad face version.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                Utils.IntEquals(keyName, valueName1, recommendedValue) &&
+                Utils.IntEquals(keyName, valueName2, recommendedValue)
+            );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName1, recommendedValue, RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, recommendedValue, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName1, 0, RegistryValueKind.DWord);
+                Registry.SetValue(keyName, valueName2, 0, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/System/SpeedUpShutdown.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.System
+{
+    internal class SpeedUpShutdown : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control";
+        private const string valueName = "WaitToKillServiceTimeout";
+        private const string recommendedValue = "1000"; // Set to 1000 ms (1 second)
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue} ms";
+        }
+
+        public override string ID()
+        {
+            return "Speed Up Shutdown Process";
+        }
+
+        public override string Info()
+        {
+            return "This feature reduces the WaitToKillServiceTimeout value, which speeds up the shutdown process by reducing the time Windows waits for services to stop.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.StringEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, RegistryValueKind.String);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in SpeedUpShutdown: " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, "5000", RegistryValueKind.String); // Default value
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in SpeedUpShutdown (Undo): " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/System/VerboseStatus.cs

@@ -0,0 +1,67 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.System
+{
+    internal class VerboseStatus : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System";
+        private const string valueName = "VerboseStatus";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Enable Verbose Logon status messages";
+        }
+
+        public override string Info()
+        {
+            return "This method allows you to see what processes are hanging when shutting down and turning on the machine.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+               Utils.IntEquals(keyName, valueName, recommendedValue)
+         );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/DarkMode.cs

@@ -0,0 +1,125 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class AppDarkMode : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
+        private const string valueName = "AppsUseLightTheme";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended: {recommendedValue} (Dark mode – preferred for a modern look, but up to you)";
+        }
+
+        public override string ID()
+        {
+            return "Enable Dark Mode for Apps";
+        }
+
+        public override string Info()
+        {
+            return "This feature enables Dark Mode for apps in Windows 11.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in AppDarkMode: " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in AppDarkMode (Undo): " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+
+    internal class SystemDarkMode : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
+        private const string valueName = "SystemUsesLightTheme";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Suggestion: {recommendedValue} (Dark mode – easy on the eyes, but totally your call)";
+        }
+
+        public override string ID()
+        {
+            return "Enable Dark Mode for System";
+        }
+
+        public override string Info()
+        {
+            return "This feature enables Dark Mode for Windows system UI (e.g., taskbar, start menu).";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in SystemDarkMode: " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in SystemDarkMode (Undo): " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/FullContextMenus.cs

@@ -0,0 +1,69 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class FullContextMenus : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\SOFTWARE\CLASSES\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32";
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName}";
+        }
+
+        public override string ID()
+        {
+            return "Show Full context menus in Windows 11";
+        }
+
+        public override string Info()
+        {
+            return "This feature will enable full context menus";
+        }
+
+        public override bool CheckFeature()
+        {
+            try
+            {
+                object value = Registry.GetValue(keyName, "", null);
+                return value != null; // Return true if value is not null
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error occurred while checking: " + ex.Message, LogLevel.Error);
+                return false;
+            }
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, "", "", RegistryValueKind.String);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error occurred while enabling: " + ex.Message, LogLevel.Error);
+                return Task.FromResult(false);
+            }
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.CurrentUser.DeleteSubKeyTree(@"Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}", false);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error occurred while disabling: " + ex.Message, LogLevel.Error);
+                return false;
+            }
+        }
+    }
+}

src/MSCFixer/Features/UI/LockScreen.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class LockScreen : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Personalization";
+        private const string valueName = "NoLockScreen";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Don't use personalized lock screen";
+        }
+
+        public override string Info()
+        {
+            return "This feature will disable the personalized lock screen.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return !(
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/SearchBoxSuggestions.cs

@@ -0,0 +1,62 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.UI
+{
+    internal class DisableSearchBoxSuggestions : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\Explorer";
+        private const string valueName = "DisableSearchBoxSuggestions";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Search Box Suggestions";
+        }
+
+        public override string Info()
+        {
+            return "This feature disables Bing search and web suggestions in the Windows Start Menu.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return Utils.IntEquals(keyName, valueName, recommendedValue);
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, recommendedValue, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in DisableSearchBoxSuggestions: " + ex.Message, LogLevel.Error);
+                return Task.FromResult(false);
+            }
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord); // 0 = Enable suggestions
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error undoing DisableSearchBoxSuggestions: " + ex.Message, LogLevel.Error);
+                return false;
+            }
+        }
+    }
+}

src/MSCFixer/Features/UI/SearchboxTaskbarMode.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class SearchboxTaskbarMode : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Search";
+        private const string valueName = "SearchboxTaskbarMode";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Hide search box on taskbar";
+        }
+
+        public override string Info()
+        {
+            return "This feature will hide search box on taskbar";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 2, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/ShowOrHideMostUsedApps.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class ShowOrHideMostUsedApps : FeatureBase
+    {
+        private const string keyName = @"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Explorer";
+        private const string valueName = "ShowOrHideMostUsedApps";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Hide Most used apps in start menu";
+        }
+
+        public override string Info()
+        {
+            return "This feature will hide Most used apps in start menu";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 2, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/ShowTaskViewButton.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class ShowTaskViewButton : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "ShowTaskViewButton";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended: {recommendedValue} (Task View off – cleaner taskbar, unless you use it often)";
+        }
+
+        public override string ID()
+        {
+            return "Hide Task view button on taskbar";
+        }
+
+        public override string Info()
+        {
+            return "This feature will hide the Task view button on taskbar";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/SnapAssistFlyout.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class DisableSnapAssistFlyout : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "EnableSnapAssistFlyout";
+        private const int recommendedValue = 0; 
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Disable Snap Assist Flyout";
+        }
+
+        public override string Info()
+        {
+            return "This feature disables the Snap Assist flyout, which appears when you snap a window.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in DisableSnapAssistFlyout: " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in DisableSnapAssistFlyout (Undo): " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/StartLayout.cs

@@ -0,0 +1,66 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class StartLayout : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "Start_Layout";
+        private const int recommendedValue = 1;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Recommended Value: {recommendedValue}";
+        }
+
+        public override string ID()
+        {
+            return "Pin more Apps on start menu";
+        }
+
+        public override string Info()
+        {
+            return "This feature will allow pinning more Apps on start menu";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/TaskbarAlignment.cs

@@ -0,0 +1,67 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class TaskbarAlignment : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
+        private const string valueName = "TaskbarAl";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Suggested Value: {recommendedValue} (Left – feels like home if you're coming from Windows 10)";
+        }
+
+
+        public override string ID()
+        {
+            return "Align Start button to left";
+        }
+
+        public override string Info()
+        {
+            return "This feature will align the Start button to left";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Code red in " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}

src/MSCFixer/Features/UI/Transparency.cs

@@ -0,0 +1,67 @@
+using Microsoft.Win32;
+using System;
+using Crapfixer;
+using System.Threading.Tasks;
+
+namespace Settings.Personalization
+{
+    internal class Transparency : FeatureBase
+    {
+        private const string keyName = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
+        private const string valueName = "EnableTransparency";
+        private const int recommendedValue = 0;
+
+        public override string GetFeatureDetails()
+        {
+            return $"{keyName} | Value: {valueName} | Suggestion: {recommendedValue} (No transparency – smoother performance, still stylish)";
+        }
+
+
+        public override string ID()
+        {
+            return "Disable Transparency Effects";
+        }
+
+        public override string Info()
+        {
+            return "This feature disables transparency effects for Start menu, taskbar, and other surfaces.";
+        }
+
+        public override bool CheckFeature()
+        {
+            return (
+                   Utils.IntEquals(keyName, valueName, recommendedValue)
+             );
+        }
+
+        public override Task<bool> DoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 0, RegistryValueKind.DWord);
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in DisableTransparency: " + ex.Message, LogLevel.Error);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public override bool UndoFeature()
+        {
+            try
+            {
+                Registry.SetValue(keyName, valueName, 1, RegistryValueKind.DWord);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log("Error in DisableTransparency (Undo): " + ex.Message, LogLevel.Error);
+            }
+
+            return false;
+        }
+    }
+}