diff --git a/Directory.Build.props b/Directory.Build.props
index 580e61dafb..a856825d87 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -50,7 +50,7 @@
     <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
     <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
     <Company>ppy Pty Ltd</Company>
-    <Copyright>Copyright (c) 2024 ppy Pty Ltd</Copyright>
+    <Copyright>Copyright (c) 2025 ppy Pty Ltd</Copyright>
     <PackageTags>osu game</PackageTags>
   </PropertyGroup>
 </Project>
diff --git a/LICENCE b/LICENCE
index 3bb8b62d5d..9ffcc70c13 100644
--- a/LICENCE
+++ b/LICENCE
@@ -1,4 +1,4 @@
-Copyright (c) 2024 ppy Pty Ltd <contact@ppy.sh>.
+Copyright (c) 2025 ppy Pty Ltd <contact@ppy.sh>.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/Templates/osu.Game.Templates.csproj b/Templates/osu.Game.Templates.csproj
index 186a6093f5..ecac2e4794 100644
--- a/Templates/osu.Game.Templates.csproj
+++ b/Templates/osu.Game.Templates.csproj
@@ -8,7 +8,7 @@
     <PackageProjectUrl>https://github.com/ppy/osu/blob/master/Templates</PackageProjectUrl>
     <RepositoryUrl>https://github.com/ppy/osu</RepositoryUrl>
     <PackageReleaseNotes>Automated release.</PackageReleaseNotes>
-    <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+    <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
     <Description>Templates to use when creating a ruleset for consumption in osu!.</Description>
     <PackageTags>dotnet-new;templates;osu</PackageTags>
     <TargetFramework>netstandard2.1</TargetFramework>
diff --git a/osu.Android.props b/osu.Android.props
index de3fe31ee6..0509d86b0a 100644
--- a/osu.Android.props
+++ b/osu.Android.props
@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.704.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.718.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Android/OsuGameAndroid.cs b/osu.Android/OsuGameAndroid.cs
index 932fc8454e..71a71db73d 100644
--- a/osu.Android/OsuGameAndroid.cs
+++ b/osu.Android/OsuGameAndroid.cs
@@ -2,10 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using Android.App;
 using Android.Content.PM;
 using Microsoft.Maui.Devices;
 using osu.Framework.Allocation;
+using osu.Framework.Development;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Platform;
 using osu.Game;
@@ -21,58 +23,30 @@ namespace osu.Android
         [Cached]
         private readonly OsuGameActivity gameActivity;
 
+        private readonly PackageInfo packageInfo;
+
         public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
 
         public OsuGameAndroid(OsuGameActivity activity)
             : base(null)
         {
             gameActivity = activity;
+            packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
         }
 
-        public override Version AssemblyVersion
+        public override string Version
         {
             get
             {
-                var packageInfo = Application.Context.ApplicationContext!.PackageManager!.GetPackageInfo(Application.Context.ApplicationContext.PackageName!, 0).AsNonNull();
+                if (!IsDeployedBuild)
+                    return @"local " + (DebugUtils.IsDebugBuild ? @"debug" : @"release");
 
-                try
-                {
-                    // We store the osu! build number in the "VersionCode" field to better support google play releases.
-                    // If we were to use the main build number, it would require a new submission each time (similar to TestFlight).
-                    // In order to do this, we should split it up and pad the numbers to still ensure sequential increase over time.
-                    //
-                    // We also need to be aware that older SDK versions store this as a 32bit int.
-                    //
-                    // Basic conversion format (as done in Fastfile): 2020.606.0 -> 202006060
-
-                    // https://stackoverflow.com/questions/52977079/android-sdk-28-versioncode-in-packageinfo-has-been-deprecated
-                    string versionName;
-
-                    if (OperatingSystem.IsAndroidVersionAtLeast(28))
-                    {
-                        versionName = packageInfo.LongVersionCode.ToString();
-                        // ensure we only read the trailing portion of long (the part we are interested in).
-                        versionName = versionName.Substring(versionName.Length - 9);
-                    }
-                    else
-                    {
-#pragma warning disable CS0618 // Type or member is obsolete
-                        // this is required else older SDKs will report missing method exception.
-                        versionName = packageInfo.VersionCode.ToString();
-#pragma warning restore CS0618 // Type or member is obsolete
-                    }
-
-                    // undo play store version garbling (as mentioned above).
-                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
-                }
-                catch
-                {
-                }
-
-                return new Version(packageInfo.VersionName.AsNonNull());
+                return packageInfo.VersionName.AsNonNull();
             }
         }
 
+        public override Version AssemblyVersion => new Version(packageInfo.VersionName.AsNonNull().Split('-').First());
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
diff --git a/osu.Desktop.slnf b/osu.Desktop.slnf
index 46e52044f4..e7f96935e8 100644
--- a/osu.Desktop.slnf
+++ b/osu.Desktop.slnf
@@ -1,32 +1,32 @@
 {
-    "solution":  {
-                     "path":  "osu.sln",
-                     "projects":  [
-                                      "..\\osu-resources\\osu.Game.Resources\\osu.Game.Resources.csproj",
-                                      "osu.Desktop\\osu.Desktop.csproj",
-                                      "osu.Game.Benchmarks\\osu.Game.Benchmarks.csproj",
-                                      "osu.Game.Rulesets.Catch.Tests\\osu.Game.Rulesets.Catch.Tests.csproj",
-                                      "osu.Game.Rulesets.Catch\\osu.Game.Rulesets.Catch.csproj",
-                                      "osu.Game.Rulesets.Mania.Tests\\osu.Game.Rulesets.Mania.Tests.csproj",
-                                      "osu.Game.Rulesets.Mania\\osu.Game.Rulesets.Mania.csproj",
-                                      "osu.Game.Rulesets.Osu.Tests\\osu.Game.Rulesets.Osu.Tests.csproj",
-                                      "osu.Game.Rulesets.Osu\\osu.Game.Rulesets.Osu.csproj",
-                                      "osu.Game.Rulesets.Taiko.Tests\\osu.Game.Rulesets.Taiko.Tests.csproj",
-                                      "osu.Game.Rulesets.Taiko\\osu.Game.Rulesets.Taiko.csproj",
-                                      "osu.Game.Tests\\osu.Game.Tests.csproj",
-                                      "osu.Game.Tournament.Tests\\osu.Game.Tournament.Tests.csproj",
-                                      "osu.Game.Tournament\\osu.Game.Tournament.csproj",
-                                      "osu.Game\\osu.Game.csproj",
-                                      "Templates\\Rulesets\\ruleset-empty\\osu.Game.Rulesets.EmptyFreeform.Tests\\osu.Game.Rulesets.EmptyFreeform.Tests.csproj",
-                                      "Templates\\Rulesets\\ruleset-empty\\osu.Game.Rulesets.EmptyFreeform\\osu.Game.Rulesets.EmptyFreeform.csproj",
-                                      "Templates\\Rulesets\\ruleset-example\\osu.Game.Rulesets.Pippidon.Tests\\osu.Game.Rulesets.Pippidon.Tests.csproj",
-                                      "Templates\\Rulesets\\ruleset-example\\osu.Game.Rulesets.Pippidon\\osu.Game.Rulesets.Pippidon.csproj",
-                                      "Templates\\Rulesets\\ruleset-scrolling-empty\\osu.Game.Rulesets.EmptyScrolling.Tests\\osu.Game.Rulesets.EmptyScrolling.Tests.csproj",
-                                      "Templates\\Rulesets\\ruleset-scrolling-empty\\osu.Game.Rulesets.EmptyScrolling\\osu.Game.Rulesets.EmptyScrolling.csproj",
-                                      "Templates\\Rulesets\\ruleset-scrolling-example\\osu.Game.Rulesets.Pippidon.Tests\\osu.Game.Rulesets.Pippidon.Tests.csproj",
-                                      "Templates\\Rulesets\\ruleset-scrolling-example\\osu.Game.Rulesets.Pippidon\\osu.Game.Rulesets.Pippidon.csproj",
-                                      "../osu-framework/osu.Framework/osu.Framework.csproj",
-                                      "../osu-framework/osu.Framework.NativeLibs/osu.Framework.NativeLibs.csproj"
-                                  ]
-                 }
-}
+  "solution": {
+    "path": "osu.sln",
+    "projects": [
+      "..\\osu-framework\\osu.Framework.NativeLibs\\osu.Framework.NativeLibs.csproj",
+      "..\\osu-framework\\osu.Framework\\osu.Framework.csproj",
+      "..\\osu-resources\\osu.Game.Resources\\osu.Game.Resources.csproj",
+      "osu.Desktop\\osu.Desktop.csproj",
+      "osu.Game.Benchmarks\\osu.Game.Benchmarks.csproj",
+      "osu.Game.Rulesets.Catch.Tests\\osu.Game.Rulesets.Catch.Tests.csproj",
+      "osu.Game.Rulesets.Catch\\osu.Game.Rulesets.Catch.csproj",
+      "osu.Game.Rulesets.Mania.Tests\\osu.Game.Rulesets.Mania.Tests.csproj",
+      "osu.Game.Rulesets.Mania\\osu.Game.Rulesets.Mania.csproj",
+      "osu.Game.Rulesets.Osu.Tests\\osu.Game.Rulesets.Osu.Tests.csproj",
+      "osu.Game.Rulesets.Osu\\osu.Game.Rulesets.Osu.csproj",
+      "osu.Game.Rulesets.Taiko.Tests\\osu.Game.Rulesets.Taiko.Tests.csproj",
+      "osu.Game.Rulesets.Taiko\\osu.Game.Rulesets.Taiko.csproj",
+      "osu.Game.Tests\\osu.Game.Tests.csproj",
+      "osu.Game.Tournament.Tests\\osu.Game.Tournament.Tests.csproj",
+      "osu.Game.Tournament\\osu.Game.Tournament.csproj",
+      "osu.Game\\osu.Game.csproj",
+      "Templates\\Rulesets\\ruleset-empty\\osu.Game.Rulesets.EmptyFreeform.Tests\\osu.Game.Rulesets.EmptyFreeform.Tests.csproj",
+      "Templates\\Rulesets\\ruleset-empty\\osu.Game.Rulesets.EmptyFreeform\\osu.Game.Rulesets.EmptyFreeform.csproj",
+      "Templates\\Rulesets\\ruleset-example\\osu.Game.Rulesets.Pippidon.Tests\\osu.Game.Rulesets.Pippidon.Tests.csproj",
+      "Templates\\Rulesets\\ruleset-example\\osu.Game.Rulesets.Pippidon\\osu.Game.Rulesets.Pippidon.csproj",
+      "Templates\\Rulesets\\ruleset-scrolling-empty\\osu.Game.Rulesets.EmptyScrolling.Tests\\osu.Game.Rulesets.EmptyScrolling.Tests.csproj",
+      "Templates\\Rulesets\\ruleset-scrolling-empty\\osu.Game.Rulesets.EmptyScrolling\\osu.Game.Rulesets.EmptyScrolling.csproj",
+      "Templates\\Rulesets\\ruleset-scrolling-example\\osu.Game.Rulesets.Pippidon.Tests\\osu.Game.Rulesets.Pippidon.Tests.csproj",
+      "Templates\\Rulesets\\ruleset-scrolling-example\\osu.Game.Rulesets.Pippidon\\osu.Game.Rulesets.Pippidon.csproj"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/osu.Desktop/OsuGameDesktop.cs b/osu.Desktop/OsuGameDesktop.cs
index 7290761d56..885ee0620e 100644
--- a/osu.Desktop/OsuGameDesktop.cs
+++ b/osu.Desktop/OsuGameDesktop.cs
@@ -123,7 +123,7 @@ namespace osu.Desktop
 
         public override bool RestartAppWhenExited()
         {
-            Task.Run(() => Velopack.UpdateExe.Start()).FireAndForget();
+            Task.Run(() => Velopack.UpdateExe.Start(waitPid: (uint)Environment.ProcessId)).FireAndForget();
             return true;
         }
 
diff --git a/osu.Desktop/Updater/VelopackUpdateManager.cs b/osu.Desktop/Updater/VelopackUpdateManager.cs
index 3b79313f8c..cba050c638 100644
--- a/osu.Desktop/Updater/VelopackUpdateManager.cs
+++ b/osu.Desktop/Updater/VelopackUpdateManager.cs
@@ -53,33 +53,44 @@ namespace osu.Desktop.Updater
                 return false;
             }
 
-            IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
-            Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
+            try
             {
-                AllowVersionDowngrade = true
-            });
+                IUpdateSource updateSource = new GithubSource(@"https://github.com/ppy/osu", null, ReleaseStream.Value == Game.Configuration.ReleaseStream.Tachyon);
+                Velopack.UpdateManager updateManager = new Velopack.UpdateManager(updateSource, new UpdateOptions
+                {
+                    AllowVersionDowngrade = true
+                });
 
-            UpdateInfo? update = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
+                UpdateInfo? update = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
 
-            if (cancellationToken.IsCancellationRequested)
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    log("Update check cancelled");
+                    scheduleNextUpdateCheck();
+                    return true;
+                }
+
+                if (update == null)
+                {
+                    // No update is available.
+                    log("No update found");
+                    scheduleNextUpdateCheck();
+                    return false;
+                }
+
+                // Download update in the background while notifying awaiters of the update being available.
+                log($"New update available: {update.TargetFullRelease.Version}");
+                downloadUpdate(updateManager, update, cancellationToken);
+                return true;
+            }
+            catch (Exception e)
             {
-                log("Update check cancelled");
+                log($"Update check failed with error ({e.Message})");
+
+                // we shouldn't crash on a web failure. or any failure for the matter.
                 scheduleNextUpdateCheck();
                 return true;
             }
-
-            if (update == null)
-            {
-                // No update is available.
-                log("No update found");
-                scheduleNextUpdateCheck();
-                return false;
-            }
-
-            // Download update in the background while notifying awaiters of the update being available.
-            log($"New update available: {update.TargetFullRelease.Version}");
-            downloadUpdate(updateManager, update, cancellationToken);
-            return true;
         }
 
         private void downloadUpdate(Velopack.UpdateManager updateManager, UpdateInfo update, CancellationToken cancellationToken) => Task.Run(async () =>
diff --git a/osu.Desktop/osu.nuspec b/osu.Desktop/osu.nuspec
index 66b3970351..14af4d0334 100644
--- a/osu.Desktop/osu.nuspec
+++ b/osu.Desktop/osu.nuspec
@@ -12,7 +12,7 @@
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
         <description>A free-to-win rhythm game. Rhythm is just a *click* away!</description>
         <releaseNotes>testing</releaseNotes>
-        <copyright>Copyright (c) 2024 ppy Pty Ltd</copyright>
+        <copyright>Copyright (c) 2025 ppy Pty Ltd</copyright>
         <language>en-AU</language>
     </metadata>
     <files>
diff --git a/osu.Game.Rulesets.Catch.Tests/CatchRateAdjustedDisplayDifficultyTest.cs b/osu.Game.Rulesets.Catch.Tests/CatchRateAdjustedDisplayDifficultyTest.cs
index f77ec64df3..0ec3bfd911 100644
--- a/osu.Game.Rulesets.Catch.Tests/CatchRateAdjustedDisplayDifficultyTest.cs
+++ b/osu.Game.Rulesets.Catch.Tests/CatchRateAdjustedDisplayDifficultyTest.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Mods;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, []);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
         }
@@ -33,7 +34,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new CatchModHalfTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
         }
@@ -44,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new CatchModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(7.67).Within(0.01));
         }
diff --git a/osu.Game.Rulesets.Catch/CatchRuleset.cs b/osu.Game.Rulesets.Catch/CatchRuleset.cs
index d253b9893f..c7487df0c2 100644
--- a/osu.Game.Rulesets.Catch/CatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/CatchRuleset.cs
@@ -33,6 +33,7 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch
@@ -265,9 +266,10 @@ namespace osu.Game.Rulesets.Catch
         }
 
         /// <seealso cref="CatchHitObject.ApplyDefaultsToSelf"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, IReadOnlyCollection<Mod> mods)
         {
             BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, CatchHitObject.PREEMPT_MAX, CatchHitObject.PREEMPT_MID, CatchHitObject.PREEMPT_MIN);
             preempt /= rate;
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs b/osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs
index f2c77d6a05..f40d2bb45e 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Mods
@@ -9,5 +10,12 @@ namespace osu.Game.Rulesets.Catch.Mods
     public class CatchModEasy : ModEasyWithExtraLives
     {
         public override LocalisableString Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!";
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty *= ADJUST_RATIO;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs b/osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs
index 62fded0980..f7d64dc57b 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs
@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             base.ApplyToDifficulty(difficulty);
 
+            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
             difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
             difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
         }
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaLegacyModConversionTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaLegacyModConversionTest.cs
index cb2abc1595..2ffc1ee0ef 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaLegacyModConversionTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaLegacyModConversionTest.cs
@@ -5,7 +5,6 @@ using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
@@ -38,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { LegacyMods.Key2, new[] { typeof(ManiaModKey2) } },
             new object[] { LegacyMods.Mirror, new[] { typeof(ManiaModMirror) } },
             new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(ManiaModHardRock), typeof(ManiaModDoubleTime) } },
-            new object[] { LegacyMods.ScoreV2, new[] { typeof(ModScoreV2) } },
+            new object[] { LegacyMods.ScoreV2, new[] { typeof(ManiaModScoreV2) } },
         };
 
         [TestCaseSource(nameof(mania_mod_mapping))]
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
index 2c17cd8015..f95c0c186f 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
@@ -9,7 +9,6 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -521,14 +520,13 @@ namespace osu.Game.Rulesets.Mania.Tests
                 ScoreInfo = new ScoreInfo
                 {
                     Ruleset = CreateRuleset().RulesetInfo,
-                    Mods = [new ModScoreV2()]
+                    Mods = [new ManiaModScoreV2()]
                 }
             };
 
             RunTest($@"SV2 single note @ OD{overallDifficulty}", beatmap, $@"SV2 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1NonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -556,7 +554,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1 single note @ OD{overallDifficulty}", beatmap, $@"SV1 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_convert_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1Convert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -585,7 +582,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_hard_rock_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndHardRockNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -614,7 +610,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+HR single note @ OD{overallDifficulty}", beatmap, $@"SV1+HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_easy_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndEasyNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -643,7 +638,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+EZ single note @ OD{overallDifficulty}", beatmap, $@"SV1+EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_double_time_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndDoubleTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -672,7 +666,6 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+DT single note @ OD{overallDifficulty}", beatmap, $@"SV1+DT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
-        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_half_time_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndHalfTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
diff --git a/osu.Game.Rulesets.Mania/LAsEZMania/ManiaKeyCounterDisplay.cs b/osu.Game.Rulesets.Mania/LAsEZMania/ManiaKeyCounterDisplay.cs
index 6970bb5c60..394d430bee 100644
--- a/osu.Game.Rulesets.Mania/LAsEZMania/ManiaKeyCounterDisplay.cs
+++ b/osu.Game.Rulesets.Mania/LAsEZMania/ManiaKeyCounterDisplay.cs
@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Mania.LAsEZMania
                 float width = (float)columnWidth.Value;
                 int index = KeyFlow.IndexOf(counter);
 
-                if (ezSkinConfig.GetColumnType(StageDefinition.Columns, index) == "S1")
+                if (ezSkinConfig.GetColumnType(StageDefinition.Columns, index) == "S")
                     width *= (float)specialFactor.Value;
 
                 counter.Width = width;
diff --git a/osu.Game.Rulesets.Mania/ManiaRuleset.cs b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
index e54c3b8e08..5f0a12cf51 100644
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@@ -191,7 +191,7 @@ namespace osu.Game.Rulesets.Mania
                 yield return new ManiaModMirror();
 
             if (mods.HasFlag(LegacyMods.ScoreV2))
-                yield return new ModScoreV2();
+                yield return new ManiaModScoreV2();
         }
 
         public override LegacyMods ConvertToLegacyMods(Mod[] mods)
@@ -356,7 +356,7 @@ namespace osu.Game.Rulesets.Mania
                 case ModType.System:
                     return new Mod[]
                     {
-                        new ModScoreV2(),
+                        new ManiaModScoreV2(),
                     };
 
                 default:
@@ -490,6 +490,32 @@ namespace osu.Game.Rulesets.Mania
             return statistics.ToArray();
         }
 
+        /// <seealso cref="ManiaHitWindows"/>
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, IReadOnlyCollection<Mod> mods)
+        {
+            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+
+            // notably, in mania, hit windows are designed to be independent of track playback rate (see `ManiaHitWindows.SpeedMultiplier`).
+            // *however*, to not make matters *too* simple, mania Hard Rock and Easy differ from all other rulesets
+            // in that they apply multipliers *to hit window durations directly* rather than to the Overall Difficulty attribute itself.
+            // because the duration of hit window durations as a function of OD is not a linear function,
+            // this means that multiplying the OD is *not* the same thing as multiplying the hit window duration.
+            // in fact, the second operation is *much* harsher and will produce values much farther outside of normal operating range
+            // (even negative in the case of Easy).
+            // stable handles this wrong on song select and just assumes that it can handle mania EZ / HR the same way as all other rulesets.
+
+            double perfectHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, ManiaHitWindows.PERFECT_WINDOW_RANGE);
+
+            if (mods.Any(m => m is ManiaModHardRock))
+                perfectHitWindow /= ManiaModHardRock.HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+            else if (mods.Any(m => m is ManiaModEasy))
+                perfectHitWindow /= ManiaModEasy.HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+
+            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(perfectHitWindow, ManiaHitWindows.PERFECT_WINDOW_RANGE);
+
+            return adjustedDifficulty;
+        }
+
         public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
         {
             return new ManiaFilterCriteria();
diff --git a/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs b/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs
index ea01bd4436..ca364a1ec8 100644
--- a/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs
+++ b/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs
@@ -2,12 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -17,29 +15,21 @@ namespace osu.Game.Rulesets.Mania.Mods
     /// <remarks>
     /// Historically, in osu!mania, hit windows are expected to adjust relative to the gameplay rate such that the real-world hit window remains the same.
     /// </remarks>
-    public interface IManiaRateAdjustmentMod : IApplicableToDifficulty, IApplicableToHitObject
+    public interface IManiaRateAdjustmentMod : IApplicableToHitObject
     {
         BindableNumber<double> SpeedChange { get; }
 
-        HitWindows HitWindows { get; set; }
-
-        void IApplicableToDifficulty.ApplyToDifficulty(BeatmapDifficulty difficulty)
-        {
-            HitWindows = new ManiaHitWindows(SpeedChange.Value);
-            HitWindows.SetDifficulty(difficulty.OverallDifficulty);
-        }
-
         void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
         {
             switch (hitObject)
             {
                 case Note:
-                    hitObject.HitWindows = HitWindows;
+                    ((ManiaHitWindows)hitObject.HitWindows).SpeedMultiplier = SpeedChange.Value;
                     break;
 
                 case HoldNote hold:
-                    hold.Head.HitWindows = HitWindows;
-                    hold.Tail.HitWindows = HitWindows;
+                    ((ManiaHitWindows)hold.Head.HitWindows).SpeedMultiplier = SpeedChange.Value;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).SpeedMultiplier = SpeedChange.Value;
                     break;
             }
         }
diff --git a/osu.Game.Rulesets.Mania/Mods/LAsMods/ManiaModSpaceBody.cs b/osu.Game.Rulesets.Mania/Mods/LAsMods/ManiaModSpaceBody.cs
index 4844704894..0937f2ec43 100644
--- a/osu.Game.Rulesets.Mania/Mods/LAsMods/ManiaModSpaceBody.cs
+++ b/osu.Game.Rulesets.Mania/Mods/LAsMods/ManiaModSpaceBody.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.Mods.LAsMods
         public override string Acronym => "SB";
         public override double ScoreMultiplier => 1;
 
-        public override LocalisableString Description => "LaMod: Hold the keys. Adjust the gaps.";
+        public override LocalisableString Description => "LaMod: Full LN 面海, 可调面缝";
 
         public override ModType Type => ModType.CustomMod;
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs b/osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs
index 88d6a19822..8ff131d3c8 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => Name;
         public abstract int KeyCount { get; }
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 1; // TODO: Implement the mania key mod score multiplier
+        public override double ScoreMultiplier => 0.9;
         public override bool Ranked => UsesDefaultConfiguration;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModClassic.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModClassic.cs
index 073dda9de8..5e46250dd2 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModClassic.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModClassic.cs
@@ -1,11 +1,41 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModClassic : ModClassic
+    public class ManiaModClassic : ModClassic, IApplicableToBeatmap
     {
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            bool isConvert = !beatmap.BeatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+
+            foreach (var ho in beatmap.HitObjects)
+            {
+                switch (ho)
+                {
+                    case Note note:
+                    {
+                        var hitWindows = (ManiaHitWindows)note.HitWindows;
+                        hitWindows.IsConvert = isConvert;
+                        hitWindows.ClassicModActive = true;
+                        break;
+                    }
+
+                    case HoldNote hold:
+                    {
+                        var headWindows = (ManiaHitWindows)hold.Head.HitWindows;
+                        var tailWindows = (ManiaHitWindows)hold.Tail.HitWindows;
+                        headWindows.IsConvert = tailWindows.IsConvert = isConvert;
+                        headWindows.ClassicModActive = tailWindows.ClassicModActive = true;
+                        break;
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs
index dbe2a9a9fc..9e9d671006 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs
@@ -1,14 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDaycore : ModDaycore, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs
index bea1a14110..043fa1c40c 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs
@@ -1,16 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDoubleTime : ModDoubleTime, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
-
         // For now, all rate-increasing mods should be given a 1x multiplier in mania because it doesn't always
         // make the map harder and is more of a personal preference.
         // In the future, we can consider adjusting this by experimenting with not applying the hitwindow leniency.
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
index 275643ca44..16872c45c4 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
@@ -2,12 +2,32 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModEasy : ModEasyWithExtraLives
+    public class ManiaModEasy : ModEasyWithExtraLives, IApplicableToHitObject
     {
         public override LocalisableString Description => @"More forgiving HP drain, less accuracy required, and extra lives!";
+
+        public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1 / 1.4;
+
+        void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Note:
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+
+                case HoldNote hold:
+                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs
index b0fbb11396..f8d2758914 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs
@@ -1,14 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModHalfTime : ModHalfTime, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
index 189c4b3a5f..13f86bd641 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
@@ -1,13 +1,33 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModHardRock : ModHardRock
+    public class ManiaModHardRock : ModHardRock, IApplicableToHitObject
     {
         public override double ScoreMultiplier => 1;
         public override bool Ranked => false;
+
+        public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;
+
+        void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Note:
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+
+                case HoldNote hold:
+                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
+                    break;
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
index 7e5e80db6c..0eb4ddc7d0 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
@@ -2,16 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModNightcore : ModNightcore<ManiaHitObject>, IManiaRateAdjustmentMod
     {
-        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
-
         // For now, all rate-increasing mods should be given a 1x multiplier in mania because it doesn't always
         // make the map any harder and is more of a personal preference.
         // In the future, we can consider adjusting this by experimenting with not applying the hitwindow leniency.
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModScoreV2.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModScoreV2.cs
new file mode 100644
index 0000000000..46bb75a480
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModScoreV2.cs
@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Mania.Mods
+{
+    public class ManiaModScoreV2 : ModScoreV2, IApplicableToBeatmap
+    {
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            foreach (var ho in beatmap.HitObjects)
+            {
+                switch (ho)
+                {
+                    case Note note:
+                    {
+                        var hitWindows = (ManiaHitWindows)note.HitWindows;
+                        hitWindows.ScoreV2Active = true;
+                        break;
+                    }
+
+                    case HoldNote hold:
+                    {
+                        var headWindows = (ManiaHitWindows)hold.Head.HitWindows;
+                        var tailWindows = (ManiaHitWindows)hold.Tail.HitWindows;
+                        headWindows.ScoreV2Active = tailWindows.ScoreV2Active = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
index 28e6447656..ca75009c68 100644
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
@@ -9,14 +9,91 @@ namespace osu.Game.Rulesets.Mania.Scoring
 {
     public class ManiaHitWindows : HitWindows
     {
-        private static readonly DifficultyRange perfect_window_range = new DifficultyRange(22.4D, 19.4D, 13.9D);
+        public static readonly DifficultyRange PERFECT_WINDOW_RANGE = new DifficultyRange(22.4D, 19.4D, 13.9D);
         private static readonly DifficultyRange great_window_range = new DifficultyRange(64, 49, 34);
         private static readonly DifficultyRange good_window_range = new DifficultyRange(97, 82, 67);
         private static readonly DifficultyRange ok_window_range = new DifficultyRange(127, 112, 97);
         private static readonly DifficultyRange meh_window_range = new DifficultyRange(151, 136, 121);
         private static readonly DifficultyRange miss_window_range = new DifficultyRange(188, 173, 158);
 
-        private readonly double multiplier;
+        private double speedMultiplier = 1;
+
+        /// <summary>
+        /// Multiplier used to compensate for the playback speed of the track speeding up or slowing down.
+        /// The goal of this multiplier is to keep hit windows independent of track speed.
+        /// <list type="bullet">
+        /// <item>When the track speed is above 1, the hit window ranges are multiplied by <see cref="SpeedMultiplier"/>, because the time elapses faster.</item>
+        /// <item>When the track speed is below 1, the hit window ranges are also multiplied by <see cref="SpeedMultiplier"/>, because the time elapses slower.</item>
+        /// </list>
+        /// </summary>
+        public double SpeedMultiplier
+        {
+            get => speedMultiplier;
+            set
+            {
+                speedMultiplier = value;
+                updateWindows();
+            }
+        }
+
+        private double difficultyMultiplier = 1;
+
+        /// <summary>
+        /// Multiplier used to make the gameplay more or less difficult.
+        /// <list type="bullet">
+        /// <item>When the <see cref="DifficultyMultiplier"/> is above 1, the hit windows decrease to make the gameplay harder.</item>
+        /// <item>When the <see cref="DifficultyMultiplier"/> is below 1, the hit windows increase to make the gameplay easier.</item>
+        /// </list>
+        /// </summary>
+        public double DifficultyMultiplier
+        {
+            get => difficultyMultiplier;
+            set
+            {
+                difficultyMultiplier = value;
+                updateWindows();
+            }
+        }
+
+        private double totalMultiplier => speedMultiplier / difficultyMultiplier;
+
+        private double overallDifficulty;
+
+        private bool classicModActive;
+
+        public bool ClassicModActive
+        {
+            get => classicModActive;
+            set
+            {
+                classicModActive = value;
+                updateWindows();
+            }
+        }
+
+        private bool scoreV2Active;
+
+        public bool ScoreV2Active
+        {
+            get => scoreV2Active;
+            set
+            {
+                scoreV2Active = value;
+                updateWindows();
+            }
+        }
+
+        private bool isConvert;
+
+        public bool IsConvert
+        {
+            get => isConvert;
+            set
+            {
+                isConvert = value;
+                updateWindows();
+            }
+        }
 
         private double perfect;
         private double great;
@@ -25,16 +102,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         private double meh;
         private double miss;
 
-        public ManiaHitWindows()
-            : this(1)
-        {
-        }
-
-        public ManiaHitWindows(double multiplier)
-        {
-            this.multiplier = multiplier;
-        }
-
         public override bool IsHitResultAllowed(HitResult result)
         {
             switch (result)
@@ -55,12 +122,44 @@ namespace osu.Game.Rulesets.Mania.Scoring
 
         public override void SetDifficulty(double difficulty)
         {
-            perfect = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, perfect_window_range) * multiplier) + 0.5;
-            great = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, great_window_range) * multiplier) + 0.5;
-            good = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, good_window_range) * multiplier) + 0.5;
-            ok = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, ok_window_range) * multiplier) + 0.5;
-            meh = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, meh_window_range) * multiplier) + 0.5;
-            miss = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, miss_window_range) * multiplier) + 0.5;
+            overallDifficulty = difficulty;
+            updateWindows();
+        }
+
+        private void updateWindows()
+        {
+            if (ClassicModActive && !ScoreV2Active)
+            {
+                if (IsConvert)
+                {
+                    perfect = Math.Floor(16 * totalMultiplier) + 0.5;
+                    great = Math.Floor((Math.Round(overallDifficulty) > 4 ? 34 : 47) * totalMultiplier) + 0.5;
+                    good = Math.Floor((Math.Round(overallDifficulty) > 4 ? 67 : 77) * totalMultiplier) + 0.5;
+                    ok = Math.Floor(97 * totalMultiplier) + 0.5;
+                    meh = Math.Floor(121 * totalMultiplier) + 0.5;
+                    miss = Math.Floor(158 * totalMultiplier) + 0.5;
+                }
+                else
+                {
+                    double invertedOd = Math.Clamp(10 - overallDifficulty, 0, 10);
+
+                    perfect = Math.Floor(16 * totalMultiplier) + 0.5;
+                    great = Math.Floor((34 + 3 * invertedOd) * totalMultiplier) + 0.5;
+                    good = Math.Floor((67 + 3 * invertedOd) * totalMultiplier) + 0.5;
+                    ok = Math.Floor((97 + 3 * invertedOd) * totalMultiplier) + 0.5;
+                    meh = Math.Floor((121 + 3 * invertedOd) * totalMultiplier) + 0.5;
+                    miss = Math.Floor((158 + 3 * invertedOd) * totalMultiplier) + 0.5;
+                }
+            }
+            else
+            {
+                perfect = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, PERFECT_WINDOW_RANGE) * totalMultiplier) + 0.5;
+                great = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, great_window_range) * totalMultiplier) + 0.5;
+                good = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, good_window_range) * totalMultiplier) + 0.5;
+                ok = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, ok_window_range) * totalMultiplier) + 0.5;
+                meh = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, meh_window_range) * totalMultiplier) + 0.5;
+                miss = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, miss_window_range) * totalMultiplier) + 0.5;
+            }
         }
 
         public override double WindowFor(HitResult result)
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitExplosion.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitExplosion.cs
index 12f90c5f58..6a71a830ee 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitExplosion.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitExplosion.cs
@@ -2,44 +2,29 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Screens;
 using osu.Game.Screens.LAsEzExtensions;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
-    public partial class EzHitExplosion : CompositeDrawable, IHitExplosion
+    public partial class EzHitExplosion : EzNoteBase, IHitExplosion
     {
-        private TextureAnimation? animation;
-        private TextureAnimation? animationP;
-        private Container container = null!;
-
-        private IBindable<double> noteHeightBindable = new Bindable<double>();
-        private IBindable<double> columnWidthBindable = new Bindable<double>();
-        private IBindable<double> specialFactorBindable = new Bindable<double>();
+        protected override bool BoolUpdateColor => false;
 
         // public override bool RemoveWhenNotAlive => true;
 
-        [Resolved]
-        private Column column { get; set; } = null!;
-
-        [Resolved]
-        private StageDefinition stageDefinition { get; set; } = null!;
-
-        [Resolved]
-        private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
-
         [Resolved]
         private EzLocalTextureFactory factory { get; set; } = null!;
 
+        private TextureAnimation? primaryAnimation;
+        private TextureAnimation? goodAnimation;
+        private bool animationsCreated;
+
         public EzHitExplosion()
         {
             RelativeSizeAxes = Axes.Both;
@@ -51,78 +36,54 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         {
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
-
-            noteHeightBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight);
-            columnWidthBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth);
-            specialFactorBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.SpecialFactor);
-
-            noteHeightBindable.BindValueChanged(_ => updateY(), true);
-            columnWidthBindable.BindValueChanged(_ => updateY(), true);
-            specialFactorBindable.BindValueChanged(_ => updateY(), true);
+            OnDrawableChanged();
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            onSkinChanged();
-            factory.OnNoteChanged += onSkinChanged;
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (isDisposing) { factory.OnNoteChanged -= onSkinChanged; }
-        }
-
-        private void loadAnimation()
+        protected override void OnDrawableChanged()
         {
             ClearInternal();
+            primaryAnimation = null;
+            goodAnimation = null;
 
-            animation = factory.CreateAnimation("noteflare");
-            animationP = factory.CreateAnimation("noteflaregood");
+            primaryAnimation = factory.CreateAnimation("noteflare");
+            goodAnimation = factory.CreateAnimation("noteflaregood");
 
-            container = new Container
+            if (primaryAnimation?.FrameCount > 0)
+                AddInternal(primaryAnimation);
+
+            if (goodAnimation?.FrameCount > 0)
             {
-                Anchor = Anchor.BottomCentre,
-                Origin = Anchor.BottomCentre,
-                RelativeSizeAxes = Axes.None,
-                Children = new Drawable[]
-                    { animation },
-            };
+                goodAnimation.Alpha = 0;
+                AddInternal(goodAnimation);
+            }
 
-            AddInternal(container);
-            updateY();
+            animationsCreated = true;
         }
 
-        private void updateY()
+        protected override void UpdateSize()
         {
-            bool isSpecialColumn = ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1";
-            double columnWidth = columnWidthBindable.Value * (isSpecialColumn ? specialFactorBindable.Value : 1);
-
-            bool isSquare = factory.IsSquareNote("whitenote");
-            float aspectRatio = factory.GetRatio("whitenote");
-
-            float moveY = isSquare
-                ? (float)columnWidth / 2 * aspectRatio
-                : (float)noteHeightBindable.Value / 2 * aspectRatio;
-
+            base.UpdateSize();
+            float moveY = NoteSize.Value.Y / 2;
             // baseYPosition = LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION - (float)hitPosition.Value - moveY;
             Position = new Vector2(0, -moveY);
         }
 
-        private void onSkinChanged()
-        {
-            loadAnimation();
-        }
-
         public void Animate(JudgementResult result)
         {
-            loadAnimation();
+            if (!animationsCreated) OnDrawableChanged();
 
-            if (result.Type > HitResult.Great)
+            if (primaryAnimation?.FrameCount > 0)
             {
-                if (animationP != null) container.Add(animationP);
+                primaryAnimation.Alpha = 1;
+                primaryAnimation.GotoFrame(0);
+                primaryAnimation.Restart();
+            }
+
+            if (result.Type >= HitResult.Great && goodAnimation?.FrameCount > 0)
+            {
+                goodAnimation.Alpha = 1;
+                goodAnimation.GotoFrame(0);
+                goodAnimation.Restart();
             }
         }
     }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitTarget.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitTarget.cs
index 2b04878056..77f19cc6a0 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitTarget.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHitTarget.cs
@@ -11,10 +11,10 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
     internal partial class EzHitTarget : EzNote
     {
-        // private IBindable<double> hitPosition = new Bindable<double>();
-
-        protected override bool ShowSeparators => false;
+        protected override bool BoolUpdateColor => false;
         protected override bool UseColorization => false;
+        protected override bool ShowSeparators => false;
+
         protected override string ColorPrefix => "white";
 
         [Resolved]
@@ -23,9 +23,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         [Resolved]
         private IGameplayClock gameplayClock { get; set; } = null!;
 
-        // [Resolved]
-        // private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
-
         public EzHitTarget()
         {
             RelativeSizeAxes = Axes.X;
@@ -38,11 +35,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         {
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
-            // hitPosition = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
-            // hitPosition.BindValueChanged(_ => updateY(), true);
         }
 
-        // private float baseYPosition = 0f;
         private double beatInterval;
 
         protected override void LoadComplete()
@@ -61,12 +55,5 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             double smoothValue = 0.3 * Math.Sin(progress * 2 * Math.PI);
             Y = (float)(smoothValue * 6);
         }
-
-        //DrawableManiaRuleset中关联设置后，此处不必设置
-        // private void updateY()
-        // {
-        //     baseYPosition = LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION - (float)hitPosition.Value;
-        //     Position = new Vector2(0, baseYPosition);
-        // }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHead.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHead.cs
index c3e3684a75..c6488c9119 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHead.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHead.cs
@@ -2,205 +2,79 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Screens;
-using osu.Game.Screens.LAsEzExtensions;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
-    public partial class EzHoldNoteHead : CompositeDrawable
+    public partial class EzHoldNoteHead : EzNoteBase
     {
-        private Bindable<bool> enabledColor = null!;
-        private Bindable<double> nonSquareNoteHeight = null!;
-
-        private TextureAnimation animation = null!;
-        private Container container = null!;
-        private EzNoteSideLine? noteSeparatorsL;
-        private EzNoteSideLine? noteSeparatorsR;
-
-        [Resolved]
-        private Column column { get; set; } = null!;
-
-        [Resolved]
-        private StageDefinition stageDefinition { get; set; } = null!;
-
-        [Resolved]
-        private EzLocalTextureFactory factory { get; set; } = null!;
-
-        [Resolved]
-        private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
+        protected override bool ShowSeparators => true;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             RelativeSizeAxes = Axes.X;
             FillMode = FillMode.Fill;
-
-            nonSquareNoteHeight = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight);
-            enabledColor = ezSkinConfig.GetBindable<bool>(EzSkinSetting.ColorSettingsEnabled);
-            OnSkinChanged();
         }
 
-        protected override void LoadComplete()
+        protected override void OnDrawableChanged()
         {
-            base.LoadComplete();
+            string newComponentName = $"{ColorPrefix}longnote/head";
 
-            nonSquareNoteHeight.BindValueChanged(_ => updateSizes(), true);
-            ezSkinConfig.OnSettingsChanged += OnConfigChanged;
-            factory.OnNoteChanged += OnSkinChanged;
-        }
+            var animation = Factory.CreateAnimation(newComponentName);
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (isDisposing)
-            {
-                ezSkinConfig.OnSettingsChanged -= OnConfigChanged;
-                factory.OnNoteChanged -= OnSkinChanged;
-            }
-        }
-
-        protected virtual Color4 NoteColor
-        {
-            get
-            {
-                int keyMode = stageDefinition.Columns;
-                int columnIndex = column.Index;
-                return ezSkinConfig.GetColumnColor(keyMode, columnIndex);
-            }
-        }
-
-        protected virtual string ColorPrefix
-        {
-            get
-            {
-                if (enabledColor.Value)
-                    return "white";
-
-                if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1")
-                    return "green";
-
-                int logicalIndex = 0;
-
-                for (int i = 0; i < column.Index; i++)
-                {
-                    if (ezSkinConfig.GetColumnType(stageDefinition.Columns, i) != "S1")
-                        logicalIndex++;
-                }
-
-                return logicalIndex % 2 == 0 ? "white" : "blue";
-            }
-        }
-
-        protected virtual string ComponentName => $"{ColorPrefix}longnote/head";
-
-        private void loadAnimation()
-        {
-            ClearInternal();
-            animation = factory.CreateAnimation(ComponentName);
-            container = new Container
-            {
-                RelativeSizeAxes = Axes.X,
-                Anchor = Anchor.BottomCentre,
-                Origin = Anchor.BottomCentre,
-                Masking = true,
-            };
-
-            noteSeparatorsL = new EzNoteSideLine
-            {
-                RelativeSizeAxes = Axes.X,
-                FillMode = FillMode.Fill,
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.Centre,
-            };
-            noteSeparatorsR = new EzNoteSideLine
-            {
-                RelativeSizeAxes = Axes.X,
-                FillMode = FillMode.Fill,
-                Anchor = Anchor.CentreRight,
-                Origin = Anchor.Centre,
-                // Rotation = 180,
-            };
-            AddInternal(new Container
-            {
-                RelativeSizeAxes = Axes.X,
-                FillMode = FillMode.Stretch,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Children = new Drawable[]
-                {
-                    noteSeparatorsL,
-                    noteSeparatorsR
-                }
-            });
-
-            if (animation.FrameCount == 0)
+            if (animation is TextureAnimation textureAnimation && textureAnimation.FrameCount == 0)
             {
                 animation.Dispose();
-                animation = factory.CreateAnimation($"{ColorPrefix}note");
-                var x = new Container
-                {
-                    RelativeSizeAxes = Axes.X,
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.BottomCentre,
-                    Child = animation,
-                };
-                if (x.Child is TextureAnimation)
-                    container.Child = x;
+                animation = Factory.CreateAnimation($"{ColorPrefix}note");
 
-                OnConfigChanged();
-                AddInternal(container);
+                if (animation is TextureAnimation newTexture && newTexture.FrameCount == 0)
+                {
+                    animation.Dispose();
+                    return;
+                }
+
+                if (MainContainer != null)
+                {
+                    MainContainer.Clear();
+                    MainContainer.RelativeSizeAxes = Axes.X;
+                    MainContainer.Anchor = Anchor.BottomCentre;
+                    MainContainer.Origin = Anchor.BottomCentre;
+                    MainContainer.Masking = true;
+                    MainContainer.Child = new Container
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.BottomCentre,
+                        Child = animation,
+                    };
+                }
             }
             else
             {
-                OnConfigChanged();
-                AddInternal(animation);
+                if (MainContainer != null)
+                {
+                    MainContainer.Clear();
+                    MainContainer.Child = animation;
+                }
             }
 
-            OnConfigChanged();
+            Schedule(UpdateSize);
         }
 
-        private void updateSizes()
+        protected override void UpdateSize()
         {
-            bool isSquare = factory.IsSquareNote("whitenote");
-            float noteHeight = isSquare
-                ? DrawWidth
-                : (float)(ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).Value);
+            base.UpdateSize();
+            float v = NoteSize.Value.Y;
+            Height = v;
 
-            Height = noteHeight;
-
-            if (container.Children.Count > 0 && container.Child is Container c)
+            if (MainContainer?.Children.Count > 0 && MainContainer.Child is Container c)
             {
-                container.Height = noteHeight / 2;
-                c.Height = noteHeight;
+                MainContainer.Height = v / 2;
+                c.Height = v;
             }
         }
-
-        private void OnConfigChanged()
-        {
-            var noteColor = Color4.White;
-            if (enabledColor.Value)
-                noteColor = NoteColor;
-
-            animation.Colour = noteColor;
-            container.Colour = noteColor;
-            noteSeparatorsL?.UpdateGlowEffect(noteColor);
-            noteSeparatorsR?.UpdateGlowEffect(noteColor);
-
-            Schedule(() =>
-            {
-                updateSizes();
-                Invalidate();
-            });
-        }
-
-        private void OnSkinChanged() => loadAnimation();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHittingLayer.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHittingLayer.cs
index 5822934031..43a06a6d4a 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHittingLayer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteHittingLayer.cs
@@ -6,39 +6,20 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Screens;
 using osu.Game.Screens.LAsEzExtensions;
-using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
-    public partial class EzHoldNoteHittingLayer : CompositeDrawable
+    public partial class EzHoldNoteHittingLayer : EzNoteBase
     {
+        protected override bool BoolUpdateColor => false;
         public readonly Bindable<bool> IsHitting = new Bindable<bool>();
         private TextureAnimation? animation;
 
-        private IBindable<double> noteHeightBindable = new Bindable<double>();
-        private IBindable<double> columnWidthBindable = new Bindable<double>();
-        private IBindable<double> specialFactorBindable = new Bindable<double>();
-
         public IBindable<double> HitPosition { get; set; } = new Bindable<double>();
 
-        // private IBindable<double> hitPosition = new Bindable<double>();
-        // private float baseYPosition;
-
-        [Resolved]
-        private Column column { get; set; } = null!;
-
-        [Resolved]
-        private StageDefinition stageDefinition { get; set; } = null!;
-
-        [Resolved]
-        private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
-
         [Resolved]
         private EzLocalTextureFactory factory { get; set; } = null!;
 
@@ -46,31 +27,20 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         {
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.Centre;
-            // AutoSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.Both;
             Blending = BlendingParameters.Additive;
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            noteHeightBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight);
-            columnWidthBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth);
-            specialFactorBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.SpecialFactor);
-            HitPosition = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
-            noteHeightBindable.BindValueChanged(_ => UpdateLNsLight(), true);
-            columnWidthBindable.BindValueChanged(_ => UpdateLNsLight(), true);
-            specialFactorBindable.BindValueChanged(_ => UpdateLNsLight(), true);
-            // hitPosition.BindValueChanged(_ => updateY(), true);
+            HitPosition = EZSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
+            HitPosition.BindValueChanged(_ => UpdateSize(), true);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            onSkinChanged();
-            factory.OnNoteChanged += onSkinChanged;
-            HitPosition.BindValueChanged(pos => Y =
-                LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION - (float)pos.NewValue, true);
-
             IsHitting.BindValueChanged(hitting =>
             {
                 ClearTransforms();
@@ -89,62 +59,48 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             }, true);
         }
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (isDisposing)
-            {
-                factory.OnNoteChanged -= onSkinChanged;
-            }
-        }
-
         public void Recycle()
         {
             ClearTransforms();
             Alpha = 0;
         }
 
-        private void loadAnimation()
+        protected override void OnDrawableChanged()
         {
-            ClearInternal();
-            animation = factory.CreateAnimation("longnoteflare");
+            string[] componentsToTry = { "longnoteflare", "noteflaregood", "noteflare" };
 
-            if (animation.FrameCount == 0)
+            foreach (string component in componentsToTry)
             {
-                animation.Dispose();
-                animation = factory.CreateAnimation("noteflaregood");
+                animation = factory.CreateAnimation(component);
 
-                if (animation.FrameCount == 0)
+                if (animation.FrameCount > 0)
                 {
-                    animation.Dispose();
-                    animation = factory.CreateAnimation("noteflare");
+                    animation.Loop = true;
+                    break;
                 }
             }
 
-            animation.Loop = true;
-            AddInternal(animation);
-            UpdateLNsLight();
+            if (animation is TextureAnimation textureAnimation && textureAnimation.FrameCount == 0)
+            {
+                animation.Dispose();
+                UpdateColor();
+                return;
+            }
+
+            if (MainContainer != null)
+            {
+                MainContainer.Clear();
+                if (animation != null) MainContainer.Child = animation;
+            }
+
+            Schedule(UpdateSize);
         }
 
-        public void UpdateLNsLight()
+        protected override void UpdateSize()
         {
-            bool isSpecialColumn = ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1";
-            double columnWidth = columnWidthBindable.Value * (isSpecialColumn ? specialFactorBindable.Value : 1);
-
-            bool isSquare = factory.IsSquareNote("whitenote");
-            float aspectRatio = factory.GetRatio("whitenote");
-
-            float moveY = isSquare
-                ? (float)columnWidth / 2 * aspectRatio
-                : (float)noteHeightBindable.Value * aspectRatio;
-
-            Position = new Vector2(0, moveY);
-        }
-
-        private void onSkinChanged()
-        {
-            loadAnimation();
+            base.UpdateSize();
+            float v = NoteSize.Value.Y / 2;
+            Position = new Vector2(0, -(float)HitPosition.Value - v);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteMiddle.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteMiddle.cs
index 6bb514aa26..f5fa00cb6e 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteMiddle.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteMiddle.cs
@@ -5,52 +5,31 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Screens;
-using osu.Game.Screens.LAsEzExtensions;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
-    public partial class EzHoldNoteMiddle : CompositeDrawable, IHoldNoteBody
+    public partial class EzHoldNoteMiddle : EzNoteBase, IHoldNoteBody
     {
         private readonly IBindable<bool> isHitting = new Bindable<bool>();
 
-        private DrawableHoldNote holdNote = null!;
+        private Container? topContainer;
+        private Container? bodyContainer;
+        private Container? bodyScaleContainer;
+        private Container? bodyInnerContainer;
 
-        private TextureAnimation? middleAnimation;
-        private TextureAnimation? tailAnimation;
-        private Container topContainer = null!;
-        private Container middleContainer = null!;
-        private Container middleScaleContainer = null!;
-        private Container middleInnerContainer = null!;
-
-        private IBindable<double> noteHeight = new Bindable<double>();
         private IBindable<double> hitPosition = new Bindable<double>();
-        private Bindable<bool> enabledColor = null!;
-        private Drawable? container;
-        private Drawable? lightContainer;
-        private EzHoldNoteHittingLayer hittingLayer = null!;
+        private EzHoldNoteHittingLayer? hittingLayer;
 
         [Resolved]
         private Column column { get; set; } = null!;
 
-        [Resolved]
-        private StageDefinition stageDefinition { get; set; } = null!;
-
-        [Resolved]
-        private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
-
-        [Resolved]
-        private EzLocalTextureFactory factory { get; set; } = null!;
-
         public EzHoldNoteMiddle()
         {
             RelativeSizeAxes = Axes.Both;
@@ -64,148 +43,77 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         [BackgroundDependencyLoader(true)]
         private void load(DrawableHitObject drawableObject)
         {
-            holdNote = (DrawableHoldNote)drawableObject;
+            var holdNote = (DrawableHoldNote)drawableObject;
             isHitting.BindTo(holdNote.IsHolding);
 
-            noteHeight = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight);
-            hitPosition = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
-            enabledColor = ezSkinConfig.GetBindable<bool>(EzSkinSetting.ColorSettingsEnabled);
-        }
-
-        public void Recycle()
-        {
-            ClearTransforms();
-            hittingLayer.Recycle();
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-            updateSizes();
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            OnSkinChanged();
-            noteHeight.BindValueChanged(_ => OnSettingsChanged(), true);
-            factory.OnNoteChanged += OnSkinChanged;
-            ezSkinConfig.OnSettingsChanged += OnSettingsChanged;
+            hitPosition = EZSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
             isHitting.BindValueChanged(onIsHittingChanged, true);
+            OnSkinChanged();
         }
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (isDisposing)
-            {
-                factory.OnNoteChanged -= OnSkinChanged;
-                ezSkinConfig.OnSettingsChanged -= OnSettingsChanged;
-                lightContainer?.Expire();
-            }
-        }
+        // protected override void Update()
+        // {
+        //     base.Update();
+        // }
 
         private void OnSkinChanged()
         {
-            if (lightContainer != null)
+            if (hittingLayer != null)
             {
-                column.TopLevelContainer.Remove(lightContainer, false);
-                lightContainer.Expire();
-                lightContainer = null;
+                column.TopLevelContainer.Remove(hittingLayer, false);
+                hittingLayer.Expire();
+                hittingLayer = null;
             }
 
-            loadAnimation();
             hittingLayer = new EzHoldNoteHittingLayer
             {
                 Alpha = 0,
                 IsHitting = { BindTarget = isHitting }
             };
-            lightContainer = new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.BottomCentre,
-                Origin = Anchor.BottomCentre,
-                Alpha = 0,
-                Child = hittingLayer
-            };
 
             hittingLayer.HitPosition.BindTo(hitPosition);
         }
 
         private void onIsHittingChanged(ValueChangedEvent<bool> isHitting)
         {
-            hittingLayer.IsHitting.Value = isHitting.NewValue;
+            if (hittingLayer != null) hittingLayer.IsHitting.Value = isHitting.NewValue;
 
-            if (lightContainer == null)
+            if (hittingLayer == null)
                 return;
 
             if (isHitting.NewValue)
             {
-                lightContainer.ClearTransforms();
+                hittingLayer.ClearTransforms();
 
-                if (lightContainer.Parent == null)
-                    column.TopLevelContainer.Add(lightContainer);
+                if (hittingLayer.Parent == null)
+                    column.TopLevelContainer.Add(hittingLayer);
 
-                lightContainer.FadeIn(80);
+                hittingLayer.FadeIn(80);
             }
             else
             {
-                lightContainer.FadeOut(120)
-                              .OnComplete(d => column.TopLevelContainer.Remove(d, false));
+                hittingLayer.FadeOut(120)
+                            .OnComplete(d => column.TopLevelContainer.Remove(d, false));
             }
         }
 
-        protected virtual Color4 NoteColor
+        public void Recycle()
         {
-            get
-            {
-                int keyMode = stageDefinition.Columns;
-                int columnIndex = column.Index;
-                return ezSkinConfig.GetColumnColor(keyMode, columnIndex);
-            }
+            ClearTransforms();
+            hittingLayer?.Recycle();
         }
 
-        protected virtual string ColorPrefix
+        protected override void OnDrawableChanged()
         {
-            get
-            {
-                if (enabledColor.Value)
-                    return "white";
+            string newComponentName = $"{ColorPrefix}note";
+            var body = Factory.CreateAnimation($"{ColorPrefix}longnote/middle");
+            var tail = Factory.CreateAnimation($"{ColorPrefix}longnote/tail");
 
-                if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1")
-                    return "green";
+            if (body.FrameCount == 0)
+                body = Factory.CreateAnimation(newComponentName);
 
-                int logicalIndex = 0;
-
-                for (int i = 0; i < column.Index; i++)
-                {
-                    if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) != "S1")
-                        logicalIndex++;
-                }
-
-                return logicalIndex % 2 == 0 ? "white" : "blue";
-            }
-        }
-
-        private void loadAnimation()
-        {
-            ClearInternal();
-            string backupComponentName = $"{ColorPrefix}note";
-            middleAnimation = factory.CreateAnimation($"{ColorPrefix}longnote/middle");
-            tailAnimation = factory.CreateAnimation($"{ColorPrefix}longnote/tail");
-
-            if (middleAnimation.FrameCount == 0)
-            {
-                middleAnimation.Dispose();
-                middleAnimation = factory.CreateAnimation(backupComponentName);
-            }
-
-            if (tailAnimation.FrameCount == 0)
-            {
-                tailAnimation.Dispose();
-                tailAnimation = factory.CreateAnimation(backupComponentName);
-            }
+            if (tail.FrameCount == 0)
+                tail = Factory.CreateAnimation(newComponentName);
 
             topContainer = new Container
             {
@@ -218,67 +126,80 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
                     RelativeSizeAxes = Axes.X,
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
-                    Child = tailAnimation
+                    Child = tail
                 }
             };
-            middleContainer = new Container
+            bodyContainer = new Container
             {
                 RelativeSizeAxes = Axes.X,
                 Anchor = Anchor.TopCentre,
                 Origin = Anchor.TopCentre,
                 Masking = true,
-                Child = middleScaleContainer = new Container
+                Child = bodyScaleContainer = new Container
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = 1,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Child = middleInnerContainer = new Container
+                    Child = bodyInnerContainer = new Container
                     {
                         RelativeSizeAxes = Axes.X,
-                        Child = middleAnimation
+                        Child = body
                     }
                 }
             };
-            container = new Container
+
+            if (MainContainer != null)
             {
-                RelativeSizeAxes = Axes.Both,
-                Children = new[] { middleContainer, topContainer }
-            };
-
-            OnSettingsChanged();
-            AddInternal(container);
-        }
-
-        private void updateSizes()
-        {
-            bool isSquare = factory.IsSquareNote("whitenote");
-            float noteSize = isSquare
-                ? DrawWidth
-                : (float)(ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).Value);
-
-            topContainer.Height = noteSize / 2;
-            if (topContainer.Child is Container topInner)
-                topInner.Height = noteSize;
-
-            float middleHeight = Math.Max(DrawHeight - noteSize / 2, noteSize / 2);
-
-            middleContainer.Y = noteSize / 2;
-            middleContainer.Height = middleHeight + 2;
-            middleScaleContainer.Scale = new Vector2(1, DrawHeight - noteSize / 2);
-            middleInnerContainer.Height = noteSize;
-            middleInnerContainer.Y = -noteSize / 2;
-            Invalidate();
-        }
-
-        private void OnSettingsChanged()
-        {
-            if (enabledColor.Value && container != null)
-            {
-                container.Colour = NoteColor;
+                MainContainer.Clear();
+                MainContainer.Children = [bodyContainer, topContainer];
             }
 
-            Schedule(updateSizes);
+            Schedule(UpdateSize);
+        }
+
+        protected override void UpdateSize()
+        {
+            base.UpdateSize();
+            if (MainContainer?.Children.Count == 0)
+                return;
+
+            float v = NoteSize.Value.Y;
+
+            if (topContainer?.Child is Container topInner)
+            {
+                topContainer.Height = v / 2;
+                topInner.Height = v;
+            }
+
+            float middleHeight = Math.Max(DrawHeight - v / 2, v / 2);
+
+            if (bodyContainer != null)
+            {
+                bodyContainer.Y = v / 2;
+                bodyContainer.Height = middleHeight + 2;
+            }
+
+            if (bodyScaleContainer != null)
+                bodyScaleContainer.Scale = new Vector2(1, DrawHeight - v / 2);
+
+            if (bodyInnerContainer != null)
+            {
+                bodyInnerContainer.Height = v;
+                bodyInnerContainer.Y = -v / 2;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (isDisposing)
+            {
+                hittingLayer?.Expire();
+                topContainer?.Expire();
+                bodyContainer?.Expire();
+            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteTail.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteTail.cs
index e47d477696..666d66658e 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteTail.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzHoldNoteTail.cs
@@ -20,14 +20,12 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
     public partial class EzHoldNoteTail : CompositeDrawable
     {
-        private EzHoldNoteHittingLayer hittingLayer = null!;
+        private readonly EzHoldNoteHittingLayer hittingLayer = null!;
         private TextureAnimation? animation;
         private Container container = null!;
 
         private EzSkinSettingsManager ezSkinConfig = null!;
         private Bindable<bool> enabledColor = null!;
-        private float noteSize;
-        private bool isSquare;
 
         [Resolved]
         private Column column { get; set; } = null!;
@@ -48,9 +46,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             RelativeSizeAxes = Axes.Both;
             Alpha = 0f;
 
-            hittingLayer = new EzHoldNoteHittingLayer { RelativeSizeAxes = Axes.Both };
-            AddInternal(hittingLayer);
-
             if (drawableObject != null)
             {
                 // accentColour.BindTo(drawableObject.AccentColour);
@@ -64,13 +59,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 
         private void updateSizes()
         {
-            isSquare = factory.IsSquareNote("whitenote");
-            noteSize = isSquare
-                ? DrawWidth
-                : (float)(ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).Value);
-
-            container.Height = noteSize / 2;
-            if (animation != null) animation.Height = noteSize;
         }
 
         protected override void LoadComplete()
@@ -78,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             base.LoadComplete();
             loadAnimation();
             factory.OnNoteChanged += onSkinChanged;
-            ezSkinConfig.OnSettingsChanged += onSettingsChanged;
+            factory.OnNoteSizeChanged += onNoteSizeChanged;
         }
 
         private void onSkinChanged()
@@ -86,7 +74,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             Schedule(loadAnimation);
         }
 
-        private void onSettingsChanged()
+        private void onNoteSizeChanged()
         {
             if (enabledColor.Value)
                 container.Colour = NoteColor;
@@ -145,7 +133,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
                 }
             };
 
-            onSettingsChanged();
+            onNoteSizeChanged();
             AddInternal(container);
         }
 
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzKeyArea.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzKeyArea.cs
index 6c4c037376..6f9f291954 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzKeyArea.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzKeyArea.cs
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             base.LoadComplete();
             OnSkinChanged();
             factory.OnStageChanged += OnSkinChanged;
-            ezSkinConfig.OnSettingsChanged += OnConfigChanged;
+            factory.OnNoteSizeChanged += OnConfigChanged;
         }
 
         protected override void Dispose(bool isDisposing)
@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             if (isDisposing)
             {
                 factory.OnStageChanged -= OnSkinChanged;
-                ezSkinConfig.OnSettingsChanged -= OnConfigChanged;
+                factory.OnNoteSizeChanged -= OnConfigChanged;
             }
         }
 
@@ -67,14 +67,14 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         {
             get
             {
-                if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1")
+                if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S")
                     return "02";
 
                 int logicalIndex = 0;
 
                 for (int i = 0; i < column.Index; i++)
                 {
-                    if (ezSkinConfig.GetColumnType(stageDefinition.Columns, i) == "S1")
+                    if (ezSkinConfig.GetColumnType(stageDefinition.Columns, i) == "S")
                         logicalIndex++;
                 }
 
@@ -107,21 +107,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             AddInternal(container);
         }
 
-        private void updateSizes()
-        {
-            bool isSquare = factory.IsSquareNote("whitenote");
-            Height = isSquare
-                ? DrawWidth
-                : (float)(ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).Value);
-        }
-
         private void OnConfigChanged()
         {
-            Schedule(() =>
-            {
-                updateSizes();
-                Invalidate();
-            });
         }
 
         private void OnSkinChanged() => loadAnimation();
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNote.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNote.cs
index 8dab66e593..590da33b5e 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNote.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNote.cs
@@ -2,181 +2,48 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Screens;
-using osu.Game.Screens.LAsEzExtensions;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
-    public partial class EzNote : CompositeDrawable
+    public partial class EzNote : EzNoteBase
     {
-        private Bindable<bool> enabledColor = null!;
-        private Bindable<double> nonSquareNoteHeight = null!;
-
-        private TextureAnimation animation = null!;
-        private Drawable container = null!;
-        private EzNoteSideLine? noteSeparatorsL;
-        private EzNoteSideLine? noteSeparatorsR;
-
-        protected virtual bool ShowSeparators => true;
-        protected virtual bool UseColorization => true;
-
-        [Resolved]
-        private Column column { get; set; } = null!;
-
-        [Resolved]
-        private StageDefinition stageDefinition { get; set; } = null!;
-
-        [Resolved]
-        private EzLocalTextureFactory factory { get; set; } = null!;
-
-        [Resolved]
-        private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
+        protected override bool ShowSeparators => true;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             RelativeSizeAxes = Axes.X;
             FillMode = FillMode.Fill;
-
-            enabledColor = ezSkinConfig.GetBindable<bool>(EzSkinSetting.ColorSettingsEnabled);
-            nonSquareNoteHeight = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight);
         }
 
-        protected override void LoadComplete()
+        protected override void OnDrawableChanged()
         {
-            base.LoadComplete();
-            OnSkinChanged();
-            enabledColor.BindValueChanged(_ => OnConfigChanged(), true);
-            nonSquareNoteHeight.BindValueChanged(_ => updateSizes(), true);
-            ezSkinConfig.OnSettingsChanged += OnConfigChanged;
-            factory.OnNoteChanged += OnSkinChanged;
-        }
+            string newComponentName = $"{ColorPrefix}note";
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
+            var animation = Factory.CreateAnimation(newComponentName);
 
-            if (isDisposing)
+            if (animation is TextureAnimation textureAnimation && textureAnimation.FrameCount == 0)
             {
-                ezSkinConfig.OnSettingsChanged -= OnConfigChanged;
-                factory.OnNoteChanged -= OnSkinChanged;
-            }
-        }
-
-        protected virtual Color4 NoteColor
-        {
-            get
-            {
-                int keyMode = stageDefinition.Columns;
-                int columnIndex = column.Index;
-                return ezSkinConfig.GetColumnColor(keyMode, columnIndex);
-            }
-        }
-
-        protected virtual string ColorPrefix
-        {
-            get
-            {
-                if (enabledColor.Value)
-                    return "white";
-
-                if (ezSkinConfig.GetColumnType(stageDefinition.Columns, column.Index) == "S1")
-                    return "green";
-
-                int logicalIndex = 0;
-
-                for (int i = 0; i < column.Index; i++)
-                {
-                    if (ezSkinConfig.GetColumnType(stageDefinition.Columns, i) != "S1")
-                        logicalIndex++;
-                }
-
-                return logicalIndex % 2 == 0 ? "white" : "blue";
-            }
-        }
-
-        protected virtual string ComponentName => $"{ColorPrefix}note";
-
-        private void loadAnimation()
-        {
-            ClearInternal();
-            animation = factory.CreateAnimation(ComponentName);
-            container = new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Child = animation
-            };
-
-            if (ShowSeparators)
-            {
-                noteSeparatorsL = new EzNoteSideLine
-                {
-                    RelativeSizeAxes = Axes.X,
-                    FillMode = FillMode.Fill,
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.Centre,
-                };
-                noteSeparatorsR = new EzNoteSideLine
-                {
-                    RelativeSizeAxes = Axes.X,
-                    FillMode = FillMode.Fill,
-                    Anchor = Anchor.CentreRight,
-                    Origin = Anchor.Centre,
-                    // Rotation = 180,
-                };
-                AddInternal(new Container
-                {
-                    RelativeSizeAxes = Axes.X,
-                    FillMode = FillMode.Stretch,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Children = new Drawable[]
-                    {
-                        noteSeparatorsL,
-                        noteSeparatorsR
-                    }
-                });
+                animation.Dispose();
+                UpdateColor();
+                return;
             }
 
-            OnConfigChanged();
-            AddInternal(container);
-        }
-
-        private void updateSizes()
-        {
-            bool isSquare = factory.IsSquareNote("whitenote");
-            Height = isSquare
-                ? DrawWidth
-                : (float)(ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).Value);
-        }
-
-        private void OnConfigChanged()
-        {
-            var noteColor = Color4.White;
-            if (enabledColor.Value && UseColorization)
-                noteColor = NoteColor;
-
-            container.Colour = noteColor;
-
-            noteSeparatorsL?.UpdateGlowEffect(noteColor);
-            noteSeparatorsR?.UpdateGlowEffect(noteColor);
-
-            Schedule(() =>
+            if (MainContainer != null)
             {
-                updateSizes();
-                Invalidate();
-            });
+                MainContainer.Clear();
+                MainContainer.Child = animation;
+            }
+
+            Schedule(UpdateSize);
         }
 
-        private void OnSkinChanged() => loadAnimation();
+        protected override void UpdateSize()
+        {
+            base.UpdateSize();
+            Height = NoteSize.Value.Y;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteBase.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteBase.cs
new file mode 100644
index 0000000000..ce020953da
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteBase.cs
@@ -0,0 +1,171 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Screens;
+using osu.Game.Screens.LAsEzExtensions;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
+{
+    public abstract partial class EzNoteBase : CompositeDrawable
+    {
+        protected virtual bool BoolUpdateColor => true;
+        protected virtual bool UseColorization => true;
+        protected virtual bool ShowSeparators => false;
+        protected int KeyMode;
+        protected int ColumnIndex;
+
+        protected Container? SeparatorsContainer { get; private set; }
+        protected Container? MainContainer { get; private set; }
+
+        [Resolved]
+        protected Column Column { get; private set; } = null!;
+
+        [Resolved]
+        protected StageDefinition StageDefinition { get; private set; } = null!;
+
+        [Resolved]
+        protected EzSkinSettingsManager EZSkinConfig { get; private set; } = null!;
+
+        [Resolved]
+        protected EzLocalTextureFactory Factory { get; private set; } = null!;
+
+        private IBindable<Colour4> columnColorBindable = null!;
+        protected Bindable<bool> EnabledColor = null!;
+        protected Bindable<Vector2> NoteSize = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            KeyMode = StageDefinition.Columns;
+            ColumnIndex = Column.Index;
+            EnabledColor = EZSkinConfig.GetBindable<bool>(EzSkinSetting.ColorSettingsEnabled);
+            columnColorBindable = EZSkinConfig.GetColumnColorBindable(KeyMode, ColumnIndex);
+            NoteSize = Factory.GetNoteSize(KeyMode, ColumnIndex);
+
+            createSeparators();
+            MainContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            };
+            AddInternal(MainContainer);
+        }
+
+        private void createSeparators()
+        {
+            var noteSeparatorsL = new EzNoteSideLine
+            {
+                RelativeSizeAxes = Axes.X,
+                FillMode = FillMode.Fill,
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.Centre,
+            };
+
+            var noteSeparatorsR = new EzNoteSideLine
+            {
+                RelativeSizeAxes = Axes.X,
+                FillMode = FillMode.Fill,
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.Centre,
+            };
+
+            SeparatorsContainer = new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                FillMode = FillMode.Stretch,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Alpha = ShowSeparators ? 1f : 0f,
+                Children = [noteSeparatorsL, noteSeparatorsR]
+            };
+
+            AddInternal(SeparatorsContainer);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            EnabledColor.BindValueChanged(_ => UpdateColor(), true);
+            columnColorBindable.BindValueChanged(_ => UpdateColor(), true);
+            NoteSize.BindValueChanged(_ => UpdateSize(), true);
+
+            Factory.OnNoteChanged += OnDrawableChanged;
+            // Factory.OnNoteSizeChanged += UpdateSize;
+            Scheduler.AddOnce(OnDrawableChanged);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            Factory.OnNoteChanged -= OnDrawableChanged;
+            // Factory.OnNoteSizeChanged -= UpdateSize;
+        }
+
+        protected Colour4 NoteColor
+        {
+            get
+            {
+                if (EnabledColor.Value && UseColorization)
+                    return EZSkinConfig.GetColumnColor(KeyMode, ColumnIndex);
+
+                return Colour4.White;
+            }
+        }
+
+        protected virtual string ColorPrefix
+        {
+            get
+            {
+                if (EnabledColor.Value) return "white";
+
+                string keyType = EZSkinConfig.GetColumnType(KeyMode, ColumnIndex);
+
+                return keyType switch
+                {
+                    "A" => "white",
+                    "B" => "blue",
+                    "S" => "green",
+                    "E" => "white",
+                    "P" => "green",
+                    _ => "white"
+                };
+            }
+        }
+
+        protected void UpdateColor()
+        {
+            if (BoolUpdateColor)
+            {
+                if (MainContainer != null)
+                    MainContainer.Colour = NoteColor;
+
+                if (SeparatorsContainer?.Children != null)
+                {
+                    foreach (var child in SeparatorsContainer.Children)
+                    {
+                        if (child is EzNoteSideLine sideLine)
+                            sideLine.UpdateGlowEffect(NoteColor);
+                    }
+                }
+            }
+        }
+
+        protected virtual void UpdateSize()
+        {
+            NoteSize = Factory.GetNoteSize(KeyMode, ColumnIndex);
+            UpdateColor();
+        }
+
+        protected virtual void OnDrawableChanged() { }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteSideLine.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteSideLine.cs
index 8503b29dc8..b77a9f67e2 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteSideLine.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzNoteSideLine.cs
@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
@@ -11,7 +10,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Screens;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 {
@@ -74,7 +72,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             separator.Height = (float)noteTrackLineHeight.Value;
         }
 
-        public void UpdateGlowEffect(Color4 color)
+        public void UpdateGlowEffect(Colour4 color)
         {
             separator.Colour = new ColourInfo
             {
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzStageBottom.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzStageBottom.cs
index 7bfaf9173a..8986a3f2c3 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzStageBottom.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/EzStageBottom.cs
@@ -35,8 +35,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 
             hitPositon = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
             columnWidth = ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth);
-            hitPositon.BindValueChanged(_ => OnConfigChanged());
-            columnWidth.BindValueChanged(_ => OnConfigChanged());
+            hitPositon.BindValueChanged(_ => updateSizes());
+            columnWidth.BindValueChanged(_ => updateSizes());
             OnSkinChanged();
         }
 
@@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
         //     updateSizes();
         // }
 
-        private void loadAnimation()
+        private void OnSkinChanged()
         {
             ClearInternal();
 
@@ -77,8 +77,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
                 Child = stageBottom
             };
             // sprite.Depth = float.MinValue;
-            OnConfigChanged();
             AddInternal(sprite);
+            Schedule(updateSizes);
         }
 
         private void updateSizes()
@@ -93,16 +93,5 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             sprite.Y = LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION - (float)hitPositon.Value - DrawHeight * 0.865f;
             // Position = new Vector2(0, 415 + 110 - (float)hitPositon.Value);
         }
-
-        private void OnConfigChanged()
-        {
-            Schedule(() =>
-            {
-                updateSizes();
-                Invalidate();
-            });
-        }
-
-        private void OnSkinChanged() => loadAnimation();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/ManiaEzStyleProSkinTransformer.cs b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/ManiaEzStyleProSkinTransformer.cs
index 1c0f67dd6a..39db73c9b3 100644
--- a/osu.Game.Rulesets.Mania/Skinning/EzStylePro/ManiaEzStyleProSkinTransformer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/EzStylePro/ManiaEzStyleProSkinTransformer.cs
@@ -202,6 +202,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
 
                         case ManiaSkinComponents.HitExplosion:
                             return new EzHitExplosion();
+                            // return HitExplosionPool.Rent();
 
                         case ManiaSkinComponents.StageBackground:
                             return new Ez2StageBackground();
@@ -226,7 +227,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.EzStylePro
             {
                 int columnIndex = maniaLookup.ColumnIndex ?? 0;
                 var stage = beatmap.GetStageForColumnIndex(columnIndex);
-                bool isSpecialColumn = ezSkinConfig.GetColumnType(stage.Columns, columnIndex) == "S1";
+                bool isSpecialColumn = ezSkinConfig.GetColumnType(stage.Columns, columnIndex) == "S";
                 float width = (float)columnWidthBindable.Value * (isSpecialColumn ? (float)specialFactorBindable.Value : 1f);
                 // float hitPositionValue = (float)hitPosition.Value; // + (float)virtualHitPosition.Value - 110f;
 
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/HitTargetInsetContainer.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/HitTargetInsetContainer.cs
index 130410ab6a..46d9b34af6 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/HitTargetInsetContainer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/HitTargetInsetContainer.cs
@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
     {
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
         private Bindable<double> hitPositonBindable = new Bindable<double>();
+        private Bindable<bool> globalHitPosition = new Bindable<bool>();
+
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
@@ -30,17 +32,23 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, EzSkinSettingsManager ezSkinConfig, IScrollingInfo scrollingInfo)
         {
-            hitPositonBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
-            hitPositonBindable.BindValueChanged(_ => UpdateHitPosition(), true);
-            hitPosition = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.HitPosition)?.Value ?? (float)hitPositonBindable.Value;
-
             direction.BindTo(scrollingInfo.Direction);
             direction.BindValueChanged(onDirectionChanged, true);
+
+            ezSkinConfig.GetBindable<bool>(EzSkinSetting.GlobalHitPosition).BindValueChanged(_ => updateHitPosition(skin, ezSkinConfig));
+            ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition).BindValueChanged(_ => updateHitPosition(skin, ezSkinConfig));
+
+            updateHitPosition(skin, ezSkinConfig);
         }
 
-        protected virtual void UpdateHitPosition()
+        private void updateHitPosition(ISkinSource skin, EzSkinSettingsManager ezSkinConfig)
         {
-            hitPosition = (float)hitPositonBindable.Value;
+            bool globalHitPositionValue = ezSkinConfig.GetBindable<bool>(EzSkinSetting.GlobalHitPosition).Value;
+            double hitPositionValue = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition).Value;
+
+            hitPosition = globalHitPositionValue
+                ? (float)hitPositionValue
+                : skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.HitPosition)?.Value ?? (float)hitPositionValue;
         }
 
         private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
diff --git a/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs b/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
index add2ce843f..fe06796bea 100644
--- a/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
+++ b/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
@@ -163,7 +163,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 }
 
                 bool isSpecialColumn =
-                    ezSkinConfig.GetColumnType(stageDefinition.Columns, i) == "S1";
+                    ezSkinConfig.GetColumnType(stageDefinition.Columns, i) == "S";
                 float ezWidth = (float)columnWidthBindable.Value * (isSpecialColumn ? (float)specialFactorBindable.Value : 1);
 
                 switch (ezColumnWidthStyle.Value)
diff --git a/osu.Game.Rulesets.Mania/UI/Components/HitPositionPaddedContainer.cs b/osu.Game.Rulesets.Mania/UI/Components/HitPositionPaddedContainer.cs
index a697000700..6d71cf9077 100644
--- a/osu.Game.Rulesets.Mania/UI/Components/HitPositionPaddedContainer.cs
+++ b/osu.Game.Rulesets.Mania/UI/Components/HitPositionPaddedContainer.cs
@@ -24,6 +24,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
         private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
 
         private Bindable<double> hitPositonBindable = new Bindable<double>();
+        private readonly Bindable<bool> globalHitPosition = new Bindable<bool>();
 
         [BackgroundDependencyLoader]
         private void load(IScrollingInfo scrollingInfo)
@@ -31,6 +32,8 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             Direction.BindTo(scrollingInfo.Direction);
             Direction.BindValueChanged(_ => UpdateHitPosition(), true);
 
+            ezSkinConfig.BindWith(EzSkinSetting.GlobalHitPosition, globalHitPosition);
+            globalHitPosition.BindValueChanged(_ => UpdateHitPosition(), true);
             hitPositonBindable = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
             hitPositonBindable.BindValueChanged(_ => UpdateHitPosition(), true);
             skin.SourceChanged += onSkinChanged;
@@ -40,9 +43,16 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 
         protected virtual void UpdateHitPosition()
         {
-            float hitPosition = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
-                                    new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
-                                ?? (float)hitPositonBindable.Value;
+            float hitPosition;
+
+            if (globalHitPosition.Value)
+                hitPosition = (float)hitPositonBindable.Value;
+            else
+            {
+                hitPosition = skin.GetConfig<ManiaSkinConfigurationLookup, float>(
+                                  new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.HitPosition))?.Value
+                              ?? (float)hitPositonBindable.Value;
+            }
 
             Padding = Direction.Value == ScrollingDirection.Up
                 ? new MarginPadding { Top = hitPosition }
diff --git a/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs b/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs
index aa903205c8..4108e9388d 100644
--- a/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs
+++ b/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, []);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
         }
@@ -33,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty { OverallDifficulty = originalOverallDifficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, []);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(originalOverallDifficulty));
         }
@@ -44,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new OsuModHalfTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(2.22).Within(0.01));
@@ -56,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new OsuModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(7.67).Within(0.01));
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(7.77).Within(0.01));
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
index 8d81fe3017..367a00ad3b 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
+using osu.Game.Tests;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -152,6 +153,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [FlakyTest]
         public void TestSpinPerMinuteOnRewind()
         {
             double estimatedSpm = 0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index a667d12a44..41b0947fbb 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -93,7 +93,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
 
-            overallDifficulty = (80 - greatHitWindow) / 6;
+            overallDifficulty = (79.5 - greatHitWindow) / 6;
             approachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5;
 
             if (osuAttributes.SliderCount > 0)
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModEasy.cs b/osu.Game.Rulesets.Osu/Mods/OsuModEasy.cs
index 97fe0d0bf2..9725a42674 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModEasy.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModEasy.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -9,5 +10,12 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModEasy : ModEasyWithExtraLives
     {
         public override LocalisableString Description => @"Larger circles, more forgiving HP drain, less accuracy required, and extra lives!";
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty *= ADJUST_RATIO;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs b/osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs
index d24597eeed..e7ac63599d 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs
@@ -28,6 +28,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             base.ApplyToDifficulty(difficulty);
 
+            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
             difficulty.CircleSize = Math.Min(difficulty.CircleSize * 1.3f, 10.0f); // CS uses a custom 1.3 ratio.
             difficulty.ApproachRate = Math.Min(difficulty.ApproachRate * ADJUST_RATIO, 10.0f);
         }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
index 5ee8814b5a..129c03149f 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
@@ -12,9 +12,9 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Beatmaps;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
 
@@ -83,7 +83,12 @@ namespace osu.Game.Rulesets.Osu.Mods
             {
             }
 
-            public override Judgement CreateJudgement() => new OsuJudgement();
+            public override Judgement CreateJudgement() => new StrictTrackingTailJudgement();
+        }
+
+        public class StrictTrackingTailJudgement : SliderTailCircle.TailJudgement
+        {
+            public override HitResult MinResult => HitResult.LargeTickMiss;
         }
 
         private partial class StrictTrackingDrawableSliderTail : DrawableSliderTail
diff --git a/osu.Game.Rulesets.Osu/OsuRuleset.cs b/osu.Game.Rulesets.Osu/OsuRuleset.cs
index 0edb8046b9..be9f0e276b 100644
--- a/osu.Game.Rulesets.Osu/OsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/OsuRuleset.cs
@@ -40,6 +40,7 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu
@@ -365,9 +366,10 @@ namespace osu.Game.Rulesets.Osu
 
         /// <seealso cref="OsuHitObject.ApplyDefaultsToSelf"/>
         /// <seealso cref="OsuHitWindows"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, IReadOnlyCollection<Mod> mods)
         {
             BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, OsuHitObject.PREEMPT_MAX, OsuHitObject.PREEMPT_MID, OsuHitObject.PREEMPT_MIN);
             preempt /= rate;
diff --git a/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs b/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs
index 4ab3f502ad..2a5688ab11 100644
--- a/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Taiko.Mods;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty { OverallDifficulty = originalOverallDifficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, []);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(originalOverallDifficulty));
         }
@@ -33,7 +34,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new TaikoModHalfTime()]);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(1.11).Within(0.01));
         }
@@ -44,7 +45,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty();
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(difficulty, [new TaikoModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(8.89).Within(0.01));
         }
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModEasy.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModEasy.cs
index 009f2854f8..1bc9277210 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModEasy.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModEasy.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty *= ADJUST_RATIO;
             difficulty.SliderMultiplier *= slider_multiplier;
         }
     }
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.cs
index ba41175461..8f01c21894 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
@@ -23,6 +24,8 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             base.ApplyToDifficulty(difficulty);
+
+            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
             difficulty.SliderMultiplier *= slider_multiplier;
         }
     }
diff --git a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
index 1cb41e1299..76488fdd26 100644
--- a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
@@ -38,6 +38,7 @@ using osu.Game.Rulesets.Taiko.Configuration;
 using osu.Game.Rulesets.Taiko.Edit.Setup;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Screens.Edit.Setup;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Taiko
 {
@@ -270,9 +271,10 @@ namespace osu.Game.Rulesets.Taiko
         }
 
         /// <seealso cref="TaikoHitWindows"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, IReadOnlyCollection<Mod> mods)
         {
             BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, TaikoHitWindows.GREAT_WINDOW_RANGE);
             greatHitWindow /= rate;
diff --git a/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs b/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs
index 61ee6a3663..c2a712b580 100644
--- a/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckAudioQualityTest.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using ManagedBass;
 using Moq;
 using NUnit.Framework;
 using osu.Framework.Audio.Track;
@@ -10,7 +11,9 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Checks;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual;
+using osuTK.Audio;
 
 namespace osu.Game.Tests.Editing.Checks
 {
@@ -28,9 +31,13 @@ namespace osu.Game.Tests.Editing.Checks
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    Metadata = new BeatmapMetadata { AudioFile = "abc123.jpg" }
+                    Metadata = new BeatmapMetadata()
                 }
             };
+
+            // 0 = No output device. This still allows decoding.
+            if (!Bass.Init(0) && Bass.LastError != Errors.Already)
+                throw new AudioException("Could not initialize Bass.");
         }
 
         [Test]
@@ -54,6 +61,14 @@ namespace osu.Game.Tests.Editing.Checks
             Assert.That(check.Run(context), Is.Empty);
         }
 
+        [Test]
+        public void TestAcceptableOgg()
+        {
+            var context = getContext(208, useOgg: true);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
         [Test]
         public void TestNullBitrate()
         {
@@ -87,6 +102,17 @@ namespace osu.Game.Tests.Editing.Checks
             Assert.That(issues.Single().Template is CheckAudioQuality.IssueTemplateTooHighBitrate);
         }
 
+        [Test]
+        public void TestTooHighBitrateOgg()
+        {
+            var context = getContext(250, useOgg: true);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAudioQuality.IssueTemplateTooHighBitrate);
+        }
+
         [Test]
         public void TestTooLowBitrate()
         {
@@ -98,24 +124,41 @@ namespace osu.Game.Tests.Editing.Checks
             Assert.That(issues.Single().Template is CheckAudioQuality.IssueTemplateTooLowBitrate);
         }
 
-        private BeatmapVerifierContext getContext(int? audioBitrate)
+        private BeatmapVerifierContext getContext(int? audioBitrate, bool useOgg = false)
         {
-            return new BeatmapVerifierContext(beatmap, getMockWorkingBeatmap(audioBitrate).Object);
+            // Update the audio filename and beatmapset files based on the format being tested
+            string audioFileName = useOgg ? "abc123.ogg" : "abc123.mp3";
+            string fileExtension = useOgg ? "ogg" : "mp3";
+
+            beatmap.Metadata.AudioFile = audioFileName;
+            beatmap.BeatmapInfo.BeatmapSet = new BeatmapSetInfo
+            {
+                Files = { CheckTestHelpers.CreateMockFile(fileExtension) }
+            };
+
+            return new BeatmapVerifierContext(beatmap, getMockWorkingBeatmap(audioBitrate, useOgg).Object);
         }
 
         /// <summary>
         /// Returns the mock of the working beatmap with the given audio properties.
         /// </summary>
         /// <param name="audioBitrate">The bitrate of the audio file the beatmap uses.</param>
-        private Mock<IWorkingBeatmap> getMockWorkingBeatmap(int? audioBitrate)
+        /// <param name="useOgg">Whether to use an OGG sample instead of MP3.</param>
+        private Mock<IWorkingBeatmap> getMockWorkingBeatmap(int? audioBitrate, bool useOgg = false)
         {
             var mockTrack = new Mock<OsuTestScene.ClockBackedTestWorkingBeatmap.TrackVirtualManual>(new FramedClock(), "virtual");
             mockTrack.SetupGet(t => t.Bitrate).Returns(audioBitrate);
 
+            // Use real audio samples for format detection
+            string samplePath = useOgg ? "Samples/test-sample.ogg" : "Samples/test-sample-cut.mp3";
+
             var mockWorkingBeatmap = new Mock<IWorkingBeatmap>();
             mockWorkingBeatmap.SetupGet(w => w.Beatmap).Returns(beatmap);
             mockWorkingBeatmap.SetupGet(w => w.Track).Returns(mockTrack.Object);
 
+            // Return a fresh stream each time GetStream is called to avoid disposed stream issues
+            mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(() => TestResources.OpenResource(samplePath));
+
             return mockWorkingBeatmap;
         }
     }
diff --git a/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
index bdb4dce354..8a9ee4b81b 100644
--- a/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
+++ b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
@@ -136,14 +136,39 @@ namespace osu.Game.Tests.NonVisual
             AddUntilStep("no check pending", () => !manager.IsPending);
         }
 
+        [Test]
+        public void TestFixedReleaseStreamWrittenToConfig()
+        {
+            AddStep("add manager", () =>
+            {
+                config = new OsuConfigManager(LocalStorage);
+                config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
+                Child = new DependencyProvidingContainer
+                {
+                    CachedDependencies = [(typeof(OsuConfigManager), config)],
+                    Child = manager = new TestUpdateManager(ReleaseStream.Tachyon)
+                };
+            });
+
+            AddAssert("release stream set to tachyon", () => config.Get<ReleaseStream>(OsuSetting.ReleaseStream), () => Is.EqualTo(ReleaseStream.Tachyon));
+        }
+
         private partial class TestUpdateManager : UpdateManager
         {
+            public override ReleaseStream? FixedReleaseStream { get; }
+
             public bool IsPending { get; private set; }
             public int Invocations { get; private set; }
             public int Completions { get; private set; }
 
             private TaskCompletionSource<bool>? pendingCheck;
 
+            public TestUpdateManager(ReleaseStream? fixedReleaseStream = null)
+            {
+                FixedReleaseStream = fixedReleaseStream;
+            }
+
             protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
             {
                 Invocations++;
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneToolbarRulesetSelector.cs b/osu.Game.Tests/Visual/Menus/TestSceneToolbarRulesetSelector.cs
new file mode 100644
index 0000000000..6f1ecb9025
--- /dev/null
+++ b/osu.Game.Tests/Visual/Menus/TestSceneToolbarRulesetSelector.cs
@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.IO.Stores;
+using osu.Game.Beatmaps;
+using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public partial class TestSceneToolbarRulesetSelector : OsuTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets, OsuGameBase game)
+        {
+            TestRuleset.Resources = new TestResourceStore(game.Resources);
+
+            Dependencies.CacheAs<RulesetStore>(new TestRulesetStore(rulesets));
+
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = Toolbar.HEIGHT,
+                Child = new ToolbarRulesetSelector(),
+            };
+        }
+
+        private class TestRulesetStore : RulesetStore
+        {
+            public TestRulesetStore(RulesetStore store)
+            {
+                AvailableRulesets = store.AvailableRulesets.Append(new TestRuleset().RulesetInfo);
+            }
+
+            public override IEnumerable<RulesetInfo> AvailableRulesets { get; }
+        }
+
+        private class TestRuleset : Ruleset
+        {
+            public static IResourceStore<byte[]> Resources { get; set; } = null!;
+
+            public override IEnumerable<Mod> GetModsFor(ModType type) => Enumerable.Empty<Mod>();
+
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod>? mods = null) => null!;
+
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => null!;
+
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => null!;
+
+            public override IResourceStore<byte[]> CreateResourceStore() => Resources;
+
+            public override string Description => "Test Ruleset";
+            public override string ShortName => "test";
+        }
+
+        private class TestResourceStore : ResourceStore<byte[]>
+        {
+            public TestResourceStore(IResourceStore<byte[]> store)
+                : base(store)
+            {
+            }
+
+            protected override IEnumerable<string> GetFilenames(string name) => base.GetFilenames(name)
+                                                                                    .Select(s => s.Replace("UI/ruleset-select-test", "Gameplay/failsound"));
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index 03fe9b8b58..083b5b14fb 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -53,6 +53,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
+        private BeatmapSetInfo importedSet2 = null!;
 
         private TestMultiplayerComponents multiplayerComponents = null!;
 
@@ -81,12 +82,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("import beatmap", () =>
             {
                 beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+
+                importedSet = beatmaps.GetAllUsableBeatmapSets().First();
+                importedSet2 = beatmaps.Import(CreateBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet!)!.Value.Detach();
+
                 Realm.Write(r =>
                 {
                     foreach (var beatmapInfo in r.All<BeatmapInfo>())
                         beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
                 });
-                importedSet = beatmaps.GetAllUsableBeatmapSets().First();
             });
 
             AddStep("load multiplayer", () => LoadScreen(multiplayerComponents = new TestMultiplayerComponents()));
@@ -1095,6 +1099,112 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("global beatmap matches second playlist item", () => Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(multiplayerClient.ClientRoom!.Playlist[1].BeatmapID));
         }
 
+        /// <summary>
+        /// Tests that the local user is not able to change their play style if they haven't downloaded the beatmap (beatmap carousel will be empty).
+        /// </summary>
+        [Test]
+        public void TestCanNotEditDifficultyIfNotDownloaded()
+        {
+            IBeatmap roomBeatmap = null!;
+
+            createRoom(() =>
+            {
+                roomBeatmap = CreateBeatmap(new OsuRuleset().RulesetInfo);
+
+                return new Room
+                {
+                    Name = "Test Room",
+                    QueueMode = QueueMode.AllPlayers,
+                    Playlist =
+                    [
+                        new PlaylistItem(CreateAPIBeatmap(roomBeatmap.BeatmapInfo))
+                        {
+                            RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                            Freestyle = true
+                        }
+                    ]
+                };
+            });
+
+            AddAssert("editing disallowed", () => !this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().UserStyleEditingEnabled);
+            AddStep("import beatmap", () => beatmaps.Import(roomBeatmap.BeatmapInfo.BeatmapSet!));
+            AddAssert("editing allowed", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().UserStyleEditingEnabled);
+        }
+
+        /// <summary>
+        /// Test that the user selection screen is not exited when the beatmap is changed to the same set.
+        /// </summary>
+        [Test]
+        public void TestUserStyleSelectionDoesNotExitWhenBeatmapSetNotChanged()
+        {
+            createRoom(() => new Room
+            {
+                Name = "Test Room",
+                QueueMode = QueueMode.AllPlayers,
+                Playlist =
+                [
+                    new PlaylistItem(importedSet.Beatmaps.First())
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        Freestyle = true
+                    }
+                ]
+            });
+
+            AddStep("open user style selection", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().ShowUserStyleSelect());
+            AddUntilStep("style selection screen opened", () => this.ChildrenOfType<MultiplayerMatchFreestyleSelect>().SingleOrDefault()?.IsCurrentScreen() == true);
+
+            AddStep("change beatmap", () =>
+            {
+                var newItem = multiplayerClient.ServerRoom!.Playlist[0].Clone();
+                var newBeatmap = importedSet.Beatmaps.Last();
+                newItem.BeatmapID = newBeatmap.OnlineID;
+                newItem.BeatmapChecksum = newBeatmap.MD5Hash;
+
+                multiplayerClient.EditPlaylistItem(newItem);
+            });
+
+            AddWaitStep("wait for potential beatmap change", 2);
+            AddAssert("style selection screen still open", () => this.ChildrenOfType<MultiplayerMatchFreestyleSelect>().SingleOrDefault()?.IsCurrentScreen() == true);
+        }
+
+        /// <summary>
+        /// Tests that the user selection screen is exited when the beatmap is changed to another set.
+        /// </summary>
+        [Test]
+        public void TestUserStyleSelectionExitedWhenBeatmapSetChanged()
+        {
+            createRoom(() => new Room
+            {
+                Name = "Test Room",
+                QueueMode = QueueMode.AllPlayers,
+                Playlist =
+                [
+                    new PlaylistItem(importedSet.Beatmaps.First())
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        Freestyle = true
+                    }
+                ]
+            });
+
+            AddStep("open user style selection", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().ShowUserStyleSelect());
+            AddUntilStep("style selection screen opened", () => this.ChildrenOfType<MultiplayerMatchFreestyleSelect>().SingleOrDefault()?.IsCurrentScreen() == true);
+
+            AddStep("change beatmap set", () =>
+            {
+                var newItem = multiplayerClient.ServerRoom!.Playlist[0].Clone();
+                var newBeatmap = importedSet2.Beatmaps.Last();
+                newItem.BeatmapID = newBeatmap.OnlineID;
+                newItem.BeatmapChecksum = newBeatmap.MD5Hash;
+
+                multiplayerClient.EditPlaylistItem(newItem);
+            });
+
+            AddUntilStep("selected beatmap changed", () => Beatmap.Value.BeatmapInfo.Equals(importedSet2.Beatmaps.First()));
+            AddUntilStep("style selection screen closed", () => this.ChildrenOfType<MultiplayerMatchFreestyleSelect>().SingleOrDefault()?.IsCurrentScreen() != true);
+        }
+
         private void enterGameplay()
         {
             pressReadyButton();
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
index e0a0e5a785..aa4c4949fb 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
@@ -13,6 +13,7 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
@@ -53,10 +54,17 @@ namespace osu.Game.Tests.Visual.Multiplayer
             Dependencies.Cache(new RealmRulesetStore(Realm));
             Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, Beatmap.Default));
             Dependencies.Cache(Realm);
+            Dependencies.CacheAs<BeatmapStore>(new RealmDetachedBeatmapStore());
 
             beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
 
             importedSet = beatmaps.GetAllUsableBeatmapSets().First();
+
+            Realm.Write(r =>
+            {
+                foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                    beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+            });
         }
 
         public override void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index d50fc69823..dcfbea6e92 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -471,7 +471,7 @@ namespace osu.Game.Tests.Visual.Navigation
             {
                 AddUntilStep($"config value is {configValue}", () => getConfigManager().Get<double>(ManiaRulesetSetting.ScrollSpeed), () => Is.EqualTo(configValue));
                 AddUntilStep($"gameplay value is {gameplayValue}", () => this.ChildrenOfType<DrawableManiaRuleset>().Single().TargetTimeRange,
-                    () => Is.EqualTo(DrawableManiaRuleset.ComputeScrollTime(gameplayValue)));
+                    () => Is.EqualTo(DrawableManiaRuleset.ComputeScrollTime(gameplayValue, 200, 5)));
             }
 
             ManiaRulesetConfigManager getConfigManager() => ((ManiaRulesetConfigManager)Game.Dependencies.Get<IRulesetConfigCache>().GetConfigFor(new ManiaRuleset())!);
diff --git a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
index f36ef7a8e8..5da05826cf 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
@@ -10,6 +10,8 @@ using osu.Game.Rulesets;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics.Sprites;
@@ -193,7 +195,8 @@ namespace osu.Game.Tests.Visual.Online
                 overlay.ShowBeatmapSet(set);
             });
 
-            AddAssert("shown beatmaps of current ruleset", () => overlay.Header.HeaderContent.Picker.Difficulties.All(b => b.Beatmap.Ruleset.OnlineID == overlay.Header.RulesetSelector.Current.Value.OnlineID));
+            AddAssert("shown beatmaps of current ruleset",
+                () => overlay.Header.HeaderContent.Picker.Difficulties.All(b => b.Beatmap.Ruleset.OnlineID == overlay.Header.RulesetSelector.Current.Value.OnlineID));
             AddAssert("left-most beatmap selected", () => overlay.Header.HeaderContent.Picker.Difficulties.First().State == BeatmapPicker.DifficultySelectorState.Selected);
         }
 
@@ -373,6 +376,39 @@ namespace osu.Game.Tests.Visual.Online
             });
         }
 
+        [Test]
+        public void TestBeatmapsetWithDeletedUser()
+        {
+            AddStep("show map with deleted user", () =>
+            {
+                JObject jsonBlob = JObject.FromObject(getBeatmapSet(), new JsonSerializer
+                {
+                    ReferenceLoopHandling = ReferenceLoopHandling.Ignore
+                });
+
+                jsonBlob["user"] = JToken.Parse(
+                    """
+                    {
+                        "avatar_url": null,
+                        "country_code": null,
+                        "default_group": "default",
+                        "id": null,
+                        "is_active": false,
+                        "is_bot": false,
+                        "is_deleted": true,
+                        "is_online": false,
+                        "is_supporter": false,
+                        "last_visit": null,
+                        "pm_friends_only": false,
+                        "profile_colour": null,
+                        "username": "[deleted user]"
+                    }
+                    """);
+
+                overlay.ShowBeatmapSet(JsonConvert.DeserializeObject<APIBeatmapSet>(JsonConvert.SerializeObject(jsonBlob)));
+            });
+        }
+
         private APIBeatmapSet createManyDifficultiesBeatmapSet()
         {
             var set = getBeatmapSet();
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
index 61269a7bf4..e3137d77d7 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
@@ -274,6 +274,29 @@ namespace osu.Game.Tests.Visual.Playlists
             AddUntilStep("all panels have non-negative position", () => this.ChildrenOfType<ScorePanel>().All(p => p.ScorePosition.Value > 0));
         }
 
+        [Test]
+        public void TestPresentInvalidOnlineScore()
+        {
+            AddStep("set up invalid user score", () =>
+            {
+                userScore.OnlineID = -1;
+                userScore.TotalScore = 0;
+            });
+
+            AddStep("bind user score info handler", () => bindHandler(userScore: userScore));
+
+            createResultsWithScore(() => userScore);
+
+            AddUntilStep("wait for user score to be displayed", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().GetScorePanels().Any());
+            AddWaitStep("wait for any more potential scores", 5);
+            AddAssert("only 1 score visible", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().GetScorePanels().Count(), () => Is.EqualTo(1));
+
+            AddUntilStep("left loading spinner hidden", () =>
+                resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreLeft).State.Value == Visibility.Hidden);
+            AddUntilStep("right loading spinner hidden", () =>
+                resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Hidden);
+        }
+
         private void createResultsWithScore(Func<ScoreInfo> getScore)
         {
             AddStep("load results", () =>
@@ -359,7 +382,7 @@ namespace osu.Game.Tests.Visual.Playlists
                 switch (request)
                 {
                     case ShowPlaylistScoreRequest s:
-                        if (userScore == null)
+                        if (userScore == null || userScore.OnlineID == -1)
                             triggerFail(s);
                         else
                             triggerSuccess(s, () => createUserResponse(userScore));
@@ -367,7 +390,7 @@ namespace osu.Game.Tests.Visual.Playlists
                         break;
 
                     case ShowPlaylistUserScoreRequest u:
-                        if (userScore == null)
+                        if (userScore == null || userScore.OnlineID == -1)
                             triggerFail(u);
                         else
                             triggerSuccess(u, () => createUserResponse(userScore));
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
index 29b4955d02..2874384c4d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
@@ -333,22 +333,32 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         #endregion
 
+        #region Source grouping
+
+        [Test]
+        public async Task TestGroupingBySource()
+        {
+            int total = 0;
+
+            var beatmapSets = new List<BeatmapSetInfo>();
+            addBeatmapSet(s => s.Beatmaps[0].Metadata.Source = "Cool Game", beatmapSets, out var beatmapCoolGame);
+            addBeatmapSet(s => s.Beatmaps[0].Metadata.Source = "Cool game", beatmapSets, out var beatmapCoolGameB);
+            addBeatmapSet(s => s.Beatmaps[0].Metadata.Source = "Nice Movie", beatmapSets, out var beatmapNiceMovie);
+            addBeatmapSet(s => s.Beatmaps[0].Metadata.Source = string.Empty, beatmapSets, out var beatmapUnsourced);
+
+            var results = await runGrouping(GroupMode.Source, beatmapSets);
+            assertGroup(results, 0, "Cool Game", new[] { beatmapCoolGame, beatmapCoolGameB }, ref total);
+            assertGroup(results, 1, "Nice Movie", new[] { beatmapNiceMovie }, ref total);
+            assertGroup(results, 2, "Unsourced", new[] { beatmapUnsourced }, ref total);
+            assertTotal(results, total);
+        }
+
+        #endregion
+
         private static async Task<List<CarouselItem>> runGrouping(GroupMode group, List<BeatmapSetInfo> beatmapSets)
         {
             var groupingFilter = new BeatmapCarouselFilterGrouping(() => new FilterCriteria { Group = group });
-            var carouselItems = await groupingFilter.Run(beatmapSets.SelectMany(s => s.Beatmaps.Select(b => new CarouselItem(b))).ToList(), CancellationToken.None);
-
-            // sanity check to ensure no detection of two group items with equal order value.
-            var groups = carouselItems.Select(i => i.Model).OfType<GroupDefinition>();
-
-            foreach (var header in groups)
-            {
-                var sameOrder = groups.FirstOrDefault(g => g != header && g.Order == header.Order);
-                if (sameOrder != null)
-                    Assert.Fail($"Detected two groups with equal order number: \"{header.Title}\" vs. \"{sameOrder.Title}\"");
-            }
-
-            return carouselItems;
+            return await groupingFilter.Run(beatmapSets.SelectMany(s => s.Beatmaps.Select(b => new CarouselItem(b))).ToList(), CancellationToken.None);
         }
 
         private static void assertGroup(List<CarouselItem> items, int index, string expectedTitle, IEnumerable<BeatmapSetInfo> expectedBeatmapSets, ref int totalItems)
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
index c704f21fa4..ba7759d8a5 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
@@ -5,6 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -145,14 +146,27 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddUntilStep("wait for filtering", () => !Carousel.IsFiltering);
         }
 
-        protected void ImportBeatmapForRuleset(int rulesetId)
+        protected void SortBy(SortMode mode) => AddStep($"sort by {mode.GetDescription().ToLowerInvariant()}", () => Config.SetValue(OsuSetting.SongSelectSortingMode, mode));
+
+        protected void GroupBy(GroupMode mode) => AddStep($"group by {mode.GetDescription().ToLowerInvariant()}", () => Config.SetValue(OsuSetting.SongSelectGroupMode, mode));
+
+        protected void SortAndGroupBy(SortMode sort, GroupMode group)
+        {
+            AddStep($"sort by {sort.GetDescription().ToLowerInvariant()} & group by {group.GetDescription().ToLowerInvariant()}", () =>
+            {
+                Config.SetValue(OsuSetting.SongSelectSortingMode, sort);
+                Config.SetValue(OsuSetting.SongSelectGroupMode, group);
+            });
+        }
+
+        protected void ImportBeatmapForRuleset(params int[] rulesetIds)
         {
             int beatmapsCount = 0;
 
-            AddStep($"import test map for ruleset {rulesetId}", () =>
+            AddStep($"import test map for ruleset {rulesetIds}", () =>
             {
                 beatmapsCount = SongSelect.IsNull() ? 0 : Carousel.Filters.OfType<BeatmapCarouselFilterGrouping>().Single().SetItems.Count;
-                Beatmaps.Import(TestResources.CreateTestBeatmapSetInfo(3, Rulesets.AvailableRulesets.Where(r => r.OnlineID == rulesetId).ToArray()));
+                Beatmaps.Import(TestResources.CreateTestBeatmapSetInfo(3, Rulesets.AvailableRulesets.Where(r => rulesetIds.Contains(r.OnlineID)).ToArray()));
             });
 
             // This is specifically for cases where the add is happening post song select load.
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
index 3dd6fed708..0ee742a09d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
@@ -162,5 +162,23 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("statistics still visible", () => display.ChildrenOfType<BeatmapTitleWedge.StatisticDifficulty>().First().Parent!.Alpha == 1);
             AddAssert("tiny statistics still hidden", () => display.ChildrenOfType<GridContainer>().Last().Alpha == 0);
         }
+
+        [Test]
+        public void TestMaximumLength()
+        {
+            AddStep("setup auto size", () => Child = display = new BeatmapTitleWedge.DifficultyStatisticsDisplay(true)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            AddStep("set long statistics", () => display.Statistics = new[]
+            {
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 1", 0.2f, 0.2f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 2", 0.7f, 0.7f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 3", 0.4f, 0.8f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 4", 0.3f, 0.3f, 1f),
+            });
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
new file mode 100644
index 0000000000..857691a399
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
@@ -0,0 +1,253 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    /// <summary>
+    /// The fallback behaviour guaranteed by SongSelect is that a random selection will happen in worst case scenario.
+    /// Every case we're testing here is expected to have a *custom behaviour* – engaging and overriding this random selection fallback.
+    ///
+    /// The scenarios we care abouts are:
+    /// - Ruleset change (select another difficulty from same set for the new ruleset, if possible).
+    /// - Beatmap difficulty hidden (select closest valid difficulty from same set)
+    /// - Beatmap set deleted (select closest valid beatmap post-deletion)
+    ///
+    /// We are working with 5 sets, each with 3 difficulties (all osu! ruleset).
+    /// </summary>
+    public partial class TestSceneSongSelectCurrentSelectionInvalidated : SongSelectTestScene
+    {
+        private BeatmapInfo? selectedBeatmap => (BeatmapInfo?)Carousel.CurrentSelection;
+        private BeatmapSetInfo? selectedBeatmapSet => selectedBeatmap?.BeatmapSet;
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            for (int i = 0; i < 5; i++)
+                ImportBeatmapForRuleset(0);
+
+            LoadSongSelect();
+        }
+
+        [Test]
+        public void TestRulesetChange()
+        {
+            AddStep("disable converts", () => Config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
+
+            ImportBeatmapForRuleset(0, 1);
+            ImportBeatmapForRuleset(0, 1);
+            ImportBeatmapForRuleset(0, 2);
+            waitForFiltering(5);
+
+            ChangeRuleset(1);
+            waitForFiltering(6);
+
+            BeatmapInfo? initiallySelected = null;
+            AddAssert("selected is taiko", () => (initiallySelected = selectedBeatmap)?.Ruleset.OnlineID, () => Is.EqualTo(1));
+
+            ChangeRuleset(0);
+            waitForFiltering(7);
+            AddAssert("selected is osu", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(0));
+            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+
+            ChangeRuleset(1);
+            waitForFiltering(8);
+            AddAssert("selected is taiko", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+
+            ChangeRuleset(2);
+            waitForFiltering(9);
+            AddAssert("selected is catch", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(2));
+            AddAssert("selected is different set", () => selectedBeatmap?.BeatmapSet, () => Is.Not.EqualTo(initiallySelected!.BeatmapSet));
+        }
+
+        /// <summary>
+        /// Make sure that deleting all sets doesn't hit some weird edge case / crash.
+        /// </summary>
+        [TestCase(SortMode.Title)]
+        [TestCase(SortMode.Artist)]
+        [TestCase(SortMode.Difficulty)]
+        public void TestDeleteAllSets(SortMode sortMode)
+        {
+            int filterCount = sortMode != SortMode.Title ? 2 : 1;
+
+            SortBy(sortMode);
+            waitForFiltering(filterCount);
+
+            BeatmapSetInfo deletedSet = null!;
+
+            for (int i = 0; i < 4; i++)
+            {
+                AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+                waitForFiltering(filterCount + 1 + i);
+                selectionChangedFrom(() => deletedSet);
+            }
+
+            // The carousel still holds an invalid selection after the final deletion. Probably fine?
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            AddUntilStep("wait for no global selection", () => Beatmap.IsDefault, () => Is.True);
+        }
+
+        [Test]
+        public void DifficultiesGrouped_DeleteSet_SelectsAdjacent()
+        {
+            SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
+            waitForFiltering(2);
+
+            makePanelSelected<PanelGroupStarDifficulty>(2);
+            makePanelSelected<PanelBeatmapStandalone>(3);
+
+            // Deleting second-last, should select last
+            BeatmapSetInfo deletedSet = null!;
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            waitForFiltering(3);
+
+            selectionChangedFrom(() => deletedSet);
+            assertPanelSelected<PanelBeatmapStandalone>(3);
+
+            // Deleting last, should select previous
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            waitForFiltering(4);
+
+            selectionChangedFrom(() => deletedSet);
+            assertPanelSelected<PanelBeatmapStandalone>(2);
+        }
+
+        [TestCase(SortMode.Title)]
+        [TestCase(SortMode.Artist)]
+        public void SetsGrouped_DeleteSet_SelectsAdjacent(SortMode sortMode)
+        {
+            int filterCount = sortMode != SortMode.Title ? 2 : 1;
+
+            SortBy(sortMode);
+            waitForFiltering(filterCount);
+
+            makePanelSelected<PanelBeatmapSet>(3);
+
+            // Deleting second-last, should select last
+            BeatmapSetInfo deletedSet = null!;
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            waitForFiltering(filterCount + 1);
+
+            selectionChangedFrom(() => deletedSet);
+            assertPanelSelected<PanelBeatmapSet>(3);
+            assertPanelSelected<PanelBeatmap>(0);
+
+            // Deleting last, should select previous
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            waitForFiltering(filterCount + 2);
+
+            selectionChangedFrom(() => deletedSet);
+            assertPanelSelected<PanelBeatmapSet>(2);
+            assertPanelSelected<PanelBeatmap>(0);
+        }
+
+        // Same scenario as the test case above, but where selected difficulty before deletion is not first index in the expanded set.
+        // Basically ensures that the reselection is running `RequestRecommendedSelection` and not just relying on indices.
+        [TestCase(SortMode.Title)]
+        [TestCase(SortMode.Artist)]
+        public void SetsGrouped_DeleteSet_SelectsNextSetRecommendedDifficulty(SortMode sortMode)
+        {
+            int filterCount = sortMode != SortMode.Title ? 2 : 1;
+
+            SortBy(sortMode);
+            waitForFiltering(filterCount);
+
+            makePanelSelected<PanelBeatmapSet>(2);
+            makePanelSelected<PanelBeatmap>(2);
+
+            AddUntilStep("wait for beatmap to be selected", () => selectedBeatmapSet != null);
+
+            BeatmapSetInfo deletedSet = null!;
+            AddStep("delete selected", () => Beatmaps.Delete(deletedSet = selectedBeatmapSet!));
+            waitForFiltering(++filterCount);
+
+            selectionChangedFrom(() => deletedSet);
+            assertPanelSelected<PanelBeatmapSet>(2);
+            assertPanelSelected<PanelBeatmap>(0);
+        }
+
+        [Test]
+        public void TestHideBeatmap()
+        {
+            makePanelSelected<PanelBeatmapSet>(2);
+            makePanelSelected<PanelBeatmap>(1);
+
+            BeatmapInfo hiddenBeatmap = null!;
+
+            AddStep("hide selected", () => Beatmaps.Hide(hiddenBeatmap = selectedBeatmap!));
+            waitForFiltering(2);
+
+            AddAssert("selected beatmap below", () => selectedBeatmap!.BeatmapSet, () => Is.EqualTo(hiddenBeatmap.BeatmapSet));
+
+            AddStep("hide selected", () => Beatmaps.Hide(hiddenBeatmap = selectedBeatmap!));
+            waitForFiltering(3);
+
+            AddAssert("selected beatmap below", () => selectedBeatmap!.BeatmapSet, () => Is.EqualTo(hiddenBeatmap.BeatmapSet));
+            assertPanelSelected<PanelBeatmap>(0);
+        }
+
+        private void waitForFiltering(int filterCount = 1)
+        {
+            AddUntilStep("wait for filter count", () => Carousel.FilterCount, () => Is.EqualTo(filterCount));
+            AddUntilStep("filtering finished", () => Carousel.IsFiltering, () => Is.False);
+        }
+
+        private void makePanelSelected<T>(int index)
+            where T : Panel
+        {
+            AddStep($"click panel at index {index} if not selected", () =>
+            {
+                var panel = allPanels<T>().ElementAt(index).ChildrenOfType<Panel>().Single();
+
+                // May have already been selected randomly. Don't click a second time or gameplay will start.
+                if (!panel.Selected.Value)
+                    panel.TriggerClick();
+            });
+
+            assertPanelSelected<T>(index);
+        }
+
+        private void selectionChangedFrom(Func<BeatmapSetInfo> deletedSet) =>
+            AddUntilStep("selection changed", () => selectedBeatmapSet, () => Is.Not.EqualTo(deletedSet()));
+
+        private void assertPanelSelected<T>(int index)
+            where T : Panel
+            => AddUntilStep($"selected panel at index {index}", getActivePanelIndex<T>, () => Is.EqualTo(index));
+
+        private int getActivePanelIndex<T>()
+            where T : Panel
+            => allPanels<T>().ToList().FindIndex(p =>
+            {
+                switch (p)
+                {
+                    case PanelBeatmapStandalone pb:
+                        return pb.Selected.Value;
+
+                    case PanelBeatmap pb:
+                        return pb.Selected.Value;
+
+                    case Panel pbs:
+                        return pbs.Expanded.Value;
+
+                    default:
+                        throw new InvalidOperationException();
+                }
+            });
+
+        private IEnumerable<T> allPanels<T>()
+            where T : Panel
+            => Carousel.ChildrenOfType<T>().Where(p => p.Item != null).OrderBy(p => p.Y);
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
index 19fccdf94d..16ad970239 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
@@ -117,14 +117,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             // TODO: old test has this step, but there doesn't seem to be any purpose for it.
             // AddUntilStep("random map selected", () => Beatmap.Value != defaultBeatmap);
 
-            AddStep(@"Sort by Artist", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Artist));
-            AddStep(@"Sort by Title", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Title));
-            AddStep(@"Sort by Author", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Author));
-            AddStep(@"Sort by DateAdded", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.DateAdded));
-            AddStep(@"Sort by BPM", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.BPM));
-            AddStep(@"Sort by Length", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Length));
-            AddStep(@"Sort by Difficulty", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Difficulty));
-            AddStep(@"Sort by Source", () => Config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Source));
+            SortBy(SortMode.Artist);
+            SortBy(SortMode.Title);
+            SortBy(SortMode.Author);
+            SortBy(SortMode.DateAdded);
+            SortBy(SortMode.BPM);
+            SortBy(SortMode.Length);
+            SortBy(SortMode.Difficulty);
+            SortBy(SortMode.Source);
         }
 
         [Test]
@@ -309,6 +309,24 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             checkMatchedBeatmaps(3);
         }
 
+        [Test]
+        public void TestCantHideAllBeatmaps()
+        {
+            LoadSongSelect();
+            ImportBeatmapForRuleset(0);
+
+            checkMatchedBeatmaps(3);
+
+            AddStep("hide selected", () => Beatmaps.Hide(Beatmap.Value.BeatmapInfo));
+            checkMatchedBeatmaps(2);
+
+            AddStep("hide selected", () => Beatmaps.Hide(Beatmap.Value.BeatmapInfo));
+            checkMatchedBeatmaps(1);
+
+            AddAssert("hide fails", () => Beatmaps.Hide(Beatmap.Value.BeatmapInfo), () => Is.False);
+            checkMatchedBeatmaps(1);
+        }
+
         private NoResultsPlaceholder? getPlaceholder() => SongSelect.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
 
         private void checkMatchedBeatmaps(int expected) => AddUntilStep($"{expected} matching shown", () => Carousel.MatchedBeatmapsCount, () => Is.EqualTo(expected));
diff --git a/osu.Game.Tournament/Screens/Setup/SetupScreen.cs b/osu.Game.Tournament/Screens/Setup/SetupScreen.cs
index fed9d625ee..536e8ba767 100644
--- a/osu.Game.Tournament/Screens/Setup/SetupScreen.cs
+++ b/osu.Game.Tournament/Screens/Setup/SetupScreen.cs
@@ -12,6 +12,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Tournament.IPC;
@@ -42,6 +43,7 @@ namespace osu.Game.Tournament.Screens.Setup
         [Resolved]
         private TournamentSceneManager? sceneManager { get; set; }
 
+        private readonly IBindable<APIUser> localUser = new Bindable<APIUser>();
         private Bindable<Size> windowSize = null!;
 
         [BackgroundDependencyLoader]
@@ -70,7 +72,8 @@ namespace osu.Game.Tournament.Screens.Setup
                 },
             };
 
-            api.LocalUser.BindValueChanged(_ => Schedule(reload));
+            localUser.BindTo(api.LocalUser);
+            localUser.BindValueChanged(_ => Schedule(reload));
             stableInfo.OnStableInfoSaved += () => Schedule(reload);
             reload();
         }
diff --git a/osu.Game/Beatmaps/BeatmapManager.cs b/osu.Game/Beatmaps/BeatmapManager.cs
index 2c17908487..a3e7c1365e 100644
--- a/osu.Game/Beatmaps/BeatmapManager.cs
+++ b/osu.Game/Beatmaps/BeatmapManager.cs
@@ -218,24 +218,37 @@ namespace osu.Game.Beatmaps
         }
 
         /// <summary>
-        /// Delete a beatmap difficulty.
+        /// Hide a beatmap difficulty.
+        /// Will fail if all difficulties are about to be hidden.
         /// </summary>
         /// <param name="beatmapInfo">The beatmap difficulty to hide.</param>
-        public void Hide(BeatmapInfo beatmapInfo)
+        public bool Hide(BeatmapInfo beatmapInfo)
         {
-            Realm.Run(r =>
+            return Realm.Run(r =>
             {
                 using (var transaction = r.BeginWrite())
                 {
                     if (!beatmapInfo.IsManaged)
                         beatmapInfo = r.Find<BeatmapInfo>(beatmapInfo.ID)!;
 
+                    if (!CanHide(beatmapInfo))
+                        return false;
+
                     beatmapInfo.Hidden = true;
                     transaction.Commit();
+                    return true;
                 }
             });
         }
 
+        public bool CanHide(BeatmapInfo beatmapInfo) => Realm.Run(r =>
+        {
+            if (!beatmapInfo.IsManaged)
+                beatmapInfo = r.Find<BeatmapInfo>(beatmapInfo.ID)!;
+
+            return beatmapInfo.BeatmapSet!.Beatmaps.Count(b => !b.Hidden) > 1;
+        });
+
         /// <summary>
         /// Restore a beatmap difficulty.
         /// </summary>
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
index 56103c1d6d..135e5129ae 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             }
         }
 
-        public MenuItem[] ContextMenuItems => new MenuItem[]
+        public virtual MenuItem[] ContextMenuItems => new MenuItem[]
         {
             new OsuMenuItem(ContextMenuStrings.ViewBeatmap, MenuItemType.Highlighted, Action),
         };
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
index ebd0113379..9428984115 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
@@ -1,14 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps.Drawables.Cards.Statistics;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
@@ -321,5 +325,21 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             buttonContainer.ShowDetails.Value = showDetails;
             thumbnail.Dimmed.Value = showDetails;
         }
+
+        public override MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                var items = base.ContextMenuItems.ToList();
+
+                foreach (var button in buttonContainer.Buttons)
+                {
+                    if (button.Enabled.Value)
+                        items.Add(new OsuMenuItem(button.TooltipText.ToSentence(), MenuItemType.Standard, () => button.TriggerClick()));
+                }
+
+                return items.ToArray();
+            }
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
index 4ab2b0c973..62108fe6f5 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
@@ -1,13 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Resources.Localisation.Web;
@@ -165,5 +169,21 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
             buttonContainer.ShowDetails.Value = showDetails;
         }
+
+        public override MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                var items = base.ContextMenuItems.ToList();
+
+                foreach (var button in buttonContainer.Buttons)
+                {
+                    if (button.Enabled.Value)
+                        items.Add(new OsuMenuItem(button.TooltipText.ToSentence(), MenuItemType.Standard, () => button.TriggerClick()));
+                }
+
+                return items.ToArray();
+            }
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
index 724919f3bd..505a6fcdae 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
@@ -2,14 +2,18 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps.Drawables.Cards.Statistics;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
@@ -291,5 +295,21 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
             statisticsContainer.FadeTo(showDetails ? 1 : 0, TRANSITION_DURATION, Easing.OutQuint);
         }
+
+        public override MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                var items = base.ContextMenuItems.ToList();
+
+                foreach (var button in buttonContainer.Buttons)
+                {
+                    if (button.Enabled.Value)
+                        items.Add(new OsuMenuItem(button.TooltipText.ToSentence(), MenuItemType.Standard, () => button.TriggerClick()));
+                }
+
+                return items.ToArray();
+            }
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
index e95ac94457..d2c077d010 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
@@ -40,7 +40,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
         private void updateState()
         {
-            this.FadeTo(state.Value == DownloadState.LocallyAvailable ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
+            Enabled.Value = state.Value == DownloadState.LocallyAvailable;
+            this.FadeTo(Enabled.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
         }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
index 5ab6e1a218..56d405ce3c 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -48,6 +49,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             }
         }
 
+        public IEnumerable<BeatmapCardIconButton> Buttons => buttons;
+
         protected override Container<Drawable> Content => mainContent;
 
         private readonly Container background;
diff --git a/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs b/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
index 8182fe24b2..cc76e28dfe 100644
--- a/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
+++ b/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
@@ -140,7 +140,7 @@ namespace osu.Game.Beatmaps.Drawables
             }
 
             Ruleset ruleset = displayedContent.Ruleset.CreateInstance();
-            BeatmapDifficulty adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(originalDifficulty, rate);
+            BeatmapDifficulty adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(originalDifficulty, displayedContent.Mods ?? []);
 
             circleSize.Text = @"CS: " + adjustedDifficulty.CircleSize.ToString(@"0.##");
             drainRate.Text = @" HP: " + adjustedDifficulty.DrainRate.ToString(@"0.##");
diff --git a/osu.Game/Database/RealmAccess.cs b/osu.Game/Database/RealmAccess.cs
index 6e8107a9fd..449cedbb1e 100644
--- a/osu.Game/Database/RealmAccess.cs
+++ b/osu.Game/Database/RealmAccess.cs
@@ -102,8 +102,6 @@ namespace osu.Game.Database
         /// </summary>
         private const int schema_version = 49;
 
-        public static int SchemaVersion => schema_version;
-
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking realm retrieval during blocking periods.
         /// </summary>
diff --git a/osu.Game/Graphics/Carousel/Carousel.cs b/osu.Game/Graphics/Carousel/Carousel.cs
index b0e2ad428e..eaf075cd83 100644
--- a/osu.Game/Graphics/Carousel/Carousel.cs
+++ b/osu.Game/Graphics/Carousel/Carousel.cs
@@ -307,7 +307,7 @@ namespace osu.Game.Graphics.Carousel
         /// <summary>
         /// Retrieve a list of all <see cref="CarouselItem"/>s currently displayed.
         /// </summary>
-        public IReadOnlyCollection<CarouselItem>? GetCarouselItems() => carouselItems;
+        public IList<CarouselItem>? GetCarouselItems() => carouselItems;
 
         private List<CarouselItem>? carouselItems;
 
@@ -691,6 +691,11 @@ namespace osu.Game.Graphics.Carousel
         /// </summary>
         protected CarouselItem? CurrentSelectionItem => currentSelection.CarouselItem;
 
+        /// <summary>
+        /// The index in <see cref="GetCarouselItems"/> of the current selection, if available.
+        /// </summary>
+        protected int? CurrentSelectionIndex => currentSelection.Index;
+
         /// <summary>
         /// Becomes invalid when the current selection has changed and needs to be updated visually.
         /// </summary>
diff --git a/osu.Game/Graphics/Containers/OsuTextFlowContainer.cs b/osu.Game/Graphics/Containers/OsuTextFlowContainer.cs
index 8da8b7ed7d..dcb7f8efdd 100644
--- a/osu.Game/Graphics/Containers/OsuTextFlowContainer.cs
+++ b/osu.Game/Graphics/Containers/OsuTextFlowContainer.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
@@ -14,23 +12,27 @@ namespace osu.Game.Graphics.Containers
 {
     public partial class OsuTextFlowContainer : TextFlowContainer
     {
-        public OsuTextFlowContainer(Action<SpriteText> defaultCreationParameters = null)
+        public OsuTextFlowContainer(Action<SpriteText>? defaultCreationParameters = null)
             : base(defaultCreationParameters)
         {
         }
 
         protected override SpriteText CreateSpriteText() => new OsuSpriteText();
 
-        public ITextPart AddArbitraryDrawable(Drawable drawable) => AddPart(new TextPartManual(new ArbitraryDrawableWrapper { Child = drawable }.Yield()));
+        public ITextPart AddArbitraryDrawable(Drawable drawable) => AddPart(new TextPartManual(new ArbitraryDrawableWrapper(drawable).Yield()));
 
-        public ITextPart AddIcon(IconUsage icon, Action<SpriteText> creationParameters = null) => AddText(icon.Icon.ToString(), creationParameters);
+        public ITextPart AddIcon(IconUsage icon, Action<SpriteText>? creationParameters = null) => AddText(icon.Icon.ToString(), creationParameters);
 
         private partial class ArbitraryDrawableWrapper : Container, IHasLineBaseHeight
         {
-            public float LineBaseHeight => (Child as IHasLineBaseHeight)?.LineBaseHeight ?? DrawHeight;
+            private readonly IHasLineBaseHeight? lineBaseHeightSource;
 
-            public ArbitraryDrawableWrapper()
+            public float LineBaseHeight => lineBaseHeightSource?.LineBaseHeight ?? DrawHeight;
+
+            public ArbitraryDrawableWrapper(Drawable drawable)
             {
+                Child = drawable;
+                lineBaseHeightSource = drawable as IHasLineBaseHeight;
                 AutoSizeAxes = Axes.Both;
             }
         }
diff --git a/osu.Game/Localisation/MenuTipStrings.cs b/osu.Game/Localisation/MenuTipStrings.cs
index 977c0928b2..4d1f2ceaa6 100644
--- a/osu.Game/Localisation/MenuTipStrings.cs
+++ b/osu.Game/Localisation/MenuTipStrings.cs
@@ -10,14 +10,14 @@ namespace osu.Game.Localisation
         private const string prefix = @"osu.Game.Resources.Localisation.MenuTip";
 
         /// <summary>
-        /// "Press Ctrl-T anywhere in the game to toggle the toolbar!"
+        /// "Press {0} anywhere in the game to toggle the toolbar!"
         /// </summary>
-        public static LocalisableString ToggleToolbarShortcut => new TranslatableString(getKey(@"toggle_toolbar_shortcut"), @"Press Ctrl-T anywhere in the game to toggle the toolbar!");
+        public static LocalisableString ToggleToolbarShortcut(LocalisableString keybind) => new TranslatableString(getKey(@"toggle_toolbar_shortcut"), @"Press {0} anywhere in the game to toggle the toolbar!", keybind);
 
         /// <summary>
-        /// "Press Ctrl-O anywhere in the game to access settings!"
+        /// "Press {0} anywhere in the game to access settings!"
         /// </summary>
-        public static LocalisableString GameSettingsShortcut => new TranslatableString(getKey(@"game_settings_shortcut"), @"Press Ctrl-O anywhere in the game to access settings!");
+        public static LocalisableString GameSettingsShortcut(LocalisableString keybind) => new TranslatableString(getKey(@"game_settings_shortcut"), @"Press {0} anywhere in the game to access settings!", keybind);
 
         /// <summary>
         /// "All settings are dynamic and take effect in real-time. Try changing the skin while watching autoplay!"
@@ -40,9 +40,9 @@ namespace osu.Game.Localisation
         public static LocalisableString ScreenScalingSettings => new TranslatableString(getKey(@"screen_scaling_settings"), @"Try adjusting the ""Screen Scaling"" mode to change your gameplay or UI area, even in fullscreen!");
 
         /// <summary>
-        /// "What used to be &quot;osu!direct&quot; is available to all users just like on the website. You can access it anywhere using Ctrl-B!"
+        /// "What used to be &quot;osu!direct&quot; is available to all users just like on the website. You can access it anywhere using {0}!"
         /// </summary>
-        public static LocalisableString FreeOsuDirect => new TranslatableString(getKey(@"free_osu_direct"), @"What used to be ""osu!direct"" is available to all users just like on the website. You can access it anywhere using Ctrl-B!");
+        public static LocalisableString FreeOsuDirect(LocalisableString keybind) => new TranslatableString(getKey(@"free_osu_direct"), @"What used to be ""osu!direct"" is available to all users just like on the website. You can access it anywhere using {0}!", keybind);
 
         /// <summary>
         /// "Seeking in replays is available by dragging on the progress bar at the bottom of the screen or by using the left and right arrow keys!"
@@ -75,9 +75,9 @@ namespace osu.Game.Localisation
         public static LocalisableString ToggleAdvancedFPSCounter => new TranslatableString(getKey(@"toggle_advanced_fps_counter"), @"Toggle advanced frame / thread statistics with Ctrl-F11!");
 
         /// <summary>
-        /// "You can pause during a replay by pressing Space!"
+        /// "You can pause during a replay by pressing {0}!"
         /// </summary>
-        public static LocalisableString ReplayPausing => new TranslatableString(getKey(@"replay_pausing"), @"You can pause during a replay by pressing Space!");
+        public static LocalisableString ReplayPausing(LocalisableString keybind) => new TranslatableString(getKey(@"replay_pausing"), @"You can pause during a replay by pressing {0}!", keybind);
 
         /// <summary>
         /// "Most of the hotkeys in the game are configurable and can be changed to anything you want. Check the bindings panel under input settings!"
@@ -85,9 +85,9 @@ namespace osu.Game.Localisation
         public static LocalisableString ConfigurableHotkeys => new TranslatableString(getKey(@"configurable_hotkeys"), @"Most of the hotkeys in the game are configurable and can be changed to anything you want. Check the bindings panel under input settings!");
 
         /// <summary>
-        /// "Your gameplay HUD can be customised by using the skin layout editor. Open it at any time via Ctrl-Shift-S!"
+        /// "Your gameplay HUD can be customised by using the skin layout editor. Open it at any time via {0}!"
         /// </summary>
-        public static LocalisableString SkinEditor => new TranslatableString(getKey(@"skin_editor"), @"Your gameplay HUD can be customised by using the skin layout editor. Open it at any time via Ctrl-Shift-S!");
+        public static LocalisableString SkinEditor(LocalisableString keybind) => new TranslatableString(getKey(@"skin_editor"), @"Your gameplay HUD can be customised by using the skin layout editor. Open it at any time via {0}!", keybind);
 
         /// <summary>
         /// "You can create mod presets to make toggling your favourite mod combinations easier!"
@@ -100,14 +100,14 @@ namespace osu.Game.Localisation
         public static LocalisableString ModCustomisationSettings => new TranslatableString(getKey(@"mod_customisation_settings"), @"Many mods have customisation settings that drastically change how they function. Click the Customise button in mod select to view settings!");
 
         /// <summary>
-        /// "Press Ctrl-Shift-R to switch to a random skin!"
+        /// "Press {0} to switch to a random skin!"
         /// </summary>
-        public static LocalisableString RandomSkinShortcut => new TranslatableString(getKey(@"random_skin_shortcut"), @"Press Ctrl-Shift-R to switch to a random skin!");
+        public static LocalisableString RandomSkinShortcut(LocalisableString keybind) => new TranslatableString(getKey(@"random_skin_shortcut"), @"Press {0} to switch to a random skin!", keybind);
 
         /// <summary>
-        /// "While watching a replay, press Ctrl-H to toggle replay settings!"
+        /// "While watching a replay, press {0} to toggle replay settings!"
         /// </summary>
-        public static LocalisableString ToggleReplaySettingsShortcut => new TranslatableString(getKey(@"toggle_replay_settings_shortcut"), @"While watching a replay, press Ctrl-H to toggle replay settings!");
+        public static LocalisableString ToggleReplaySettingsShortcut(LocalisableString keybind) => new TranslatableString(getKey(@"toggle_replay_settings_shortcut"), @"While watching a replay, press {0} to toggle replay settings!", keybind);
 
         /// <summary>
         /// "You can easily copy the mods from scores on a leaderboard by right-clicking on them!"
@@ -140,9 +140,9 @@ namespace osu.Game.Localisation
         public static LocalisableString GlobalStatisticsShortcut => new TranslatableString(getKey(@"global_statistics_shortcut"), @"Take a look under the hood at performance counters and enable verbose performance logging with Ctrl-F2!");
 
         /// <summary>
-        /// "When your gameplay HUD is hidden, you can press and hold Ctrl to view it temporarily!"
+        /// "When your gameplay HUD is hidden, you can press and hold {0} to view it temporarily!"
         /// </summary>
-        public static LocalisableString PeekHUDWhenHidden => new TranslatableString(getKey(@"peek_hud_when_hidden"), @"When your gameplay HUD is hidden, you can press and hold Ctrl to view it temporarily!");
+        public static LocalisableString PeekHUDWhenHidden(LocalisableString keybind) => new TranslatableString(getKey(@"peek_hud_when_hidden"), @"When your gameplay HUD is hidden, you can press and hold {0} to view it temporarily!", keybind);
 
         /// <summary>
         /// "Drag and drop any image into the skin editor to load it in quickly!"
diff --git a/osu.Game/Localisation/SongSelectStrings.cs b/osu.Game/Localisation/SongSelectStrings.cs
index 0a031332dd..055caccc87 100644
--- a/osu.Game/Localisation/SongSelectStrings.cs
+++ b/osu.Game/Localisation/SongSelectStrings.cs
@@ -55,9 +55,29 @@ namespace osu.Game.Localisation
         public static LocalisableString EditBeatmap => new TranslatableString(getKey(@"edit_beatmap"), @"Edit beatmap");
 
         /// <summary>
-        /// "{0} stars"
+        /// "Circle Size"
         /// </summary>
-        public static LocalisableString Stars(LocalisableString value) => new TranslatableString(getKey(@"stars"), @"{0} stars", value);
+        public static LocalisableString CircleSize => new TranslatableString(getKey(@"circle_size"), @"Circle Size");
+
+        /// <summary>
+        /// "Key Count"
+        /// </summary>
+        public static LocalisableString KeyCount => new TranslatableString(getKey(@"key_count"), @"Key Count");
+
+        /// <summary>
+        /// "Approach Rate"
+        /// </summary>
+        public static LocalisableString ApproachRate => new TranslatableString(getKey(@"approach_rate"), @"Approach Rate");
+
+        /// <summary>
+        /// "Accuracy"
+        /// </summary>
+        public static LocalisableString Accuracy => new TranslatableString(getKey(@"accuracy"), @"Accuracy");
+
+        /// <summary>
+        /// "HP Drain"
+        /// </summary>
+        public static LocalisableString HPDrain => new TranslatableString(getKey(@"hp_drain"), @"HP Drain");
 
         /// <summary>
         /// "Submitted"
@@ -69,6 +89,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString Ranked => new TranslatableString(getKey(@"ranked"), @"Ranked");
 
+        /// <summary>
+        /// "{0} stars"
+        /// </summary>
+        public static LocalisableString Stars(LocalisableString value) => new TranslatableString(getKey(@"stars"), @"{0} stars", value);
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
index e8e08059b9..dc6c433f29 100644
--- a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
@@ -84,11 +84,26 @@ namespace osu.Game.Online.API.Requests.Responses
         /// The creator of this beatmap set.
         /// </summary>
         /// <remarks>
-        /// This is not included when the set is retrieved via <see cref="SearchBeatmapSetsRequest"/>,
-        /// but the creator's ID and username will be filled in this property from the <see cref="AuthorID"/> and <see cref="AuthorString"/> properties.
+        /// This property is set differently depending on the API endpoint. When retrieved via <see cref="SearchBeatmapSetsRequest"/>,
+        /// detailed user info is not included and the creator's ID and username are filled from the <see cref="AuthorID"/> and
+        /// <see cref="AuthorString"/> properties. For other API endpoints, this property is set by the <see cref="author"/> setter.
+        /// </remarks>
+        public APIUser Author = new APIUser();
+
+        /// <summary>
+        /// Helper property to deserialize the detailed user info to <see cref="Author"/>
+        /// </summary>
+        /// <remarks>
+        /// This setter implements special handling for deleted users. When received a user with ID 1, it indicates
+        /// the original user has been deleted. In such cases, the existing <see cref="Author"/> data
+        /// (filled from <see cref="AuthorID"/> and <see cref="AuthorString"/>) is preserved. For valid user,
+        /// the provided user info replaces the existing <see cref="Author"/>.
         /// </remarks>
         [JsonProperty(@"user")]
-        public APIUser Author = new APIUser();
+        private APIUser author
+        {
+            set => Author = value.Id != 1 ? value : Author;
+        }
 
         /// <summary>
         /// The ID of the beatmap set's creator.
diff --git a/osu.Game/Online/API/Requests/Responses/APIUser.cs b/osu.Game/Online/API/Requests/Responses/APIUser.cs
index 4e219cdf22..6f122c58af 100644
--- a/osu.Game/Online/API/Requests/Responses/APIUser.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIUser.cs
@@ -22,7 +22,8 @@ namespace osu.Game.Online.API.Requests.Responses
         /// </summary>
         public const int SYSTEM_USER_ID = 0;
 
-        [JsonProperty(@"id")]
+        // In osu-web, deleted users have a null ID. When deserializing, we ignore the null value and use 1 instead.
+        [JsonProperty(@"id", NullValueHandling = NullValueHandling.Ignore)]
         public int Id { get; set; } = 1;
 
         [JsonProperty(@"join_date")]
diff --git a/osu.Game/Online/Chat/ChannelManager.cs b/osu.Game/Online/Chat/ChannelManager.cs
index e9ca0a8ed2..fde6c4db06 100644
--- a/osu.Game/Online/Chat/ChannelManager.cs
+++ b/osu.Game/Online/Chat/ChannelManager.cs
@@ -9,6 +9,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
 using osu.Framework.Threading;
@@ -64,7 +65,6 @@ namespace osu.Game.Online.Chat
         public IBindableList<Channel> AvailableChannels => availableChannels;
 
         private readonly IAPIProvider api;
-        private readonly IChatClient chatClient;
 
         [Resolved]
         private UserLookupCache users { get; set; }
@@ -72,6 +72,7 @@ namespace osu.Game.Online.Chat
         private readonly IBindable<APIState> apiState = new Bindable<APIState>();
         private ScheduledDelegate scheduledAck;
 
+        private IChatClient chatClient = null!;
         private long? lastSilenceMessageId;
         private uint? lastSilenceId;
 
@@ -79,14 +80,13 @@ namespace osu.Game.Online.Chat
         {
             this.api = api;
 
-            chatClient = api.GetChatClient();
-
             CurrentChannel.ValueChanged += currentChannelChanged;
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
+            chatClient = api.GetChatClient();
             chatClient.ChannelJoined += ch => Schedule(() => joinChannel(ch));
             chatClient.ChannelParted += ch => Schedule(() => leaveChannel(getChannel(ch), false));
             chatClient.NewMessages += msgs => Schedule(() => addMessages(msgs));
@@ -282,8 +282,7 @@ namespace osu.Game.Online.Chat
 
                     // Check if the user has joined the requested channel already.
                     // This uses the channel name for comparison as the PM user's username is unavailable after a restart.
-                    var privateChannel = JoinedChannels.FirstOrDefault(
-                        c => c.Type == ChannelType.PM && c.Users.Count == 1 && c.Name.Equals(content, StringComparison.OrdinalIgnoreCase));
+                    var privateChannel = JoinedChannels.FirstOrDefault(c => c.Type == ChannelType.PM && c.Users.Count == 1 && c.Name.Equals(content, StringComparison.OrdinalIgnoreCase));
 
                     if (privateChannel != null)
                     {
@@ -645,7 +644,9 @@ namespace osu.Game.Online.Chat
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
-            chatClient?.Dispose();
+
+            if (chatClient.IsNotNull())
+                chatClient.Dispose();
         }
     }
 
diff --git a/osu.Game/Online/LocalUserStatisticsProvider.cs b/osu.Game/Online/LocalUserStatisticsProvider.cs
index 22d5788c87..061f0c7e03 100644
--- a/osu.Game/Online/LocalUserStatisticsProvider.cs
+++ b/osu.Game/Online/LocalUserStatisticsProvider.cs
@@ -5,10 +5,12 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Users;
 
@@ -35,6 +37,8 @@ namespace osu.Game.Online
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
+        private readonly IBindable<APIUser> localUser = new Bindable<APIUser>();
+
         private readonly Dictionary<string, UserStatistics> statisticsCache = new Dictionary<string, UserStatistics>();
 
         /// <summary>
@@ -48,7 +52,8 @@ namespace osu.Game.Online
         {
             base.LoadComplete();
 
-            api.LocalUser.BindValueChanged(_ =>
+            localUser.BindTo(api.LocalUser);
+            localUser.BindValueChanged(_ =>
             {
                 // queuing up requests directly on user change is unsafe, as the API status may have not been updated yet.
                 // schedule a frame to allow the API to be in its correct state sending requests.
diff --git a/osu.Game/Online/Metadata/OnlineMetadataClient.cs b/osu.Game/Online/Metadata/OnlineMetadataClient.cs
index 6637fc8dba..366ad70db2 100644
--- a/osu.Game/Online/Metadata/OnlineMetadataClient.cs
+++ b/osu.Game/Online/Metadata/OnlineMetadataClient.cs
@@ -12,6 +12,7 @@ using osu.Framework.Logging;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Users;
 
 namespace osu.Game.Online.Metadata
@@ -116,7 +117,7 @@ namespace osu.Game.Online.Metadata
             }
 
             if (IsWatchingUserPresence)
-                BeginWatchingUserPresenceInternal();
+                BeginWatchingUserPresenceInternal().FireAndForget();
 
             if (localUser.Value is not GuestUser)
             {
diff --git a/osu.Game/Online/OnlineStatusNotifier.cs b/osu.Game/Online/OnlineStatusNotifier.cs
index dda430ce6f..10d766c729 100644
--- a/osu.Game/Online/OnlineStatusNotifier.cs
+++ b/osu.Game/Online/OnlineStatusNotifier.cs
@@ -151,7 +151,7 @@ namespace osu.Game.Online
             base.Dispose(isDisposing);
 
             if (notificationsClient.IsNotNull())
-                notificationsClient.MessageReceived += notifyAboutForcedDisconnection;
+                notificationsClient.MessageReceived -= notifyAboutForcedDisconnection;
 
             if (spectatorClient.IsNotNull())
                 spectatorClient.Disconnecting -= notifyAboutForcedDisconnection;
diff --git a/osu.Game/Online/Rooms/MatchType.cs b/osu.Game/Online/Rooms/MatchType.cs
index 28f2da897a..ade28458e8 100644
--- a/osu.Game/Online/Rooms/MatchType.cs
+++ b/osu.Game/Online/Rooms/MatchType.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Online.Rooms
         [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesHeadToHead))]
         HeadToHead,
 
-        [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVs))]
+        [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVersus))]
         TeamVersus,
     }
 }
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 57ed6a5dbf..bf08023242 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -8,7 +8,6 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Humanizer;
@@ -113,6 +112,9 @@ namespace osu.Game
         /// </summary>
         public const float SCREEN_EDGE_MARGIN = 12f;
 
+        private const double general_log_debounce = 60000;
+        private const string tablet_log_prefix = @"[Tablet] ";
+
         public Toolbar Toolbar { get; private set; }
 
         private ChatOverlay chatOverlay;
@@ -241,12 +243,26 @@ namespace osu.Game
         /// </summary>
         public virtual bool HideUnlicensedContent => false;
 
+        private bool tabletLogNotifyOnWarning = true;
+        private bool tabletLogNotifyOnError = true;
+        private int generalLogRecentCount;
+
         public OsuGame(string[] args = null)
         {
             this.args = args;
 
-            forwardGeneralLogsToNotifications();
-            forwardTabletLogsToNotifications();
+            Logger.NewEntry += forwardGeneralLogToNotifications;
+            Logger.NewEntry += forwardTabletLogToNotifications;
+
+            Schedule(() =>
+            {
+                ITabletHandler tablet = Host.AvailableInputHandlers.OfType<ITabletHandler>().SingleOrDefault();
+                tablet?.Tablet.BindValueChanged(_ =>
+                {
+                    tabletLogNotifyOnWarning = true;
+                    tabletLogNotifyOnError = true;
+                }, true);
+            });
         }
 
         #region IOverlayManager
@@ -347,40 +363,42 @@ namespace osu.Game
             if (host.Window != null)
             {
                 host.Window.CursorState |= CursorState.Hidden;
-                host.Window.DragDrop += path =>
-                {
-                    // on macOS/iOS, URL associations are handled via SDL_DROPFILE events.
-                    if (path.StartsWith(OSU_PROTOCOL, StringComparison.Ordinal))
-                    {
-                        HandleLink(path);
-                        return;
-                    }
-
-                    lock (dragDropFiles)
-                    {
-                        dragDropFiles.Add(path);
-
-                        Logger.Log($@"Adding ""{Path.GetFileName(path)}"" for import");
-
-                        // File drag drop operations can potentially trigger hundreds or thousands of these calls on some platforms.
-                        // In order to avoid spawning multiple import tasks for a single drop operation, debounce a touch.
-                        dragDropImportSchedule?.Cancel();
-                        dragDropImportSchedule = Scheduler.AddDelayed(handlePendingDragDropImports, 100);
-                    }
-                };
+                host.Window.DragDrop += onWindowDragDrop;
             }
         }
 
-        private void handlePendingDragDropImports()
+        private void onWindowDragDrop(string path)
         {
+            // on macOS/iOS, URL associations are handled via SDL_DROPFILE events.
+            if (path.StartsWith(OSU_PROTOCOL, StringComparison.Ordinal))
+            {
+                HandleLink(path);
+                return;
+            }
+
             lock (dragDropFiles)
             {
-                Logger.Log($"Handling batch import of {dragDropFiles.Count} files");
+                dragDropFiles.Add(path);
 
-                string[] paths = dragDropFiles.ToArray();
-                dragDropFiles.Clear();
+                Logger.Log($@"Adding ""{Path.GetFileName(path)}"" for import");
 
-                Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);
+                // File drag drop operations can potentially trigger hundreds or thousands of these calls on some platforms.
+                // In order to avoid spawning multiple import tasks for a single drop operation, debounce a touch.
+                dragDropImportSchedule?.Cancel();
+                dragDropImportSchedule = Scheduler.AddDelayed(handlePendingDragDropImports, 100);
+            }
+
+            void handlePendingDragDropImports()
+            {
+                lock (dragDropFiles)
+                {
+                    Logger.Log($"Handling batch import of {dragDropFiles.Count} files");
+
+                    string[] paths = dragDropFiles.ToArray();
+                    dragDropFiles.Clear();
+
+                    Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);
+                }
             }
         }
 
@@ -1009,7 +1027,14 @@ namespace osu.Game
             detachedBeatmapStore?.Dispose();
 
             base.Dispose(isDisposing);
+
             SentryLogger.Dispose();
+
+            if (Host?.Window != null)
+                Host.Window.DragDrop -= onWindowDragDrop;
+
+            Logger.NewEntry -= forwardGeneralLogToNotifications;
+            Logger.NewEntry -= forwardTabletLogToNotifications;
         }
 
         protected override IDictionary<FrameworkSetting, object> GetFrameworkConfigDefaults()
@@ -1029,13 +1054,6 @@ namespace osu.Game
         {
             base.LoadComplete();
 
-            if (RuntimeInfo.EntryAssembly.GetCustomAttribute<OfficialBuildAttribute>() == null)
-                Logger.Log(NotificationsStrings.NotOfficialBuild.ToString());
-
-            // Make sure the release stream setting matches the build which was just run.
-            if (Enum.TryParse<ReleaseStream>(Version.Split('-').Last(), true, out var releaseStream))
-                LocalConfig.SetValue(OsuSetting.ReleaseStream, releaseStream);
-
             var languages = Enum.GetValues<Language>();
 
             var mappings = languages.Select(language =>
@@ -1365,115 +1383,90 @@ namespace osu.Game
                 overlay.Depth = (float)-Clock.CurrentTime;
         }
 
-        private void forwardGeneralLogsToNotifications()
+        private void forwardGeneralLogToNotifications(LogEntry entry)
         {
-            int recentLogCount = 0;
+            if (entry.Level < LogLevel.Important || entry.Target > LoggingTarget.Database || entry.Target == null) return;
 
-            const double debounce = 60000;
+            if (entry.Exception is SentryOnlyDiagnosticsException)
+                return;
 
-            Logger.NewEntry += entry =>
+            const int short_term_display_limit = 3;
+
+            if (generalLogRecentCount < short_term_display_limit)
             {
-                if (entry.Level < LogLevel.Important || entry.Target > LoggingTarget.Database || entry.Target == null) return;
-
-                if (entry.Exception is SentryOnlyDiagnosticsException)
-                    return;
-
-                const int short_term_display_limit = 3;
-
-                if (recentLogCount < short_term_display_limit)
+                Schedule(() => Notifications.Post(new SimpleErrorNotification
                 {
-                    Schedule(() => Notifications.Post(new SimpleErrorNotification
-                    {
-                        Icon = entry.Level == LogLevel.Important ? FontAwesome.Solid.ExclamationCircle : FontAwesome.Solid.Bomb,
-                        Text = entry.Message.Truncate(256) + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
-                    }));
-                }
-                else if (recentLogCount == short_term_display_limit)
+                    Icon = entry.Level == LogLevel.Important ? FontAwesome.Solid.ExclamationCircle : FontAwesome.Solid.Bomb,
+                    Text = entry.Message.Truncate(256) + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
+                }));
+            }
+            else if (generalLogRecentCount == short_term_display_limit)
+            {
+                string logFile = Logger.GetLogger(entry.Target.Value).Filename;
+
+                Schedule(() => Notifications.Post(new SimpleNotification
                 {
-                    string logFile = Logger.GetLogger(entry.Target.Value).Filename;
-
-                    Schedule(() => Notifications.Post(new SimpleNotification
+                    Icon = FontAwesome.Solid.EllipsisH,
+                    Text = NotificationsStrings.SubsequentMessagesLogged,
+                    Activated = () =>
                     {
-                        Icon = FontAwesome.Solid.EllipsisH,
-                        Text = NotificationsStrings.SubsequentMessagesLogged,
-                        Activated = () =>
-                        {
-                            Logger.Storage.PresentFileExternally(logFile);
-                            return true;
-                        }
-                    }));
-                }
+                        Logger.Storage.PresentFileExternally(logFile);
+                        return true;
+                    }
+                }));
+            }
 
-                Interlocked.Increment(ref recentLogCount);
-                Scheduler.AddDelayed(() => Interlocked.Decrement(ref recentLogCount), debounce);
-            };
+            Interlocked.Increment(ref generalLogRecentCount);
+            Scheduler.AddDelayed(() => Interlocked.Decrement(ref generalLogRecentCount), general_log_debounce);
         }
 
-        private void forwardTabletLogsToNotifications()
+        private void forwardTabletLogToNotifications(LogEntry entry)
         {
-            const string tablet_prefix = @"[Tablet] ";
+            if (entry.Level < LogLevel.Important || entry.Target != LoggingTarget.Input || !entry.Message.StartsWith(tablet_log_prefix, StringComparison.OrdinalIgnoreCase))
+                return;
 
-            bool notifyOnWarning = true;
-            bool notifyOnError = true;
+            string message = entry.Message.Replace(tablet_log_prefix, string.Empty);
 
-            Logger.NewEntry += entry =>
+            if (entry.Level == LogLevel.Error)
             {
-                if (entry.Level < LogLevel.Important || entry.Target != LoggingTarget.Input || !entry.Message.StartsWith(tablet_prefix, StringComparison.OrdinalIgnoreCase))
+                if (!tabletLogNotifyOnError)
                     return;
 
-                string message = entry.Message.Replace(tablet_prefix, string.Empty);
+                tabletLogNotifyOnError = false;
 
-                if (entry.Level == LogLevel.Error)
+                Schedule(() =>
                 {
-                    if (!notifyOnError)
-                        return;
-
-                    notifyOnError = false;
-
-                    Schedule(() =>
+                    Notifications.Post(new SimpleNotification
                     {
-                        Notifications.Post(new SimpleNotification
-                        {
-                            Text = NotificationsStrings.TabletSupportDisabledDueToError(message),
-                            Icon = FontAwesome.Solid.PenSquare,
-                            IconColour = Colours.RedDark,
-                        });
-
-                        // We only have one tablet handler currently.
-                        // The loop here is weakly guarding against a future where more than one is added.
-                        // If this is ever the case, this logic needs adjustment as it should probably only
-                        // disable the relevant tablet handler rather than all.
-                        foreach (var tabletHandler in Host.AvailableInputHandlers.OfType<ITabletHandler>())
-                            tabletHandler.Enabled.Value = false;
-                    });
-                }
-                else if (notifyOnWarning)
-                {
-                    Schedule(() => Notifications.Post(new SimpleNotification
-                    {
-                        Text = NotificationsStrings.EncounteredTabletWarning,
+                        Text = NotificationsStrings.TabletSupportDisabledDueToError(message),
                         Icon = FontAwesome.Solid.PenSquare,
-                        IconColour = Colours.YellowDark,
-                        Activated = () =>
-                        {
-                            OpenUrlExternally("https://opentabletdriver.net/Tablets", LinkWarnMode.NeverWarn);
-                            return true;
-                        }
-                    }));
+                        IconColour = Colours.RedDark,
+                    });
 
-                    notifyOnWarning = false;
-                }
-            };
-
-            Schedule(() =>
+                    // We only have one tablet handler currently.
+                    // The loop here is weakly guarding against a future where more than one is added.
+                    // If this is ever the case, this logic needs adjustment as it should probably only
+                    // disable the relevant tablet handler rather than all.
+                    foreach (var tabletHandler in Host.AvailableInputHandlers.OfType<ITabletHandler>())
+                        tabletHandler.Enabled.Value = false;
+                });
+            }
+            else if (tabletLogNotifyOnWarning)
             {
-                ITabletHandler tablet = Host.AvailableInputHandlers.OfType<ITabletHandler>().SingleOrDefault();
-                tablet?.Tablet.BindValueChanged(_ =>
+                Schedule(() => Notifications.Post(new SimpleNotification
                 {
-                    notifyOnWarning = true;
-                    notifyOnError = true;
-                }, true);
-            });
+                    Text = NotificationsStrings.EncounteredTabletWarning,
+                    Icon = FontAwesome.Solid.PenSquare,
+                    IconColour = Colours.YellowDark,
+                    Activated = () =>
+                    {
+                        OpenUrlExternally("https://opentabletdriver.net/Tablets", LinkWarnMode.NeverWarn);
+                        return true;
+                    }
+                }));
+
+                tabletLogNotifyOnWarning = false;
+            }
         }
 
         private Task asyncLoadStream;
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index c2da2ebb50..38646f4b98 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -504,9 +504,10 @@ namespace osu.Game
             AddFont(Resources, @"Fonts/Inter/Inter-BoldItalic");
 
             AddFont(Resources, @"Fonts/Noto/Noto-Basic");
-            AddFont(Resources, @"Fonts/Noto/Noto-Hangul");
+            AddFont(Resources, @"Fonts/Noto/Noto-Bopomofo");
             AddFont(Resources, @"Fonts/Noto/Noto-CJK-Basic");
             AddFont(Resources, @"Fonts/Noto/Noto-CJK-Compatibility");
+            AddFont(Resources, @"Fonts/Noto/Noto-Hangul");
             AddFont(Resources, @"Fonts/Noto/Noto-Thai");
 
             AddFont(Resources, @"Fonts/Venera/Venera-Light");
diff --git a/osu.Game/Overlays/Changelog/ChangelogBuild.cs b/osu.Game/Overlays/Changelog/ChangelogBuild.cs
index 08978ac2ab..fed38c1a1e 100644
--- a/osu.Game/Overlays/Changelog/ChangelogBuild.cs
+++ b/osu.Game/Overlays/Changelog/ChangelogBuild.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -18,7 +16,7 @@ namespace osu.Game.Overlays.Changelog
 {
     public partial class ChangelogBuild : FillFlowContainer
     {
-        public Action<APIChangelogBuild> SelectBuild;
+        public required Action<APIChangelogBuild> SelectBuild { get; init; }
 
         protected readonly APIChangelogBuild Build;
 
@@ -79,7 +77,7 @@ namespace osu.Game.Overlays.Changelog
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     AutoSizeAxes = Axes.Both,
-                    Action = () => SelectBuild?.Invoke(Build),
+                    Action = () => SelectBuild.Invoke(Build),
                     Child = new FillFlowContainer<SpriteText>
                     {
                         AutoSizeAxes = Axes.Both,
diff --git a/osu.Game/Overlays/Changelog/ChangelogSingleBuild.cs b/osu.Game/Overlays/Changelog/ChangelogSingleBuild.cs
index 13a19de22a..a9ee77ce5d 100644
--- a/osu.Game/Overlays/Changelog/ChangelogSingleBuild.cs
+++ b/osu.Game/Overlays/Changelog/ChangelogSingleBuild.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Threading;
 using osu.Framework.Allocation;
@@ -26,7 +24,7 @@ namespace osu.Game.Overlays.Changelog
 {
     public partial class ChangelogSingleBuild : ChangelogContent
     {
-        private APIChangelogBuild build;
+        private readonly APIChangelogBuild build;
 
         public ChangelogSingleBuild(APIChangelogBuild build)
         {
@@ -38,10 +36,12 @@ namespace osu.Game.Overlays.Changelog
         {
             bool complete = false;
 
+            APIChangelogBuild? onlineBuildDetails = null;
+
             var req = new GetChangelogBuildRequest(build.UpdateStream.Name, build.Version);
             req.Success += res =>
             {
-                build = res;
+                onlineBuildDetails = res;
                 complete = true;
             };
             req.Failure += _ => complete = true;
@@ -59,36 +59,35 @@ namespace osu.Game.Overlays.Changelog
                 Thread.Sleep(10);
             }
 
-            if (build != null)
+            if (onlineBuildDetails == null) return;
+
+            CommentsContainer comments;
+
+            Children = new Drawable[]
             {
-                CommentsContainer comments;
-
-                Children = new Drawable[]
+                new ChangelogBuildWithNavigation(onlineBuildDetails) { SelectBuild = SelectBuild },
+                new Box
                 {
-                    new ChangelogBuildWithNavigation(build) { SelectBuild = SelectBuild },
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = 2,
-                        Colour = colourProvider.Background6,
-                        Margin = new MarginPadding { Top = 30 },
-                    },
-                    new ChangelogSupporterPromo
-                    {
-                        Alpha = api.LocalUser.Value.IsSupporter ? 0 : 1,
-                    },
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = 2,
-                        Colour = colourProvider.Background6,
-                        Alpha = api.LocalUser.Value.IsSupporter ? 0 : 1,
-                    },
-                    comments = new CommentsContainer()
-                };
+                    RelativeSizeAxes = Axes.X,
+                    Height = 2,
+                    Colour = colourProvider.Background6,
+                    Margin = new MarginPadding { Top = 30 },
+                },
+                new ChangelogSupporterPromo
+                {
+                    Alpha = api.LocalUser.Value.IsSupporter ? 0 : 1,
+                },
+                new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 2,
+                    Colour = colourProvider.Background6,
+                    Alpha = api.LocalUser.Value.IsSupporter ? 0 : 1,
+                },
+                comments = new CommentsContainer()
+            };
 
-                comments.ShowComments(CommentableType.Build, build.Id);
-            }
+            comments.ShowComments(CommentableType.Build, onlineBuildDetails.Id);
         }
 
         public partial class ChangelogBuildWithNavigation : ChangelogBuild
@@ -98,7 +97,7 @@ namespace osu.Game.Overlays.Changelog
             {
             }
 
-            private OsuSpriteText date;
+            private OsuSpriteText date = null!;
 
             protected override FillFlowContainer CreateHeader()
             {
@@ -144,9 +143,9 @@ namespace osu.Game.Overlays.Changelog
 
         private partial class NavigationIconButton : IconButton
         {
-            public Action<APIChangelogBuild> SelectBuild;
+            public required Action<APIChangelogBuild> SelectBuild { get; init; }
 
-            public NavigationIconButton(APIChangelogBuild build)
+            public NavigationIconButton(APIChangelogBuild? build)
             {
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
diff --git a/osu.Game/Overlays/FirstRunSetup/ScreenBehaviour.cs b/osu.Game/Overlays/FirstRunSetup/ScreenBehaviour.cs
index a583ba5f6b..00a753f481 100644
--- a/osu.Game/Overlays/FirstRunSetup/ScreenBehaviour.cs
+++ b/osu.Game/Overlays/FirstRunSetup/ScreenBehaviour.cs
@@ -1,11 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
@@ -22,7 +19,7 @@ namespace osu.Game.Overlays.FirstRunSetup
     [LocalisableDescription(typeof(FirstRunSetupOverlayStrings), nameof(FirstRunSetupOverlayStrings.Behaviour))]
     public partial class ScreenBehaviour : WizardScreen
     {
-        private SearchContainer<SettingsSection> searchContainer;
+        private SearchContainer<SettingsSection> searchContainer = null!;
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
@@ -91,13 +88,11 @@ namespace osu.Game.Overlays.FirstRunSetup
                         new GraphicsSection(),
                         new OnlineSection(),
                         new MaintenanceSection(),
+                        new DebugSection()
                     },
                     SearchTerm = SettingsItem<bool>.CLASSIC_DEFAULT_SEARCH_TERM,
                 }
             };
-
-            if (DebugUtils.IsDebugBuild)
-                searchContainer.Add(new DebugSection());
         }
 
         private void applyClassic()
diff --git a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
index 10e3df17e5..14c02f5da7 100644
--- a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
+++ b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
@@ -180,7 +180,7 @@ namespace osu.Game.Overlays.Mods
                 mod.ApplyToDifficulty(adjustedDifficulty);
 
             Ruleset ruleset = GameRuleset.Value.CreateInstance();
-            adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(adjustedDifficulty, rate);
+            adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(adjustedDifficulty, Mods.Value);
 
             TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
 
diff --git a/osu.Game/Overlays/Settings/Sections/DebugSection.cs b/osu.Game/Overlays/Settings/Sections/DebugSection.cs
index 1d2129413c..969e65e823 100644
--- a/osu.Game/Overlays/Settings/Sections/DebugSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/DebugSection.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
@@ -20,12 +21,13 @@ namespace osu.Game.Overlays.Settings.Sections
 
         public DebugSection()
         {
-            Children = new Drawable[]
+            if (DebugUtils.IsDebugBuild)
             {
-                new GeneralSettings(),
-                new BatchImportSettings(),
-                new MemorySettings(),
-            };
+                Add(new GeneralSettings());
+                Add(new BatchImportSettings());
+            }
+
+            Add(new MemorySettings());
         }
     }
 }
diff --git a/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
index bd6ada4ca7..914fc9d141 100644
--- a/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 
 namespace osu.Game.Overlays.Settings.Sections.DebugSettings
@@ -15,19 +14,17 @@ namespace osu.Game.Overlays.Settings.Sections.DebugSettings
         [BackgroundDependencyLoader]
         private void load(FrameworkDebugConfigManager config, FrameworkConfigManager frameworkConfig)
         {
-            Children = new Drawable[]
+            Add(new SettingsCheckbox
             {
-                new SettingsCheckbox
-                {
-                    LabelText = @"Show log overlay",
-                    Current = frameworkConfig.GetBindable<bool>(FrameworkSetting.ShowLogOverlay)
-                },
-                new SettingsCheckbox
-                {
-                    LabelText = @"Bypass front-to-back render pass",
-                    Current = config.GetBindable<bool>(DebugSetting.BypassFrontToBackPass)
-                },
-            };
+                LabelText = @"Show log overlay",
+                Current = frameworkConfig.GetBindable<bool>(FrameworkSetting.ShowLogOverlay)
+            });
+
+            Add(new SettingsCheckbox
+            {
+                LabelText = @"Bypass front-to-back render pass",
+                Current = config.GetBindable<bool>(DebugSetting.BypassFrontToBackPass)
+            });
         }
     }
 }
diff --git a/osu.Game/Overlays/Settings/Sections/DebugSettings/MemorySettings.cs b/osu.Game/Overlays/Settings/Sections/DebugSettings/MemorySettings.cs
index b693822838..7b9b88a213 100644
--- a/osu.Game/Overlays/Settings/Sections/DebugSettings/MemorySettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/DebugSettings/MemorySettings.cs
@@ -2,9 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Runtime;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Development;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
@@ -24,73 +26,112 @@ namespace osu.Game.Overlays.Settings.Sections.DebugSettings
             SettingsButton blockAction;
             SettingsButton unblockAction;
 
-            Children = new Drawable[]
+            Add(new SettingsButton
             {
-                new SettingsButton
+                Text = @"Clear all caches",
+                Action = () =>
                 {
-                    Text = @"Clear all caches",
-                    Action = host.Collect
-                },
-                new SettingsButton
+                    host.Collect();
+
+                    // host.Collect() uses GCCollectionMode.Optimized, but we should be as aggressive as possible here.
+                    GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive, true, true);
+                }
+            });
+
+            SettingsEnumDropdown<GCLatencyMode> latencyModeDropdown;
+            Add(latencyModeDropdown = new SettingsEnumDropdown<GCLatencyMode>
+            {
+                LabelText = "GC mode",
+            });
+
+            latencyModeDropdown.Current.BindValueChanged(mode =>
+            {
+                Logger.Log($"Changing latency mode: {mode.NewValue}");
+
+                switch (mode.NewValue)
                 {
-                    Text = @"Compact realm",
-                    Action = () =>
+                    case GCLatencyMode.Default:
+                        // https://github.com/ppy/osu-framework/blob/1d5301018dfed1a28702be56e1d53c4835b199f2/osu.Framework/Platform/GameHost.cs#L703
+                        GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency;
+                        break;
+
+                    case GCLatencyMode.Interactive:
+                        GCSettings.LatencyMode = System.Runtime.GCLatencyMode.Interactive;
+                        break;
+                }
+            });
+
+            if (DebugUtils.IsDebugBuild)
+            {
+                AddRange(new Drawable[]
+                {
+                    new SettingsButton
                     {
-                        // Blocking operations implicitly causes a Compact().
-                        using (realm.BlockAllOperations(@"compact"))
+                        Text = @"Compact realm",
+                        Action = () =>
                         {
+                            // Blocking operations implicitly causes a Compact().
+                            using (realm.BlockAllOperations(@"compact"))
+                            {
+                            }
+                        }
+                    },
+                    blockAction = new SettingsButton
+                    {
+                        Text = @"Block realm",
+                    },
+                    unblockAction = new SettingsButton
+                    {
+                        Text = @"Unblock realm",
+                    }
+                });
+
+                blockAction.Action = () =>
+                {
+                    try
+                    {
+                        IDisposable? token = realm.BlockAllOperations(@"maintenance");
+
+                        blockAction.Enabled.Value = false;
+
+                        // As a safety measure, unblock after 10 seconds.
+                        // This is to handle the case where a dev may block, but then something on the update thread
+                        // accesses realm and blocks for eternity.
+                        Task.Factory.StartNew(() =>
+                        {
+                            Thread.Sleep(10000);
+                            unblock();
+                        });
+
+                        unblockAction.Action = unblock;
+
+                        void unblock()
+                        {
+                            if (token.IsNull())
+                                return;
+
+                            token.Dispose();
+                            token = null;
+
+                            Scheduler.Add(() =>
+                            {
+                                blockAction.Enabled.Value = true;
+                                unblockAction.Action = null;
+                            });
                         }
                     }
-                },
-                blockAction = new SettingsButton
-                {
-                    Text = @"Block realm",
-                },
-                unblockAction = new SettingsButton
-                {
-                    Text = @"Unblock realm",
-                },
-            };
-
-            blockAction.Action = () =>
-            {
-                try
-                {
-                    IDisposable? token = realm.BlockAllOperations(@"maintenance");
-
-                    blockAction.Enabled.Value = false;
-
-                    // As a safety measure, unblock after 10 seconds.
-                    // This is to handle the case where a dev may block, but then something on the update thread
-                    // accesses realm and blocks for eternity.
-                    Task.Factory.StartNew(() =>
+                    catch (Exception e)
                     {
-                        Thread.Sleep(10000);
-                        unblock();
-                    });
-
-                    unblockAction.Action = unblock;
-
-                    void unblock()
-                    {
-                        if (token.IsNull())
-                            return;
-
-                        token.Dispose();
-                        token = null;
-
-                        Scheduler.Add(() =>
-                        {
-                            blockAction.Enabled.Value = true;
-                            unblockAction.Action = null;
-                        });
+                        Logger.Error(e, @"Blocking realm failed");
                     }
-                }
-                catch (Exception e)
-                {
-                    Logger.Error(e, @"Blocking realm failed");
-                }
-            };
+                };
+            }
+        }
+
+        private enum GCLatencyMode
+        {
+            Default,
+            Interactive,
         }
     }
 }
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index 9800fa10f6..0744808c46 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -313,11 +313,11 @@ namespace osu.Game.Overlays.Settings.Sections
                 base.PopIn();
             }
 
-            private void rename() => skins.CurrentSkinInfo.Value.PerformWrite(skin =>
+            private void rename()
             {
-                skin.Name = textBox.Text;
+                skins.Rename(skins.CurrentSkinInfo.Value, textBox.Text);
                 PopOut();
-            });
+            }
         }
     }
 }
diff --git a/osu.Game/Overlays/SettingsOverlay.cs b/osu.Game/Overlays/SettingsOverlay.cs
index a498f2fe1f..3065a4d1bd 100644
--- a/osu.Game/Overlays/SettingsOverlay.cs
+++ b/osu.Game/Overlays/SettingsOverlay.cs
@@ -7,7 +7,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -31,7 +30,7 @@ namespace osu.Game.Overlays
 
         protected override IEnumerable<SettingsSection> CreateSections()
         {
-            var sections = new List<SettingsSection>
+            return new List<SettingsSection>
             {
                 // This list should be kept in sync with ScreenBehaviour.
                 new GeneralSection(),
@@ -44,12 +43,8 @@ namespace osu.Game.Overlays
                 new GraphicsSection(),
                 new OnlineSection(),
                 new MaintenanceSection(),
+                new DebugSection()
             };
-
-            if (DebugUtils.IsDebugBuild)
-                sections.Add(new DebugSection());
-
-            return sections;
         }
 
         private readonly List<SettingsSubPanel> subPanels = new List<SettingsSubPanel>();
diff --git a/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs b/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs
index e4ac157936..4d91b4ebfd 100644
--- a/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs
+++ b/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs
@@ -8,6 +8,7 @@ using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -47,6 +48,7 @@ namespace osu.Game.Overlays.SkinEditor
 
         private ExternalEditOperation<SkinInfo>? editOperation;
         private TaskCompletionSource? taskCompletionSource;
+        private bool finishingEdit;
 
         protected override bool DimMainContent => false;
 
@@ -95,6 +97,8 @@ namespace osu.Game.Overlays.SkinEditor
                     }
                 }
             };
+
+            gameHost.ExitRequested += tryFinishOnExit;
         }
 
         public async Task<Task> Begin(SkinInfo skinInfo)
@@ -179,8 +183,19 @@ namespace osu.Game.Overlays.SkinEditor
             gameHost.OpenFileExternally(editOperation.MountedPath.TrimDirectorySeparator() + Path.DirectorySeparatorChar);
         }
 
+        private void tryFinishOnExit()
+        {
+            if (editOperation != null && !finishingEdit)
+                finish().FireAndForget(onSuccess: () => Schedule(() => finishingEdit = false));
+        }
+
         private async Task finish()
         {
+            if (finishingEdit)
+                return;
+
+            finishingEdit = true;
+
             Debug.Assert(taskCompletionSource != null);
 
             showSpinner("Cleaning up...");
@@ -236,6 +251,7 @@ namespace osu.Game.Overlays.SkinEditor
             {
                 // Set everything to a clean state
                 editOperation = null;
+                finishingEdit = false;
                 flow.Children = Array.Empty<Drawable>();
             });
         }
@@ -249,7 +265,8 @@ namespace osu.Game.Overlays.SkinEditor
             {
                 case GlobalAction.Back:
                 case GlobalAction.Select:
-                    if (editOperation == null) return base.OnPressed(e);
+                    if (editOperation == null)
+                        return false;
 
                     finish().FireAndForget();
                     return true;
@@ -280,5 +297,13 @@ namespace osu.Game.Overlays.SkinEditor
                 },
             };
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (gameHost.IsNotNull())
+                gameHost.ExitRequested -= tryFinishOnExit;
+
+            base.Dispose(isDisposing);
+        }
     }
 }
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs b/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
index 5e71b6922c..27317518a0 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
@@ -249,7 +249,8 @@ namespace osu.Game.Overlays.SkinEditor
                 Scheduler.AddOnce(updateScreenSizing);
 
                 game.Toolbar.Hide();
-                game.CloseAllOverlays();
+                if (externalEditOverlay.State.Value != Visibility.Visible)
+                    game.CloseAllOverlays();
             }
             else
             {
@@ -298,7 +299,8 @@ namespace osu.Game.Overlays.SkinEditor
 
             if (skinEditor.State.Value == Visibility.Visible)
             {
-                skinEditor.Save(false);
+                if (externalEditOverlay.State.Value != Visibility.Visible)
+                    skinEditor.Save(false);
                 skinEditor.UpdateTargetScreen(target);
                 disableNestedInputManagers();
             }
diff --git a/osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs b/osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs
index a979575a0b..0e2fa6688d 100644
--- a/osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs
+++ b/osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs
@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
+using osu.Framework.IO.Stores;
 using osu.Game.Rulesets;
 using osuTK;
 using osuTK.Graphics;
@@ -32,6 +33,8 @@ namespace osu.Game.Overlays.Toolbar
         private readonly Dictionary<RulesetInfo, SampleChannel> rulesetSelectionChannel = new Dictionary<RulesetInfo, SampleChannel>();
         private Sample defaultSelectSample;
 
+        private ISampleStore samples;
+
         public ToolbarRulesetSelector()
         {
             RelativeSizeAxes = Axes.Y;
@@ -39,7 +42,7 @@ namespace osu.Game.Overlays.Toolbar
         }
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load(AudioManager audio, OsuGameBase game)
         {
             AddRangeInternal(new[]
             {
@@ -66,8 +69,15 @@ namespace osu.Game.Overlays.Toolbar
                 },
             });
 
+            var store = new ResourceStore<byte[]>(game.Resources);
+            samples = audio.GetSampleStore(new NamespacedResourceStore<byte[]>(store, "Samples"), audio.SampleMixer);
+
             foreach (var r in Rulesets.AvailableRulesets)
-                rulesetSelectionSample[r] = audio.Samples.Get($@"UI/ruleset-select-{r.ShortName}");
+            {
+                store.AddStore(r.CreateInstance().CreateResourceStore());
+
+                rulesetSelectionSample[r] = samples.Get($@"UI/ruleset-select-{r.ShortName}");
+            }
 
             defaultSelectSample = audio.Samples.Get(@"UI/default-select");
 
@@ -159,5 +169,12 @@ namespace osu.Game.Overlays.Toolbar
 
             return false;
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            samples?.Dispose();
+
+            base.Dispose(isDisposing);
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs b/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs
index 440d4e8e62..8c0c01d5da 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using ManagedBass;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Edit.Checks
@@ -9,8 +10,9 @@ namespace osu.Game.Rulesets.Edit.Checks
     public class CheckAudioQuality : ICheck
     {
         // This is a requirement as stated in the Ranking Criteria.
-        // See https://osu.ppy.sh/wiki/en/Ranking_Criteria#rules.4
-        private const int max_bitrate = 192;
+        // See https://osu.ppy.sh/wiki/en/Ranking_criteria#audio
+        private const int max_bitrate_default = 192;
+        private const int max_bitrate_ogg = 208;
 
         // "A song's audio file /.../ must be of reasonable quality. Try to find the highest quality source file available"
         // There not existing a version with a bitrate of 128 kbps or higher is extremely rare.
@@ -35,10 +37,17 @@ namespace osu.Game.Rulesets.Edit.Checks
 
             if (track?.Bitrate == null || track.Bitrate.Value == 0)
                 yield return new IssueTemplateNoBitrate(this).Create();
-            else if (track.Bitrate.Value > max_bitrate)
-                yield return new IssueTemplateTooHighBitrate(this).Create(track.Bitrate.Value);
-            else if (track.Bitrate.Value < min_bitrate)
-                yield return new IssueTemplateTooLowBitrate(this).Create(track.Bitrate.Value);
+            else
+            {
+                // Determine max bitrate based on audio format
+                var audioFormat = AudioCheckUtils.GetAudioFormatFromFile(context, audioFile);
+                int upperBitrateLimit = audioFormat.HasFlag(ChannelType.OGG) ? max_bitrate_ogg : max_bitrate_default;
+
+                if (track.Bitrate.Value > upperBitrateLimit)
+                    yield return new IssueTemplateTooHighBitrate(this).Create(track.Bitrate.Value, upperBitrateLimit);
+                else if (track.Bitrate.Value < min_bitrate)
+                    yield return new IssueTemplateTooLowBitrate(this).Create(track.Bitrate.Value);
+            }
         }
 
         public class IssueTemplateTooHighBitrate : IssueTemplate
@@ -48,7 +57,7 @@ namespace osu.Game.Rulesets.Edit.Checks
             {
             }
 
-            public Issue Create(int bitrate) => new Issue(this, bitrate, max_bitrate);
+            public Issue Create(int bitrate, int maxBitrate) => new Issue(this, bitrate, maxBitrate);
         }
 
         public class IssueTemplateTooLowBitrate : IssueTemplate
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs b/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
index dd01fe110a..592d61852f 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
@@ -2,12 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using ManagedBass;
-using osu.Framework.Audio.Callbacks;
 using osu.Game.Beatmaps;
-using osu.Game.Extensions;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Edit.Checks
@@ -36,28 +33,18 @@ namespace osu.Game.Rulesets.Edit.Checks
             if (beatmapSet == null) yield break;
             if (audioFile == null) yield break;
 
-            using (Stream data = context.WorkingBeatmap.GetStream(audioFile.File.GetStoragePath()))
+            var audioFormat = AudioCheckUtils.GetAudioFormatFromFile(context, context.Beatmap.Metadata.AudioFile);
+
+            // If the format is not supported by BASS
+            if (audioFormat == 0)
             {
-                if (data == null || data.Length <= 0) yield break;
+                yield return new IssueTemplateFormatUnsupported(this).Create(audioFile.Filename);
 
-                var fileCallbacks = new FileCallbacks(new DataStreamFileProcedures(data));
-                int decodeStream = Bass.CreateStream(StreamSystem.NoBuffer, BassFlags.Decode, fileCallbacks.Callbacks, fileCallbacks.Handle);
-
-                // If the format is not supported by BASS
-                if (decodeStream == 0)
-                {
-                    yield return new IssueTemplateFormatUnsupported(this).Create(audioFile.Filename);
-
-                    yield break;
-                }
-
-                var audioInfo = Bass.ChannelGetInfo(decodeStream);
-
-                if (!allowedFormats.Contains(audioInfo.ChannelType))
-                    yield return new IssueTemplateIncorrectFormat(this).Create(audioFile.Filename);
-
-                Bass.StreamFree(decodeStream);
+                yield break;
             }
+
+            if (!allowedFormats.Contains(audioFormat))
+                yield return new IssueTemplateIncorrectFormat(this).Create(audioFile.Filename);
         }
 
         public class IssueTemplateFormatUnsupported : IssueTemplate
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs b/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs
index 8a35b84170..c72e0288c2 100644
--- a/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs
+++ b/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs
@@ -3,6 +3,10 @@
 
 using System.IO;
 using System.Linq;
+using ManagedBass;
+using osu.Framework.Audio.Callbacks;
+using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Edit.Checks.Components
@@ -10,5 +14,46 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
     public static class AudioCheckUtils
     {
         public static bool HasAudioExtension(string filename) => SupportedExtensions.AUDIO_EXTENSIONS.Contains(Path.GetExtension(filename).ToLowerInvariant());
+
+        /// <summary>
+        /// Gets the audio format (ChannelType) from a stream using BASS.
+        /// </summary>
+        /// <param name="data">The audio file stream.</param>
+        /// <returns>The ChannelType of the audio, or <see cref="ChannelType.Unknown"/> if detection fails.</returns>
+        public static ChannelType GetAudioFormat(Stream data)
+        {
+            if (data.Length <= 0)
+                return ChannelType.Unknown;
+
+            using (var fileCallbacks = new FileCallbacks(new DataStreamFileProcedures(data)))
+            {
+                int decodeStream = Bass.CreateStream(StreamSystem.NoBuffer, BassFlags.Decode, fileCallbacks.Callbacks, fileCallbacks.Handle);
+                if (decodeStream == 0)
+                    return ChannelType.Unknown;
+
+                var audioInfo = Bass.ChannelGetInfo(decodeStream);
+                Bass.StreamFree(decodeStream);
+
+                return audioInfo.ChannelType;
+            }
+        }
+
+        /// <summary>
+        /// Gets the audio format for a specific file in a beatmapset.
+        /// </summary>
+        /// <param name="context">The beatmap verifier context.</param>
+        /// <param name="filename">The filename to check.</param>
+        /// <returns>The ChannelType of the audio file, or <see cref="ChannelType.Unknown"/> if detection fails.</returns>
+        public static ChannelType GetAudioFormatFromFile(BeatmapVerifierContext context, string filename)
+        {
+            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var audioFile = beatmapSet?.GetFile(filename);
+
+            if (beatmapSet == null || audioFile == null)
+                return ChannelType.Unknown;
+
+            using (Stream data = context.WorkingBeatmap.GetStream(audioFile.File.GetStoragePath()))
+                return GetAudioFormat(data);
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModEasy.cs b/osu.Game/Rulesets/Mods/ModEasy.cs
index 3ee4d7846e..0ee384c0f7 100644
--- a/osu.Game/Rulesets/Mods/ModEasy.cs
+++ b/osu.Game/Rulesets/Mods/ModEasy.cs
@@ -19,13 +19,13 @@ namespace osu.Game.Rulesets.Mods
         public override bool Ranked => UsesDefaultConfiguration;
         public override bool ValidForFreestyleAsRequiredMod => true;
 
+        protected const float ADJUST_RATIO = 0.5f;
+
         public virtual void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
-            const float ratio = 0.5f;
-            difficulty.CircleSize *= ratio;
-            difficulty.ApproachRate *= ratio;
-            difficulty.DrainRate *= ratio;
-            difficulty.OverallDifficulty *= ratio;
+            difficulty.CircleSize *= ADJUST_RATIO;
+            difficulty.ApproachRate *= ADJUST_RATIO;
+            difficulty.DrainRate *= ADJUST_RATIO;
         }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModHardRock.cs b/osu.Game/Rulesets/Mods/ModHardRock.cs
index 6149a9c712..713bfe0623 100644
--- a/osu.Game/Rulesets/Mods/ModHardRock.cs
+++ b/osu.Game/Rulesets/Mods/ModHardRock.cs
@@ -25,7 +25,6 @@ namespace osu.Game.Rulesets.Mods
         public virtual void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             difficulty.DrainRate = Math.Min(difficulty.DrainRate * ADJUST_RATIO, 10.0f);
-            difficulty.OverallDifficulty = Math.Min(difficulty.OverallDifficulty * ADJUST_RATIO, 10.0f);
         }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModScoreV2.cs b/osu.Game/Rulesets/Mods/ModScoreV2.cs
index 6a77cafa30..854f3916a1 100644
--- a/osu.Game/Rulesets/Mods/ModScoreV2.cs
+++ b/osu.Game/Rulesets/Mods/ModScoreV2.cs
@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Mods
     /// This mod is used strictly to mark osu!stable scores set with the "Score V2" mod active.
     /// It should not be used in any real capacity going forward.
     /// </remarks>
-    public sealed class ModScoreV2 : Mod
+    public class ModScoreV2 : Mod
     {
         public override string Name => "Score V2";
         public override string Acronym => @"SV2";
diff --git a/osu.Game/Rulesets/Ruleset.cs b/osu.Game/Rulesets/Ruleset.cs
index bd1f273b49..da3f628137 100644
--- a/osu.Game/Rulesets/Ruleset.cs
+++ b/osu.Game/Rulesets/Ruleset.cs
@@ -380,15 +380,15 @@ namespace osu.Game.Rulesets
         public virtual LocalisableString GetDisplayNameForHitResult(HitResult result) => result.GetLocalisableDescription();
 
         /// <summary>
-        /// Applies changes to difficulty attributes for presenting to a user a rough estimate of how rate adjust mods affect difficulty.
+        /// Applies changes to difficulty attributes for presenting to a user a rough estimate of how mods affect difficulty.
         /// Importantly, this should NOT BE USED FOR ANY CALCULATIONS.
         ///
         /// It is also not always correct, and arguably is never correct depending on your frame of mind.
         /// </summary>
         /// <param name="difficulty">>The <see cref="IBeatmapDifficultyInfo"/> that will be adjusted.</param>
-        /// <param name="rate">The rate adjustment multiplier from mods. For example 1.5 for DT.</param>
+        /// <param name="mods">The active mods.</param>
         /// <returns>The adjusted difficulty attributes.</returns>
-        public virtual BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate) => new BeatmapDifficulty(difficulty);
+        public virtual BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, IReadOnlyCollection<Mod> mods) => new BeatmapDifficulty(difficulty);
 
         /// <summary>
         /// Creates ruleset-specific beatmap filter criteria to be used on the song select screen.
diff --git a/osu.Game/Screens/Edit/BindableBeatDivisor.cs b/osu.Game/Screens/Edit/BindableBeatDivisor.cs
index bd9c9bab9a..53a1441a81 100644
--- a/osu.Game/Screens/Edit/BindableBeatDivisor.cs
+++ b/osu.Game/Screens/Edit/BindableBeatDivisor.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Screens.Edit
 {
     public class BindableBeatDivisor : BindableInt
     {
-        public static readonly int[] PREDEFINED_DIVISORS = { 1, 2, 3, 4, 6, 8, 12, 16 };
+        public static readonly int[] PREDEFINED_DIVISORS = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 16 };
 
         public const int MINIMUM_DIVISOR = 1;
         public const int MAXIMUM_DIVISOR = 64;
diff --git a/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs b/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
index 389ba2470a..8af4e3fe52 100644
--- a/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
+++ b/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
@@ -149,6 +149,8 @@ namespace osu.Game.Screens.Edit.Submission
             progress.BindValueChanged(_ => Scheduler.AddOnce(updateProgress), true);
 
             progressSampleChannel = progressSample?.GetChannel();
+            if (progressSampleChannel != null)
+                progressSampleChannel.ManualFree = true;
         }
 
         public void SetNotStarted() => status.Value = StageStatusType.NotStarted;
@@ -181,6 +183,7 @@ namespace osu.Game.Screens.Edit.Submission
             base.Dispose(isDisposing);
 
             progressSampleChannel?.Stop();
+            progressSampleChannel?.Dispose();
         }
 
         private const float transition_duration = 200;
diff --git a/osu.Game/Screens/EzColumnTab.cs b/osu.Game/Screens/EzColumnTab.cs
index d0bc1351bc..af0bc1ddcf 100644
--- a/osu.Game/Screens/EzColumnTab.cs
+++ b/osu.Game/Screens/EzColumnTab.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -12,7 +13,6 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays.Settings;
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.LAsEzExtensions;
-using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
@@ -20,41 +20,86 @@ namespace osu.Game.Screens
 {
     public partial class EzColumnTab : EditorSidebarSection
     {
-        private readonly List<int> availableKeyModes = new List<int> { 0, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18 };
+        private static readonly List<int> available_key_modes = new List<int> { 0, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18 };
+
+        private readonly Dictionary<int, List<EzSelectorColour>> columnSelectorCache = new Dictionary<int, List<EzSelectorColour>>();
+        private readonly Dictionary<EzSkinSetting, BindableColour4> colorBindables = new Dictionary<EzSkinSetting, BindableColour4>();
+
         private FillFlowContainer columnsContainer = null!;
-        private Bindable<int> keyModeSelection = new Bindable<int>();
-        private Bindable<bool> colorSettingsEnabled = new BindableBool(true);
-        private BindableColour4 aColorValue = new BindableColour4();
-        private BindableColour4 bColorValue = new BindableColour4();
-        private BindableColour4 s1ColorValue = new BindableColour4();
-        private BindableColour4 s2ColorValue = new BindableColour4();
+        private FillFlowContainer baseColorsContainer = null!;
+
+        private Bindable<int> keyModeSelection = null!;
+        private Bindable<bool> colorSettingsEnabled = null!;
 
         [Resolved]
         private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
 
-        [Resolved]
-        private SkinManager skinManager { get; set; } = null!;
-
         [Resolved]
         private Bindable<WorkingBeatmap> beatmap { get; set; } = null!;
 
         public EzColumnTab()
-            : base("EZ Column Settings")
-        {
-        }
+            : base("EZ Column Settings") { }
 
         [BackgroundDependencyLoader]
         private void load()
         {
             keyModeSelection = ezSkinConfig.GetBindable<int>(EzSkinSetting.SelectedKeyMode);
             colorSettingsEnabled = ezSkinConfig.GetBindable<bool>(EzSkinSetting.ColorSettingsEnabled);
-            // 设置双向绑定
-            aColorValue = createColorBindable(EzSkinSetting.ColumnTypeA);
-            bColorValue = createColorBindable(EzSkinSetting.ColumnTypeB);
-            s1ColorValue = createColorBindable(EzSkinSetting.ColumnTypeS1);
-            s2ColorValue = createColorBindable(EzSkinSetting.ColumnTypeS2);
 
-            var baseColorsContainer = new FillFlowContainer
+            colorBindables[EzSkinSetting.ColumnTypeA] = createColorBindable(EzSkinSetting.ColumnTypeA);
+            colorBindables[EzSkinSetting.ColumnTypeB] = createColorBindable(EzSkinSetting.ColumnTypeB);
+            colorBindables[EzSkinSetting.ColumnTypeS] = createColorBindable(EzSkinSetting.ColumnTypeS);
+            colorBindables[EzSkinSetting.ColumnTypeE] = createColorBindable(EzSkinSetting.ColumnTypeE);
+            colorBindables[EzSkinSetting.ColumnTypeP] = createColorBindable(EzSkinSetting.ColumnTypeP);
+            createUI();
+            updateKeyModeFromCurrentBeatmap();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            setupEventHandlers();
+            updateColumnsType(keyModeSelection.Value);
+        }
+
+        private void createUI()
+        {
+            baseColorsContainer = createBaseColorsContainer();
+
+            Children = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(2),
+                    Children = new Drawable[]
+                    {
+                        createColorSettingsCheckbox(),
+                        baseColorsContainer,
+                        createKeyModeSection(),
+                        createSaveButton()
+                    }
+                }
+            };
+        }
+
+        private SettingsCheckbox createColorSettingsCheckbox()
+        {
+            return new SettingsCheckbox
+            {
+                LabelText = "Color Enable\n(着色设置)",
+                TooltipText = "仅支持EZ Style Pro皮肤. Only supports EZ Style Pro skin\n" +
+                              "切换tab栏或保存后, 将重置默认颜色为当前设置\n" +
+                              "Switching tabs or saving will reset the colors to the default values",
+                Current = colorSettingsEnabled,
+            };
+        }
+
+        private FillFlowContainer createBaseColorsContainer()
+        {
+            return new FillFlowContainer
             {
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y,
@@ -67,119 +112,72 @@ namespace osu.Game.Screens
                         Margin = new MarginPadding { Bottom = 5 },
                         Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 14)
                     }.WithUnderline(),
-                    SettingsColourExtensions.CreateStyledSettingsColour("A", aColorValue),
-                    SettingsColourExtensions.CreateStyledSettingsColour("B", bColorValue),
-                    SettingsColourExtensions.CreateStyledSettingsColour("S1", s1ColorValue),
-                    SettingsColourExtensions.CreateStyledSettingsColour("S2", s2ColorValue),
+                    SettingsColourExtensions.CreateStyledSettingsColour(EzConstants.COLUMN_TYPE_A, colorBindables[EzSkinSetting.ColumnTypeA]),
+                    SettingsColourExtensions.CreateStyledSettingsColour(EzConstants.COLUMN_TYPE_B, colorBindables[EzSkinSetting.ColumnTypeB]),
+                    SettingsColourExtensions.CreateStyledSettingsColour(EzConstants.COLUMN_TYPE_S, colorBindables[EzSkinSetting.ColumnTypeS]),
+                    SettingsColourExtensions.CreateStyledSettingsColour(EzConstants.COLUMN_TYPE_E, colorBindables[EzSkinSetting.ColumnTypeE]),
+                    SettingsColourExtensions.CreateStyledSettingsColour(EzConstants.COLUMN_TYPE_P, colorBindables[EzSkinSetting.ColumnTypeP]),
                 }
             };
+        }
 
-            Children = new Drawable[]
+        private FillFlowContainer createKeyModeSection()
+        {
+            return new FillFlowContainer
             {
-                new FillFlowContainer
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Margin = new MarginPadding(5f),
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(2),
-                    Children = new Drawable[]
+                    new OsuSpriteText
                     {
-                        new SettingsCheckbox
-                        {
-                            LabelText = "Color Enable\n(着色设置)",
-                            TooltipText = "仅支持EZ Style Pro皮肤. Only supports EZ Style Pro skin\n"
-                                          + "切换tab栏或保存后, 将重置默认颜色为当前设置\n" +
-                                          "Switching tabs or saving will reset the colors to the default values",
-                            // Scale = new Vector2(0.9f),
-                            Current = colorSettingsEnabled,
-                        },
-                        // 基础颜色选择器
-                        baseColorsContainer,
-                        new FillFlowContainer
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Direction = FillDirection.Vertical,
-                            Margin = new MarginPadding(5f),
-                            Children = new Drawable[]
-                            {
-                                new OsuSpriteText
-                                {
-                                    Text = "Key Mode (键位数)",
-                                    Margin = new MarginPadding { Bottom = 5 },
-                                    Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 14),
-                                }.WithUnderline(),
-                                new SettingsDropdown<int>
-                                {
-                                    Current = keyModeSelection,
-                                    Items = availableKeyModes
-                                },
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    Height = 2,
-                                    Colour = Color4.DarkGray.Opacity(0.5f),
-                                },
-                                // 列颜色设置容器
-                                columnsContainer = new FillFlowContainer
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    AutoSizeAxes = Axes.Y,
-                                    Direction = FillDirection.Vertical,
-                                    Spacing = new Vector2(2)
-                                },
-                            }
-                        },
-                        new SettingsButton
-                        {
-                            Action = () =>
-                            {
-                                ezSkinConfig.Save();
-                                skinManager.CurrentSkinInfo.TriggerChange();
-                            },
-                        }.WithTwoLineText("(保存颜色设置)", "Save Color Settings")
-                    }
+                        Text = "Key Mode (键位数)",
+                        Margin = new MarginPadding { Bottom = 5 },
+                        Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 14),
+                    }.WithUnderline(),
+                    new SettingsDropdown<int>
+                    {
+                        Current = keyModeSelection,
+                        Items = available_key_modes
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Height = 2,
+                        Colour = Color4.DarkGray.Opacity(0.5f),
+                    },
+                    columnsContainer = new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(2)
+                    },
                 }
             };
-            updateKeyModeFromCurrentBeatmap();
-
-            colorSettingsEnabled.BindValueChanged(e =>
-            {
-                ezSkinConfig.SetValue(EzSkinSetting.ColorSettingsEnabled, e.NewValue);
-                ezSkinConfig.Save();
-                skinManager.Save(skinManager.CurrentSkin.Value);
-                baseColorsContainer.Alpha = e.NewValue ? 1f : 0f;
-            }, true);
         }
 
-        private void updateKeyModeFromCurrentBeatmap()
+        private SettingsButton createSaveButton()
         {
-            if (beatmap.Value?.Beatmap == null)
-                return;
-
-            int currentKeyCount = 0;
-
-            if (beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3)
+            return new SettingsButton
             {
-                currentKeyCount = (int)beatmap.Value.Beatmap.Difficulty.CircleSize;
-            }
-
-            // 如果无法获取键位数或键位数不在可用列表中，则不更改
-            if (currentKeyCount > 0 && availableKeyModes.Contains(currentKeyCount))
-                keyModeSelection.Value = currentKeyCount;
+                Action = () => ezSkinConfig.Save(),
+            }.WithTwoLineText("(保存颜色设置)", "Save Color Settings");
         }
 
-        protected override void LoadComplete()
+        private void setupEventHandlers()
         {
-            base.LoadComplete();
+            colorSettingsEnabled.BindValueChanged(onColorSettingsEnabledChanged, true);
+            keyModeSelection.BindValueChanged(e => updateColumnsType(e.NewValue));
 
-            aColorValue.ValueChanged += e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeA, "A");
-            bColorValue.ValueChanged += e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeB, "B");
-            s1ColorValue.ValueChanged += e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeS1, "S1");
-            s2ColorValue.ValueChanged += e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeS2, "S2");
-            keyModeSelection.ValueChanged += e => updateColumnsType(e.NewValue);
-
-            updateColumnsType(keyModeSelection.Value);
+            // 设置颜色变化事件
+            colorBindables[EzSkinSetting.ColumnTypeA].BindValueChanged(e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeA, EzConstants.COLUMN_TYPE_A));
+            colorBindables[EzSkinSetting.ColumnTypeB].BindValueChanged(e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeB, EzConstants.COLUMN_TYPE_B));
+            colorBindables[EzSkinSetting.ColumnTypeS].BindValueChanged(e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeS, EzConstants.COLUMN_TYPE_S));
+            colorBindables[EzSkinSetting.ColumnTypeE].BindValueChanged(e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeE, EzConstants.COLUMN_TYPE_E));
+            colorBindables[EzSkinSetting.ColumnTypeP].BindValueChanged(e => updateBaseColour(e.NewValue, EzSkinSetting.ColumnTypeP, EzConstants.COLUMN_TYPE_P));
         }
 
         private BindableColour4 createColorBindable(EzSkinSetting setting)
@@ -193,39 +191,52 @@ namespace osu.Game.Screens
             return result;
         }
 
-        private void updateBaseColour(Colour4 newColor, EzSkinSetting setting, string colorType)
+        private void onColorSettingsEnabledChanged(ValueChangedEvent<bool> e)
         {
+            baseColorsContainer.Alpha = e.NewValue ? 1f : 0f;
+        }
+
+        private void updateBaseColour(Colour4 newColor, EzSkinSetting setting, string type)
+        {
+            if (!colorSettingsEnabled.Value)
+                return;
+
             ezSkinConfig.SetValue(setting, newColor);
 
-            foreach (int keyMode in availableKeyModes)
-            {
-                for (int columnIndex = 0; columnIndex < keyMode; columnIndex++)
-                {
-                    string currentType = ezSkinConfig.GetColumnType(keyMode, columnIndex);
-
-                    if (currentType == colorType)
-                    {
-                        ezSkinConfig.SetColumnType(keyMode, columnIndex, colorType);
-                    }
-                }
-            }
-
             foreach (var selector in columnsContainer.ChildrenOfType<EzSelectorColour>())
             {
-                selector.SetColorMapping(colorType, newColor);
+                selector.SetColorMapping(type, newColor);
             }
-
-            ezSkinConfig.Save();
-            Invalidate();
         }
 
-        #region 创建选择器
+        private void updateKeyModeFromCurrentBeatmap()
+        {
+            if (beatmap.Value?.Beatmap == null)
+                return;
+
+            if (beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3)
+            {
+                int currentKeyCount = (int)beatmap.Value.Beatmap.Difficulty.CircleSize;
+
+                if (currentKeyCount > 0 && available_key_modes.Contains(currentKeyCount))
+                {
+                    keyModeSelection.Value = currentKeyCount;
+                }
+            }
+        }
 
         private void updateColumnsType(int keyMode)
         {
+            if (columnSelectorCache.TryGetValue(keyMode, out var cachedSelectors))
+            {
+                columnsContainer.Clear();
+                columnsContainer.AddRange(cachedSelectors);
+                return;
+            }
+
             columnsContainer.Clear();
 
-            if (keyMode == 0 || !availableKeyModes.Contains(keyMode))
+            if (keyMode == 0 || !available_key_modes.Contains(keyMode))
             {
                 columnsContainer.Add(new OsuSpriteText
                 {
@@ -236,6 +247,11 @@ namespace osu.Game.Screens
                 return;
             }
 
+            createColumnSelectors(keyMode);
+        }
+
+        private void createColumnSelectors(int keyMode)
+        {
             columnsContainer.Add(new OsuSpriteText
             {
                 Text = $"{keyMode}K ColumnType 列类型",
@@ -243,47 +259,51 @@ namespace osu.Game.Screens
                 Margin = new MarginPadding { Bottom = 5 },
             }.WithUnderline());
 
-            var colorMapping = new Dictionary<string, Color4>
-            {
-                ["A"] = aColorValue.Value,
-                ["B"] = bColorValue.Value,
-                ["S1"] = s1ColorValue.Value,
-                ["S2"] = s2ColorValue.Value
-            };
-
-            string[] currentColumnTypes = new string[keyMode];
+            var newSelectors = new List<EzSelectorColour>();
+            var colorMapping = createColorMapping();
+            string[] columnTypes = Enum.GetNames(typeof(EzColumnType));
 
             for (int i = 0; i < keyMode; i++)
             {
-                currentColumnTypes[i] = ezSkinConfig.GetColumnType(keyMode, i);
-            }
-
-            for (int i = 0; i < keyMode; i++)
-            {
-                int columnIndex = i;
-                string savedType = currentColumnTypes[columnIndex];
-
-                if (string.IsNullOrEmpty(savedType))
-                {
-                    savedType = EzColumnTypeManager.GetColumnType(keyMode, columnIndex);
-                    currentColumnTypes[columnIndex] = savedType;
-                    ezSkinConfig.SetColumnType(keyMode, columnIndex, savedType);
-                }
-
-                var selector = new EzSelectorColour($"Column {columnIndex + 1}", new[] { "A", "B", "S1", "S2" }, colorMapping);
-                selector.Current.Value = savedType;
-
-                selector.Current.ValueChanged += e =>
-                {
-                    ezSkinConfig.SetColumnType(keyMode, columnIndex, e.NewValue);
-                    ezSkinConfig.Save();
-                    // Invalidate();
-                };
-
+                var selector = createColumnSelector(keyMode, i, columnTypes, colorMapping);
                 columnsContainer.Add(selector);
+                newSelectors.Add(selector);
             }
+
+            columnSelectorCache[keyMode] = newSelectors;
         }
 
-        #endregion
+        private Dictionary<string, Color4> createColorMapping()
+        {
+            return new Dictionary<string, Color4>
+            {
+                [EzConstants.COLUMN_TYPE_A] = colorBindables[EzSkinSetting.ColumnTypeA].Value,
+                [EzConstants.COLUMN_TYPE_B] = colorBindables[EzSkinSetting.ColumnTypeB].Value,
+                [EzConstants.COLUMN_TYPE_S] = colorBindables[EzSkinSetting.ColumnTypeS].Value,
+                [EzConstants.COLUMN_TYPE_E] = colorBindables[EzSkinSetting.ColumnTypeE].Value,
+                [EzConstants.COLUMN_TYPE_P] = colorBindables[EzSkinSetting.ColumnTypeP].Value
+            };
+        }
+
+        private EzSelectorColour createColumnSelector(int keyMode, int columnIndex, string[] columnTypes, Dictionary<string, Color4> colorMapping)
+        {
+            string savedType = ezSkinConfig.GetColumnType(keyMode, columnIndex);
+
+            if (string.IsNullOrEmpty(savedType))
+            {
+                savedType = EzColumnTypeManager.GetColumnType(keyMode, columnIndex);
+                ezSkinConfig.SetColumnType(keyMode, columnIndex, savedType);
+            }
+
+            var selector = new EzSelectorColour($"Column {columnIndex + 1}", columnTypes, colorMapping);
+            selector.Current.Value = savedType;
+
+            selector.Current.ValueChanged += e =>
+            {
+                ezSkinConfig.SetColumnType(keyMode, columnIndex, e.NewValue);
+            };
+
+            return selector;
+        }
     }
 }
diff --git a/osu.Game/Screens/EzConfig.cs b/osu.Game/Screens/EzConfig.cs
new file mode 100644
index 0000000000..288346292e
--- /dev/null
+++ b/osu.Game/Screens/EzConfig.cs
@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Game.Screens
+{
+    public static class EzConfig
+    {
+        public static Bindable<float> GetNoteSize(this EzSkinSettingsManager setting, int keyMode, int columnIndex, int x = 0)
+        {
+            var result = new Bindable<float>();
+
+            var columnWidthBindable = setting.GetBindable<double>(EzSkinSetting.ColumnWidth);
+            var specialFactorBindable = setting.GetBindable<double>(EzSkinSetting.SpecialFactor);
+            var heightScaleBindable = setting.GetBindable<double>(EzSkinSetting.NoteHeightScaleToWidth);
+
+            void updateNoteSize()
+            {
+                bool isSpecialColumn = setting.GetColumnType(keyMode, columnIndex) == "S";
+                double baseWidth = columnWidthBindable.Value;
+                double specialFactor = specialFactorBindable.Value;
+
+                if (x != 0)
+                {
+                    result.Value = (float)(baseWidth * (isSpecialColumn ? specialFactor : 1.0));
+                    return;
+                }
+
+                double heightScale = heightScaleBindable.Value;
+                double columnWidth = baseWidth * (isSpecialColumn ? specialFactor : 1.0);
+                result.Value = (float)(columnWidth * heightScale);
+            }
+
+            columnWidthBindable.BindValueChanged(e => {
+                System.Diagnostics.Debug.WriteLine($"ColumnWidth changed: {e.NewValue}");
+                updateNoteSize();
+            });
+            specialFactorBindable.BindValueChanged(_ => updateNoteSize());
+
+            if (x == 0)
+                heightScaleBindable.BindValueChanged(_ => updateNoteSize());
+
+            updateNoteSize();
+
+            return result;
+        }
+    }
+}
diff --git a/osu.Game/Screens/EzSkinSettingsManager.cs b/osu.Game/Screens/EzSkinSettingsManager.cs
index dc8df3ce3d..21218b586e 100644
--- a/osu.Game/Screens/EzSkinSettingsManager.cs
+++ b/osu.Game/Screens/EzSkinSettingsManager.cs
@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
@@ -18,68 +20,29 @@ namespace osu.Game.Screens
         protected override string Filename => "EzSkinSettings.ini";
         private readonly int[] commonKeyModes = { 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18 };
 
-        protected override void InitialiseDefaults()
+        private static readonly Dictionary<int, EzSkinSetting> key_mode_to_column_color_setting = new Dictionary<int, EzSkinSetting>
         {
-            SetDefault(EzSkinSetting.SelectedKeyMode, 4);
+            { 4, EzSkinSetting.ColumnColor4K },
+            { 5, EzSkinSetting.ColumnColor5K },
+            { 6, EzSkinSetting.ColumnColor6K },
+            { 7, EzSkinSetting.ColumnColor7K },
+            { 8, EzSkinSetting.ColumnColor8K },
+            { 9, EzSkinSetting.ColumnColor9K },
+            { 10, EzSkinSetting.ColumnColor10K },
+            { 12, EzSkinSetting.ColumnColor12K },
+            { 14, EzSkinSetting.ColumnColor14K },
+            { 16, EzSkinSetting.ColumnColor16K },
+            { 18, EzSkinSetting.ColumnColor18K },
+        };
 
-            SetDefault(EzSkinSetting.ColumnWidth, 60, 5, 400.0, 1.0);
-            SetDefault(EzSkinSetting.SpecialFactor, 1.2, 0.5, 2.0, 0.1);
-            SetDefault(EzSkinSetting.HitPosition, LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION, 0, 500, 1.0);
-            SetDefault(EzSkinSetting.VisualHitPosition, 0.0, -100, 100, 1.0);
-
-            SetDefault(EzSkinSetting.ColumnWidthStyle, EzColumnWidthStyle.EzStyleProOnly);
-            SetDefault(EzSkinSetting.GlobalHitPosition, false);
-            SetDefault(EzSkinSetting.GlobalTextureName, 4);
-
-            SetDefault(EzSkinSetting.NoteSetName, "evolve");
-            SetDefault(EzSkinSetting.StageName, "JIYU");
-            SetDefault(EzSkinSetting.NonSquareNoteHeight, 28.0, 1.0, 100.0, 1.0);
-            SetDefault(EzSkinSetting.NoteTrackLine, true);
-            SetDefault(EzSkinSetting.NoteTrackLineHeight, 300, 0, 1000, 5.0);
-
-            SetDefault(EzSkinSetting.ColorSettingsEnabled, true);
-            SetDefault(EzSkinSetting.ColumnTypeA, Colour4.FromHex("#F5F5F5"));
-            SetDefault(EzSkinSetting.ColumnTypeB, Colour4.FromHex("#648FFF"));
-            SetDefault(EzSkinSetting.ColumnTypeS1, Colour4.FromHex("#FF4A4A"));
-            SetDefault(EzSkinSetting.ColumnTypeS2, Colour4.FromHex("#72FF72"));
-
-            foreach (int keyMode in commonKeyModes)
-            {
-                EzSkinSetting setting = getColumnColorSetting(keyMode);
-                SetDefault(setting, string.Join(",", getDefaultColumnTypes(keyMode)));
-            }
-        }
-
-        private EzSkinSetting getColumnColorSetting(int keyMode)
+        private static readonly Dictionary<string, EzSkinSetting> column_type_to_setting = new Dictionary<string, EzSkinSetting>
         {
-            return keyMode switch
-            {
-                4 => EzSkinSetting.ColumnColor4K,
-                5 => EzSkinSetting.ColumnColor5K,
-                6 => EzSkinSetting.ColumnColor6K,
-                7 => EzSkinSetting.ColumnColor7K,
-                8 => EzSkinSetting.ColumnColor8K,
-                9 => EzSkinSetting.ColumnColor9K,
-                10 => EzSkinSetting.ColumnColor10K,
-                12 => EzSkinSetting.ColumnColor12K,
-                14 => EzSkinSetting.ColumnColor14K,
-                16 => EzSkinSetting.ColumnColor16K,
-                18 => EzSkinSetting.ColumnColor18K,
-                _ => throw new NotSupportedException($"不支持 {keyMode} 键位模式")
-            };
-        }
-
-        private string[] getDefaultColumnTypes(int keyMode)
-        {
-            string[] types = new string[keyMode];
-
-            for (int i = 0; i < keyMode; i++)
-            {
-                types[i] = EzColumnTypeManager.GetColumnType(keyMode, i);
-            }
-
-            return types;
-        }
+            [nameof(EzColumnType.A)] = EzSkinSetting.ColumnTypeA,
+            [nameof(EzColumnType.B)] = EzSkinSetting.ColumnTypeB,
+            [nameof(EzColumnType.S)] = EzSkinSetting.ColumnTypeS,
+            [nameof(EzColumnType.E)] = EzSkinSetting.ColumnTypeE,
+            [nameof(EzColumnType.P)] = EzSkinSetting.ColumnTypeP,
+        };
 
         public EzSkinSettingsManager(Storage storage)
             : base(storage)
@@ -87,32 +50,90 @@ namespace osu.Game.Screens
             initializeEvents();
         }
 
+        protected override void InitialiseDefaults()
+        {
+            SetDefault(EzSkinSetting.SelectedKeyMode, 4);
+            SetDefault(EzSkinSetting.ColumnWidthStyle, EzColumnWidthStyle.EzStyleProOnly);
+            SetDefault(EzSkinSetting.GlobalHitPosition, false);
+            SetDefault(EzSkinSetting.GlobalTextureName, 4);
+
+            SetDefault(EzSkinSetting.ColumnWidth, 60, 5, 400.0, 1.0);
+            SetDefault(EzSkinSetting.SpecialFactor, 1.2, 0.5, 2.0, 0.1);
+            SetDefault(EzSkinSetting.HitPosition, LegacyManiaSkinConfiguration.DEFAULT_HIT_POSITION, 0, 500, 1.0);
+            SetDefault(EzSkinSetting.VisualHitPosition, 0.0, -100, 100, 1.0);
+
+            SetDefault(EzSkinSetting.NoteSetName, "evolve");
+            SetDefault(EzSkinSetting.StageName, "JIYU");
+            SetDefault(EzSkinSetting.NoteHeightScaleToWidth, 1, 0.1, 2, 0.1);
+            SetDefault(EzSkinSetting.NoteTrackLineHeight, 300, 0, 1000, 5.0);
+
+            SetDefault(EzSkinSetting.ColorSettingsEnabled, true);
+            SetDefault(EzSkinSetting.ColumnTypeA, Colour4.FromHex("#F5F5F5"));
+            SetDefault(EzSkinSetting.ColumnTypeB, Colour4.FromHex("#648FFF"));
+            SetDefault(EzSkinSetting.ColumnTypeS, Colour4.FromHex("#FF4A4A"));
+            SetDefault(EzSkinSetting.ColumnTypeE, Colour4.FromHex("#FF4A4A"));
+            SetDefault(EzSkinSetting.ColumnTypeP, Colour4.FromHex("#72FF72"));
+
+            SetDefault(EzSkinSetting.ColorSettingsEnabled, true);
+            SetDefault(EzSkinSetting.ColumnTypeA, Colour4.FromHex("#F5F5F5"));
+            SetDefault(EzSkinSetting.ColumnTypeB, Colour4.FromHex("#648FFF"));
+            SetDefault(EzSkinSetting.ColumnTypeS, Colour4.FromHex("#FF4A4A"));
+            SetDefault(EzSkinSetting.ColumnTypeE, Colour4.FromHex("#FF4A4A"));
+            SetDefault(EzSkinSetting.ColumnTypeP, Colour4.FromHex("#72FF72"));
+            initializeColumnTypeDefaults();
+        }
+
+        private void initializeColumnTypeDefaults()
+        {
+            foreach (int keyMode in commonKeyModes)
+            {
+                if (key_mode_to_column_color_setting.TryGetValue(keyMode, out var setting))
+                {
+                    string[] defaultTypes = getDefaultColumnTypes(keyMode);
+                    SetDefault(setting, string.Join(",", defaultTypes));
+                }
+            }
+        }
+
+        private static EzSkinSetting getColumnTypeListSetting(int keyMode)
+        {
+            if (key_mode_to_column_color_setting.TryGetValue(keyMode, out var setting))
+                return setting;
+
+            throw new NotSupportedException($"不支持 {keyMode} 键位模式");
+        }
+
+        private static string[] getDefaultColumnTypes(int keyMode)
+        {
+            return Enumerable.Range(0, keyMode)
+                             .Select(i => EzColumnTypeManager.GetColumnType(keyMode, i))
+                             .ToArray();
+        }
+
         public string GetColumnType(int keyMode, int columnIndex)
         {
             try
             {
-                EzSkinSetting setting = getColumnColorSetting(keyMode);
-                string columnColors = Get<string>(setting);
-
-                string[] types = columnColors.Split(',');
+                var setting = getColumnTypeListSetting(keyMode);
+                string? columnColors = Get<string>(setting);
+                string[] types = columnColors?.Split(',') ?? Array.Empty<string>();
 
                 if (columnIndex < types.Length && !string.IsNullOrEmpty(types[columnIndex]))
                     return types[columnIndex];
-
-                return EzColumnTypeManager.GetColumnType(keyMode, columnIndex);
             }
             catch (NotSupportedException)
             {
-                return EzColumnTypeManager.GetColumnType(keyMode, columnIndex);
             }
+
+            return EzColumnTypeManager.GetColumnType(keyMode, columnIndex);
         }
 
         public void SetColumnType(int keyMode, int columnIndex, string colorType)
         {
             try
             {
-                EzSkinSetting setting = getColumnColorSetting(keyMode);
-                string currentConfig = Get<string>(setting);
+                var setting = getColumnTypeListSetting(keyMode);
+                string? currentConfig = Get<string>(setting);
                 string[] types = !string.IsNullOrEmpty(currentConfig)
                     ? currentConfig.Split(',')
                     : new string[keyMode];
@@ -134,53 +155,84 @@ namespace osu.Game.Screens
         {
             string colorType = GetColumnType(keyMode, columnIndex);
 
-            EzSkinSetting setting = colorType switch
-            {
-                "S1" => EzSkinSetting.ColumnTypeS1,
-                "S2" => EzSkinSetting.ColumnTypeS2,
-                "B" => EzSkinSetting.ColumnTypeB,
-                _ => EzSkinSetting.ColumnTypeA
-            };
+            if (column_type_to_setting.TryGetValue(colorType, out var setting))
+                return Get<Colour4>(setting);
 
-            return Get<Colour4>(setting);
+            return Get<Colour4>(EzSkinSetting.ColumnTypeA);
         }
 
+        public IBindable<Colour4> GetColumnColorBindable(int keyMode, int columnIndex)
+        {
+            string colorType = GetColumnType(keyMode, columnIndex);
+
+            if (column_type_to_setting.TryGetValue(colorType, out var setting))
+                return GetBindable<Colour4>(setting);
+
+            return GetBindable<Colour4>(EzSkinSetting.ColumnTypeA);
+        }
+
+        // public Bindable<Vector2> GetNoteSize(int keyMode, int columnIndex)
+        // {
+        //     var result = new Bindable<Vector2>();
+        //
+        //     var columnWidthBindable = GetBindable<double>(EzSkinSetting.ColumnWidth);
+        //     var specialFactorBindable = GetBindable<double>(EzSkinSetting.SpecialFactor);
+        //     var heightScaleBindable = GetBindable<double>(EzSkinSetting.NoteHeightScaleToWidth);
+        //
+        //     void updateNoteSize()
+        //     {
+        //         bool isSpecialColumn = GetColumnType(keyMode, columnIndex) == "S";
+        //         double baseWidth = columnWidthBindable.Value;
+        //         double specialFactor = specialFactorBindable.Value;
+        //         double heightScale = heightScaleBindable.Value;
+        //
+        //         float x = (float)(baseWidth * (isSpecialColumn ? specialFactor : 1.0));
+        //         float y = (float)(heightScale);
+        //         result.Value = new Vector2(x, y);
+        //     }
+        //
+        //     columnWidthBindable.BindValueChanged(e =>
+        //     {
+        //         Logger.Log($"ColumnWidth changed: {e.NewValue}");
+        //         updateNoteSize();
+        //     });
+        //     specialFactorBindable.BindValueChanged(_ => updateNoteSize());
+        //     heightScaleBindable.BindValueChanged(_ => updateNoteSize());
+        //
+        //     updateNoteSize();
+        //
+        //     return result;
+        // }
+
         public new Bindable<T> GetBindable<T>(EzSkinSetting setting)
         {
             return base.GetBindable<T>(setting);
         }
 
-        public event Action? OnSettingsChanged;
-        public event Action? OnColumnChanged;
+        // public event Action? OnPositionChanged;
+        public event Action? OnNoteSizeChanged;
 
         private void initializeEvents()
         {
-            GetBindable<double>(EzSkinSetting.ColumnWidth).ValueChanged += e => OnColumnChanged?.Invoke();
-            GetBindable<double>(EzSkinSetting.SpecialFactor).ValueChanged += e => OnColumnChanged?.Invoke();
-
-            GetBindable<double>(EzSkinSetting.HitPosition).ValueChanged += e => OnSettingsChanged?.Invoke();
-            GetBindable<double>(EzSkinSetting.VisualHitPosition).ValueChanged += e => OnSettingsChanged?.Invoke();
-
-            GetBindable<double>(EzSkinSetting.NonSquareNoteHeight).ValueChanged += e => OnSettingsChanged?.Invoke();
-            GetBindable<double>(EzSkinSetting.NoteTrackLineHeight).ValueChanged += e => OnSettingsChanged?.Invoke();
+            // GetBindable<double>(EzSkinSetting.HitPosition).BindValueChanged(_ => OnPositionChanged?.Invoke(), true);
+            GetBindable<double>(EzSkinSetting.NoteHeightScaleToWidth).BindValueChanged(_ => updateAllNoteSizes(), true);
+            GetBindable<double>(EzSkinSetting.ColumnWidth).BindValueChanged(_ => updateAllNoteSizes(), true);
+            GetBindable<double>(EzSkinSetting.SpecialFactor).BindValueChanged(_ => updateAllNoteSizes(), true);
         }
 
-        protected void NotifySettingsChanged()
+        private void updateAllNoteSizes()
         {
-            OnSettingsChanged?.Invoke();
-            OnColumnChanged?.Invoke();
+            OnNoteSizeChanged?.Invoke();
         }
 
         public new void SetValue<T>(EzSkinSetting lookup, T value)
         {
             base.SetValue(lookup, value);
-            NotifySettingsChanged();
         }
 
         public new void Save()
         {
             base.Save();
-            NotifySettingsChanged();
         }
 
         IBindable<float> IGameplaySettings.ComboColourNormalisationAmount => null!;
@@ -214,19 +266,11 @@ namespace osu.Game.Screens
         // Ez专属皮肤设置
         HitPosition,
         VisualHitPosition,
-        NonSquareNoteHeight,
-        NoteTrackLine,
+        NoteHeightScaleToWidth,
         NoteTrackLineHeight,
         GlobalTextureName,
         NoteSetName,
         StageName,
-        // DynamicTracking,
-
-        // 列类型
-        ColumnTypeA,
-        ColumnTypeB,
-        ColumnTypeS1,
-        ColumnTypeS2,
 
         // 着色系统
         ColorSettingsEnabled,
@@ -241,27 +285,31 @@ namespace osu.Game.Screens
         ColumnColor14K,
         ColumnColor16K,
         ColumnColor18K,
+
+        // 列类型
+        // ColumnTypeBase = 500,
+        ColumnTypeA,
+        ColumnTypeB,
+        ColumnTypeS,
+        ColumnTypeE,
+        ColumnTypeP,
+    }
+
+    public enum EzColumnType
+    {
+        A,
+        B,
+        S,
+        E,
+        P
+    }
+
+    public static class EzConstants
+    {
+        public const string COLUMN_TYPE_A = nameof(EzColumnType.A);
+        public const string COLUMN_TYPE_B = nameof(EzColumnType.B);
+        public const string COLUMN_TYPE_S = nameof(EzColumnType.S);
+        public const string COLUMN_TYPE_E = nameof(EzColumnType.E);
+        public const string COLUMN_TYPE_P = nameof(EzColumnType.P);
     }
 }
-
-// private void setDefaultColumnColor()
-// {
-//     foreach (int keyMode in commonKeyModes)
-//     {
-//         EzSkinSetting setting = getColumnColorSetting(keyMode);
-//
-//         string existingConfig = Get<string>(setting);
-//
-//         if (string.IsNullOrEmpty(existingConfig))
-//         {
-//             string[] types = new string[keyMode];
-//
-//             for (int i = 0; i < keyMode; i++)
-//             {
-//                 types[i] = EzColumnTypeManager.GetColumnType(keyMode, i);
-//             }
-//
-//             SetValue(setting, string.Join(",", types));
-//         }
-//     }
-// }
diff --git a/osu.Game/Screens/EzSkinSettingsTab.cs b/osu.Game/Screens/EzSkinSettingsTab.cs
index a4fa4fe434..4dab658632 100644
--- a/osu.Game/Screens/EzSkinSettingsTab.cs
+++ b/osu.Game/Screens/EzSkinSettingsTab.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.IO;
 using osu.Framework.Allocation;
@@ -28,18 +27,6 @@ namespace osu.Game.Screens
 {
     public partial class EzSkinSettings : EditorSidebarSection
     {
-        private readonly Bindable<bool> globalHitPosition = new BindableBool();
-        private readonly Bindable<EzSelectorNameSet> globalTextureName = new Bindable<EzSelectorNameSet>((EzSelectorNameSet)4);
-
-        private readonly Bindable<string> selectedNoteSet = new Bindable<string>();
-        private readonly List<string> availableNoteSets = new List<string>();
-
-        private readonly Bindable<string> selectedStageSet = new Bindable<string>();
-        private readonly List<string> availableStageSets = new List<string>();
-
-        private SettingsButton refreshSkinButton = null!;
-        private bool isAbsolutePosition = true;
-
         [Resolved]
         private EzSkinSettingsManager ezSkinConfig { get; set; } = null!;
 
@@ -50,31 +37,90 @@ namespace osu.Game.Screens
         private Storage storage { get; set; } = null!;
 
         public EzSkinSettings()
-            : base("EZ Skin Settings")
+            : base("EZ Skin Settings") { }
+
+        private static readonly Dictionary<string, string> resource_paths = new Dictionary<string, string>
         {
-        }
+            ["note"] = @"EzResources\note",
+            ["Stage"] = @"EzResources\Stage"
+        };
+
+        private static readonly Dictionary<bool, (Color4 Color, string TopText, string BottomText)> position_mode_config = new Dictionary<bool, (Color4 Color, string TopText, string BottomText)>
+        {
+            [true] = (new Color4(0.2f, 0.4f, 0.8f, 0.3f), "强制刷新, 并切换至 绝对位置", "Refresh, Switch to Absolute"),
+            [false] = (new Color4(0.8f, 0.2f, 0.4f, 0.3f), "强制刷新, 并切换至 相对位置", "Refresh, Switch to Relative")
+        };
+
+        private readonly Bindable<bool> globalHitPosition = new BindableBool();
+        private readonly Bindable<EzSelectorNameSet> globalTextureName = new Bindable<EzSelectorNameSet>((EzSelectorNameSet)4);
+        private readonly Bindable<string> selectedNoteSet = new Bindable<string>();
+        private readonly Bindable<string> selectedStageSet = new Bindable<string>();
+
+        private readonly List<string> availableNoteSets = new List<string>();
+        private readonly List<string> availableStageSets = new List<string>();
+
+        private SettingsButton refreshSkinButton = null!;
+        private ScheduledDelegate? scheduledRefresh;
+        private bool isAbsolutePosition = true;
+
+        public Bindable<double> HitPosition => ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition);
+        public Bindable<double> ColumnWidth => ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth);
+        public Bindable<double> SpecialFactor => ezSkinConfig.GetBindable<double>(EzSkinSetting.SpecialFactor);
+        public Bindable<double> NoteHeightScaleToWidth => ezSkinConfig.GetBindable<double>(EzSkinSetting.NoteHeightScaleToWidth);
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            globalHitPosition.Value = ezSkinConfig.Get<bool>(EzSkinSetting.GlobalHitPosition);
-
+            globalHitPosition.Value = ezSkinConfig.GetBindable<bool>(EzSkinSetting.GlobalHitPosition).Value;
             globalTextureName.Value = (EzSelectorNameSet)ezSkinConfig.GetBindable<int>(EzSkinSetting.GlobalTextureName).Value;
-
             loadFolderSets("note");
-            string configuredNoteSet = ezSkinConfig.Get<string>(EzSkinSetting.NoteSetName);
-            if (!string.IsNullOrEmpty(configuredNoteSet) && availableNoteSets.Contains(configuredNoteSet))
-                selectedNoteSet.Value = configuredNoteSet;
-            else if (availableNoteSets.Count > 0)
-                selectedNoteSet.Value = availableNoteSets[1];
-
             loadFolderSets("Stage");
-            string configStageSet = ezSkinConfig.Get<string>(EzSkinSetting.StageName);
-            if (!string.IsNullOrEmpty(configStageSet) && availableStageSets.Contains(configStageSet))
-                selectedStageSet.Value = configStageSet;
-            else if (availableStageSets.Count > 0)
-                selectedStageSet.Value = availableStageSets[1];
 
+            // 设置默认值
+            setDefaultSelection(selectedNoteSet, availableNoteSets, ezSkinConfig.Get<string>(EzSkinSetting.NoteSetName));
+            setDefaultSelection(selectedStageSet, availableStageSets, ezSkinConfig.Get<string>(EzSkinSetting.StageName));
+            createUI();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            globalTextureName.BindValueChanged(OnNameSetChanged);
+            selectedNoteSet.BindValueChanged(e => ezSkinConfig.SetValue(EzSkinSetting.NoteSetName, e.NewValue));
+            selectedStageSet.BindValueChanged(e => ezSkinConfig.SetValue(EzSkinSetting.StageName, e.NewValue));
+        }
+
+        // public Bindable<float> GetNoteSize(int keyMode, int columnIndex, int x = 0)
+        // {
+        //     bool isSpecialColumn = ezSkinConfig.GetColumnType(keyMode, columnIndex) == "S";
+        //     double baseWidth = ColumnWidth.Value;
+        //     double specialFactor = SpecialFactor.Value;
+        //     double columnWidth = (baseWidth * (isSpecialColumn ? specialFactor : 1.0));
+        //     NoteSize.Value = (float)columnWidth;
+        //
+        //     if (x != 0)
+        //         return NoteSize;
+        //
+        //     double heightScale = NoteHeightScaleToWidth.Value;
+        //     NoteSize.Value = (float)(columnWidth * heightScale);
+        //     return new Bindable<float>((float)(columnWidth * heightScale));
+        // }
+
+        private void setDefaultSelection(Bindable<string> bindable, List<string> availableItems, string configuredValue)
+        {
+            if (!string.IsNullOrEmpty(configuredValue) && availableItems.Contains(configuredValue))
+            {
+                bindable.Value = configuredValue;
+            }
+            else if (availableItems.Count > 1)
+            {
+                bindable.Value = availableItems[1];
+            }
+        }
+
+        private void createUI()
+        {
             Children = new Drawable[]
             {
                 new FillFlowContainer
@@ -85,56 +131,6 @@ namespace osu.Game.Screens
                     Spacing = new Vector2(10),
                     Children = new Drawable[]
                     {
-                        new SettingsEnumDropdown<EzColumnWidthStyle>
-                        {
-                            LabelText = "Column Width Style(列宽风格)",
-                            TooltipText = "不完善！全局总列宽=设置值×10\n"
-                                          + "Global Total Column Width = Configured Value × 10",
-                            Current = ezSkinConfig.GetBindable<EzColumnWidthStyle>(EzSkinSetting.ColumnWidthStyle),
-                        },
-                        new SettingsSlider<double>
-                        {
-                            LabelText = "Column Width (轨道宽度)",
-                            TooltipText = "设置每列的宽度",
-                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth),
-                            KeyboardStep = 1.0f,
-                        },
-                        new SettingsSlider<double>
-                        {
-                            LabelText = "Special Factor (特殊轨道倍率)",
-                            TooltipText = "特殊列关联S1类型, 可自定义"
-                                          + "\nSpecial columns are associated with S1 type, customizable",
-                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.SpecialFactor),
-                            KeyboardStep = 0.1f,
-                        },
-                        new SettingsCheckbox
-                        {
-                            LabelText = "Global HitPosition",
-                            TooltipText = "全局判定线位置开关",
-                            Current = globalHitPosition,
-                        },
-                        new SettingsSlider<double>
-                        {
-                            LabelText = "Hit Position (可视判定线位置)",
-                            TooltipText = "设置判定线位置",
-                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition),
-                            KeyboardStep = 1f,
-                        },
-                        new SettingsSlider<double>
-                        {
-                            LabelText = "Note Height (方形note 厚度)",
-                            TooltipText = "统一修改非圆形note的高度\n"
-                                          + "Fixed Height for square notes",
-                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.NonSquareNoteHeight),
-                            KeyboardStep = 1.0f,
-                        },
-                        new SettingsSlider<double>
-                        {
-                            LabelText = "Note Track Line",
-                            TooltipText = "note两侧辅助轨道线的高度\n"
-                                          + "note side auxiliary track line height",
-                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.NoteTrackLineHeight),
-                        },
                         new EzGlobalTextureNameSelector
                         {
                             LabelText = "Global Texture Name",
@@ -158,6 +154,56 @@ namespace osu.Game.Screens
                             Current = selectedNoteSet,
                             Items = availableNoteSets,
                         },
+                        new SettingsEnumDropdown<EzColumnWidthStyle>
+                        {
+                            LabelText = "Column Width Style(列宽风格)",
+                            TooltipText = "不完善！全局总列宽=设置值×10\n"
+                                          + "Global Total Column Width = Configured Value × 10",
+                            Current = ezSkinConfig.GetBindable<EzColumnWidthStyle>(EzSkinSetting.ColumnWidthStyle),
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Column Width (轨道宽度)",
+                            TooltipText = "设置每列的宽度",
+                            Current = ColumnWidth,
+                            KeyboardStep = 1.0f,
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Special Factor (特殊轨道倍率)",
+                            TooltipText = "特殊列关联S1类型, 可自定义"
+                                          + "\nSpecial columns are associated with S1 type, customizable",
+                            Current = SpecialFactor,
+                            KeyboardStep = 0.1f,
+                        },
+                        new SettingsCheckbox
+                        {
+                            LabelText = "Global HitPosition",
+                            TooltipText = "全局判定线位置开关",
+                            Current = globalHitPosition,
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Hit Position (可视判定线位置)",
+                            TooltipText = "设置判定线位置",
+                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.HitPosition),
+                            KeyboardStep = 1f,
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Note Height Scale (note 高度比例)",
+                            TooltipText = "统一修改note的高度的比例\n"
+                                          + "Fixed Height for square notes",
+                            Current = NoteHeightScaleToWidth,
+                            KeyboardStep = 1.0f,
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Note Track Line",
+                            TooltipText = "note两侧辅助轨道线的高度\n"
+                                          + "note side auxiliary track line height",
+                            Current = ezSkinConfig.GetBindable<double>(EzSkinSetting.NoteTrackLineHeight),
+                        },
                         refreshSkinButton = new SettingsButton
                         {
                             Action = RefreshSkin,
@@ -171,23 +217,15 @@ namespace osu.Game.Screens
                     }
                 }
             };
-
-            selectedNoteSet.BindValueChanged(e => ezSkinConfig.SetValue(EzSkinSetting.NoteSetName, e.NewValue));
-            selectedStageSet.BindValueChanged(e => ezSkinConfig.SetValue(EzSkinSetting.StageName, e.NewValue));
-            globalTextureName.BindValueChanged(OnTextureNameChanged);
         }
 
         #region 追踪处理
 
-        private void OnTextureNameChanged(ValueChangedEvent<EzSelectorNameSet> textureName)
+        private void OnNameSetChanged(ValueChangedEvent<EzSelectorNameSet> textureName)
         {
-            updateAllSkinComponentsTextureNames(textureName.NewValue);
-
-            ezSkinConfig.SetValue(EzSkinSetting.GlobalTextureName, (int)textureName.NewValue);
+            updateAllEzTextureNames(textureName.NewValue);
         }
 
-        private ScheduledDelegate? scheduledRefresh;
-
         public void ScheduleRefresh()
         {
             scheduledRefresh?.Cancel();
@@ -199,38 +237,23 @@ namespace osu.Game.Screens
             isAbsolutePosition = !isAbsolutePosition;
             skinManager.CurrentSkinInfo.TriggerChange();
             // skinManager.Save(skinManager.CurrentSkin.Value);
-
-            // 更新按钮颜色
-            updateButtonColor(refreshSkinButton, isAbsolutePosition);
-            // 更新按钮文字
-            updateButtonText(refreshSkinButton, isAbsolutePosition);
+            updateButtonAppearance();
         }
 
-        private void updateButtonColor(SettingsButton button, bool isAbsolute)
+        private void updateButtonAppearance()
         {
-            Color4 color = isAbsolute ? new Color4(0.2f, 0.4f, 0.8f, 0.3f) : new Color4(0.8f, 0.2f, 0.4f, 0.3f);
-            // 找到按钮内的Box并更新颜色
-            var box = button.ChildrenOfType<Box>().FirstOrDefault();
+            var config = position_mode_config[isAbsolutePosition];
 
-            box?.FadeColour(color, 200);
-        }
+            var box = refreshSkinButton.ChildrenOfType<Box>().FirstOrDefault();
+            box?.FadeColour(config.Color, 200);
 
-        private void updateButtonText(SettingsButton button, bool isAbsolute)
-        {
-            string topText = isAbsolute ? "强制刷新, 并切换至 绝对位置" : "强制刷新, 并切换至 相对位置";
-            string bottomText = isAbsolute ? "Refresh, Switch to Absolute" : "Refresh, Switch to Relative";
+            var textContainer = refreshSkinButton.ChildrenOfType<FillFlowContainer>().FirstOrDefault();
+            var texts = textContainer?.ChildrenOfType<OsuSpriteText>().ToArray();
 
-            var textContainer = button.ChildrenOfType<FillFlowContainer>().FirstOrDefault();
-
-            if (textContainer != null)
+            if (texts?.Length >= 2)
             {
-                var texts = textContainer.ChildrenOfType<OsuSpriteText>().ToArray();
-
-                if (texts.Length >= 2)
-                {
-                    texts[0].Text = topText;
-                    texts[1].Text = bottomText;
-                }
+                texts[0].Text = config.TopText;
+                texts[1].Text = config.BottomText;
             }
         }
 
@@ -238,58 +261,30 @@ namespace osu.Game.Screens
 
         #region 刷新所有EzComponent的纹理名称
 
-        private void updateAllSkinComponentsTextureNames(EzSelectorNameSet textureName)
+        private void updateAllEzTextureNames(EzSelectorNameSet textureName)
         {
-            var scoreTexts = this.ChildrenOfType<EzScoreText>().ToList();
-            var comboTexts = this.ChildrenOfType<EzComboText>().ToList();
+            var root = findRootDrawable();
 
-            if (Parent != null)
-            {
-                var parentScoreTexts = Parent.ChildrenOfType<EzScoreText>().ToList();
-                var parentComboTexts = Parent.ChildrenOfType<EzComboText>().ToList();
-
-                scoreTexts.AddRange(parentScoreTexts);
-                comboTexts.AddRange(parentComboTexts);
-            }
-
-            var root = this as Drawable;
-
-            while (root.Parent != null)
-            {
-                root = root.Parent;
-            }
-
-            var rootScoreTexts = root.ChildrenOfType<EzScoreText>().ToList();
-            var rootComboTexts = root.ChildrenOfType<EzComboText>().ToList();
-
-            scoreTexts.AddRange(rootScoreTexts);
-            comboTexts.AddRange(rootComboTexts);
-
-            var hitResultScores = this.ChildrenOfType<EzComHitResultScore>().ToList();
-
-            if (Parent != null)
-            {
-                var parentHitResultScores = Parent.ChildrenOfType<EzComHitResultScore>().ToList();
-                hitResultScores.AddRange(parentHitResultScores);
-            }
-
-            var rootHitResultScores = root.ChildrenOfType<EzComHitResultScore>().ToList();
-            hitResultScores.AddRange(rootHitResultScores);
+            var scoreTexts = root.ChildrenOfType<EzScoreText>();
+            var comboTexts = root.ChildrenOfType<EzComboText>();
+            var hitResultScores = root.ChildrenOfType<EzComHitResultScore>();
 
             foreach (var scoreText in scoreTexts)
-            {
                 scoreText.FontName.Value = textureName;
-            }
 
             foreach (var comboText in comboTexts)
-            {
                 comboText.FontName.Value = textureName;
-            }
 
             foreach (var hitResultScore in hitResultScores)
-            {
                 hitResultScore.NameDropdown.Value = textureName;
-            }
+        }
+
+        private Drawable findRootDrawable()
+        {
+            var root = this as Drawable;
+            while (root.Parent != null)
+                root = root.Parent;
+            return root;
         }
 
         #endregion
@@ -299,11 +294,16 @@ namespace osu.Game.Screens
             List<string> targetList = type.Equals("note", StringComparison.OrdinalIgnoreCase) ? availableNoteSets : availableStageSets;
             targetList.Clear();
 
+            if (!resource_paths.TryGetValue(type, out string? relativePath))
+            {
+                Logger.Log($"Unknown resource type: {type}", LoggingTarget.Runtime, LogLevel.Error);
+                return;
+            }
+
             try
             {
-                string relativePath = $@"EzResources\{type}";
-                string dataFolderPath = storage.GetFullPath(relativePath);
-                Debug.Assert(!string.IsNullOrEmpty(dataFolderPath));
+                string? dataFolderPath = storage.GetFullPath(relativePath);
+                // Debug.Assert(!string.IsNullOrEmpty(dataFolderPath));
 
                 if (!Directory.Exists(dataFolderPath))
                 {
@@ -312,14 +312,9 @@ namespace osu.Game.Screens
                 }
 
                 string[] directories = Directory.GetDirectories(dataFolderPath);
+                targetList.AddRange(directories.Select(Path.GetFileName).Where(name => !string.IsNullOrEmpty(name))!);
 
-                foreach (string dir in directories)
-                {
-                    string dirName = Path.GetFileName(dir);
-                    targetList.Add(dirName);
-                }
-
-                Logger.Log($"EzSkinTab Find {dataFolderPath} to {targetList.Count} {type} Sets", LoggingTarget.Runtime, LogLevel.Debug);
+                Logger.Log($"Found {targetList.Count} {type} sets in {dataFolderPath}", LoggingTarget.Runtime, LogLevel.Debug);
             }
             catch (Exception ex)
             {
diff --git a/osu.Game/Screens/IEzConfig.cs b/osu.Game/Screens/IEzConfig.cs
new file mode 100644
index 0000000000..8796e766b6
--- /dev/null
+++ b/osu.Game/Screens/IEzConfig.cs
@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Game.Screens
+{
+    public interface IEzConfig
+    {
+        Bindable<float> NoteSize { get; }
+        Bindable<double> ColumnWidth { get; }
+        Bindable<double> SpecialFactor { get; }
+        Bindable<double> NoteHeightScaleToWidth { get; }
+    }
+}
diff --git a/osu.Game/Screens/LAsEzExtensions/EzColumnTypeManager.cs b/osu.Game/Screens/LAsEzExtensions/EzColumnTypeManager.cs
index bf3baf89d2..775628fb46 100644
--- a/osu.Game/Screens/LAsEzExtensions/EzColumnTypeManager.cs
+++ b/osu.Game/Screens/LAsEzExtensions/EzColumnTypeManager.cs
@@ -7,17 +7,17 @@ namespace osu.Game.Screens.LAsEzExtensions
     {
         public static string GetColumnType(int keyMode, int columnIndex)
         {
-            // 边界检查
             if (columnIndex < 0 || columnIndex >= keyMode)
                 return "A";
 
-            // 特殊键 (Special或Effect) - 使用S1颜色
             if (isSpecialColumn(keyMode, columnIndex))
-                return "S1";
+                return "S";
+
+            if (isEffectColumn(keyMode, columnIndex))
+                return "E";
 
-            // 面板键 - 使用S2颜色
             if (isPanelColumn(keyMode, columnIndex))
-                return "S2";
+                return "P";
 
             int normalKeyIndex = 0;
 
@@ -30,6 +30,19 @@ namespace osu.Game.Screens.LAsEzExtensions
             return getNormalColumnType(keyMode, normalKeyIndex, columnIndex);
         }
 
+        private static string getNormalColumnType(int keyMode, int normalKeyIndex, int columnIndex)
+        {
+            if (keyMode % 2 == 0)
+            {
+                int halfKey = keyMode / 2;
+                return columnIndex < halfKey
+                    ? (normalKeyIndex % 2 == 0 ? "A" : "B")
+                    : (normalKeyIndex % 2 == 0 ? "B" : "A");
+            }
+
+            return normalKeyIndex % 2 == 0 ? "A" : "B";
+        }
+
         private static bool isSpecialColumn(int keyMode, int columnIndex)
         {
             return keyMode switch
@@ -37,6 +50,14 @@ namespace osu.Game.Screens.LAsEzExtensions
                 12 when columnIndex is 0 or 11 => true,
                 14 when columnIndex is 0 or 12 => true,
                 16 when columnIndex is 0 or 15 => true,
+                _ => false
+            };
+        }
+
+        private static bool isEffectColumn(int keyMode, int columnIndex)
+        {
+            return keyMode switch
+            {
                 16 when columnIndex is 6 or 7 or 8 or 9 => true,
                 _ => false
             };
@@ -53,18 +74,5 @@ namespace osu.Game.Screens.LAsEzExtensions
                 _ => false
             };
         }
-
-        private static string getNormalColumnType(int keyMode, int normalKeyIndex, int columnIndex)
-        {
-            if (keyMode % 2 == 0)
-            {
-                int halfKey = keyMode / 2;
-                return columnIndex < halfKey
-                    ? (normalKeyIndex % 2 == 0 ? "A" : "B")
-                    : (normalKeyIndex % 2 == 0 ? "B" : "A");
-            }
-
-            return normalKeyIndex % 2 == 0 ? "A" : "B";
-        }
     }
 }
diff --git a/osu.Game/Screens/LAsEzExtensions/EzEditorSidebar.cs b/osu.Game/Screens/LAsEzExtensions/EzEditorSidebar.cs
index afdce43e29..1a1e9671f0 100644
--- a/osu.Game/Screens/LAsEzExtensions/EzEditorSidebar.cs
+++ b/osu.Game/Screens/LAsEzExtensions/EzEditorSidebar.cs
@@ -80,11 +80,11 @@ namespace osu.Game.Screens.LAsEzExtensions
 
         private void showColorSettings()
         {
-            var colorSettings = new EzColumnTab
+            var ezColumnSettings = new EzColumnTab
             {
                 RelativeSizeAxes = Axes.X
             };
-            Content.Add(colorSettings);
+            Content.Add(ezColumnSettings);
         }
 
         /// <summary>
diff --git a/osu.Game/Screens/LAsEzExtensions/EzLocalTextureFactory.cs b/osu.Game/Screens/LAsEzExtensions/EzLocalTextureFactory.cs
index b668f61673..5d16ce977f 100644
--- a/osu.Game/Screens/LAsEzExtensions/EzLocalTextureFactory.cs
+++ b/osu.Game/Screens/LAsEzExtensions/EzLocalTextureFactory.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
@@ -9,21 +11,44 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
+using osuTK;
 
 namespace osu.Game.Screens.LAsEzExtensions
 {
+    [Cached]
     public partial class EzLocalTextureFactory : CompositeDrawable
     {
+        // 常量定义
+        private const int max_cache_size = 100;
+        private const int max_frames_to_load = 240;
+        private const int max_stage_frames = 120;
+        private const double default_frame_length = 1000.0 / 60.0 * 4;
+        private const float default_stage_body_height = 247f;
+
+        // 全局缓存，带LRU机制
+        private static readonly Dictionary<string, List<Texture>> global_texture_cache = new Dictionary<string, List<Texture>>();
+        private static readonly Dictionary<string, bool> global_component_cache = new Dictionary<string, bool>();
+        private static readonly Dictionary<string, DateTime> cache_access_times = new Dictionary<string, DateTime>();
+        private static readonly object global_cache_lock = new object();
+
+        // 实例级缓存，统一使用全局锁
+        private readonly Dictionary<string, float> noteRatioCache = new Dictionary<string, float>();
+
+        private readonly TextureStore textureStore;
+        private readonly EzSkinSettingsManager ezSkinConfig;
+        private readonly Dictionary<string, TextureLoaderStore> loaderStoreCache = new Dictionary<string, TextureLoaderStore>();
+        private bool initialized;
+
         public Bindable<string> NoteSetName { get; set; } = new Bindable<string>();
         public Bindable<string> StageName { get; set; } = new Bindable<string>();
-        public event Action? OnNoteChanged;
-        public event Action? OnStageChanged;
 
-        private bool initialized;
-        private readonly EzSkinSettingsManager ezSkinConfig;
-        private readonly TextureStore textureStore;
-        private readonly Storage hostStorage;
-        private readonly Dictionary<string, TextureLoaderStore> loaderStoreCache = new Dictionary<string, TextureLoaderStore>();
+        public Bindable<double> ColumnWidth = new Bindable<double>();
+        public Bindable<double> SpecialFactor = new Bindable<double>();
+        public Bindable<double> NoteHeightScaleToWidth = new Bindable<double>();
+
+        public event Action? OnNoteChanged;
+        public event Action? OnNoteSizeChanged;
+        public event Action? OnStageChanged;
 
         public EzLocalTextureFactory(
             EzSkinSettingsManager ezSkinConfig,
@@ -32,14 +57,8 @@ namespace osu.Game.Screens.LAsEzExtensions
         {
             this.ezSkinConfig = ezSkinConfig;
             this.textureStore = textureStore;
-            this.hostStorage = hostStorage;
+            // this.hostStorage = hostStorage;
 
-            ensureLoaderExists();
-            initialize();
-        }
-
-        private void ensureLoaderExists()
-        {
             const string path = "EzResources/";
 
             if (!loaderStoreCache.TryGetValue(path, out var textureLoaderStore))
@@ -50,20 +69,8 @@ namespace osu.Game.Screens.LAsEzExtensions
                 loaderStoreCache[path] = textureLoaderStore;
                 textureStore.AddTextureSource(textureLoaderStore);
             }
-        }
 
-        private void clearCacheForPrefix(string prefix)
-        {
-            var keysToRemove = new List<string>();
-
-            foreach (string key in ratioCache.Keys)
-            {
-                if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
-                    keysToRemove.Add(key);
-            }
-
-            foreach (string key in keysToRemove)
-                ratioCache.Remove(key);
+            initialize();
         }
 
         private void initialize()
@@ -75,83 +82,283 @@ namespace osu.Game.Screens.LAsEzExtensions
             NoteSetName = ezSkinConfig.GetBindable<string>(EzSkinSetting.NoteSetName);
             NoteSetName.BindValueChanged(e =>
             {
-                // foreach (var loader in loaderStoreCache.Values)
-                //     loader.Dispose();
-                // loaderStoreCache.Clear();
-                // ratioCache.Clear();
-                clearCacheForPrefix("note/");
                 OnNoteChanged?.Invoke();
             }, true);
+
             StageName = ezSkinConfig.GetBindable<string>(EzSkinSetting.StageName);
             StageName.BindValueChanged(e =>
             {
-                // foreach (var loader in loaderStoreCache.Values)
-                //     loader.Dispose();
-                // loaderStoreCache.Clear();
-                clearCacheForPrefix("Stage/");
                 OnStageChanged?.Invoke();
             }, true);
+
+            ColumnWidth = ezSkinConfig.GetBindable<double>(EzSkinSetting.ColumnWidth);
+            SpecialFactor = ezSkinConfig.GetBindable<double>(EzSkinSetting.SpecialFactor);
+            NoteHeightScaleToWidth = ezSkinConfig.GetBindable<double>(EzSkinSetting.NoteHeightScaleToWidth);
+            // ColumnWidth.BindValueChanged(e =>
+            // {
+            //     OnNoteSizeChanged?.Invoke();
+            // }, true);
+            // SpecialFactor.BindValueChanged(e =>
+            // {
+            //     OnNoteSizeChanged?.Invoke();
+            // }, true);
+            // NoteHeightScaleToWidth.BindValueChanged(e =>
+            // {
+            //     OnNoteSizeChanged?.Invoke();
+            // }, true);
         }
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
+        #region 工具方法
 
-            if (isDisposing)
+        private float calculateRatio(string path)
+        {
+            try
             {
-                foreach (var loader in loaderStoreCache.Values)
-                    loader.Dispose();
-                loaderStoreCache.Clear();
+                string noteSetName = NoteSetName.Value;
+                string cacheKey = $"{noteSetName}_{System.IO.Path.GetFileName(path)}";
+
+                lock (global_cache_lock)
+                {
+                    if (global_texture_cache.TryGetValue(cacheKey, out var cachedFrames) && cachedFrames.Count > 0)
+                    {
+                        var firstFrame = cachedFrames[0];
+                        return (firstFrame.Height / (float)firstFrame.Width);
+                    }
+                }
+
+                Texture texture = textureStore.Get($"{path}/000.png") ??
+                                  textureStore.Get($"{path}/001.png");
+
+                return (texture?.Height / (float)(texture?.Width!)) ?? 1.0f;
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error calculating ratio for {path}: {ex.Message}",
+                    LoggingTarget.Runtime, LogLevel.Error);
+                return 1.0f;
             }
         }
 
+        public float GetRatio(string component)
+        {
+            string? noteName = NoteSetName.Value;
+            string path = $"note/{noteName}/{component}";
+
+            lock (global_cache_lock)
+            {
+                if (noteRatioCache.TryGetValue(path, out float cachedRatio))
+                    return cachedRatio;
+            }
+
+            float ratio = calculateRatio(path);
+            if (ratio >= 0.75f) ratio = 1.0f;
+
+            lock (global_cache_lock)
+            {
+                noteRatioCache[path] = ratio;
+            }
+
+            return ratio;
+        }
+
+        public bool IsSquareNote(string component)
+        {
+            float ratio = GetRatio(component);
+            return ratio >= 0.75f;
+        }
+
+        public Bindable<Vector2> GetNoteSize(int keyMode, int columnIndex)
+        {
+            var result = new Bindable<Vector2>();
+
+            float ratio = GetRatio("whitenote");
+
+            void updateNoteSize()
+            {
+                bool isSpecialColumn = ezSkinConfig.GetColumnType(keyMode, columnIndex) == "S";
+                float x = (float)(ColumnWidth.Value * (isSpecialColumn ? SpecialFactor.Value : 1.0));
+                float y = (float)(NoteHeightScaleToWidth.Value) * ratio * x;
+                result.Value = new Vector2(x, y);
+            }
+
+            ColumnWidth.BindValueChanged(_ => updateNoteSize());
+            SpecialFactor.BindValueChanged(_ => updateNoteSize());
+            NoteHeightScaleToWidth.BindValueChanged(_ => updateNoteSize());
+
+            updateNoteSize();
+
+            return result;
+        }
+
+        #endregion
+
+        #region 缓存处理
+
+        private static void cleanOldCacheEntries()
+        {
+            if (global_texture_cache.Count <= max_cache_size) return;
+
+            var oldestEntries = cache_access_times
+                                .OrderBy(kvp => kvp.Value)
+                                .Take(global_texture_cache.Count - max_cache_size + 10)
+                                .Select(kvp => kvp.Key)
+                                .ToList();
+
+            foreach (string key in oldestEntries)
+            {
+                global_texture_cache.Remove(key);
+                global_component_cache.Remove(key);
+                cache_access_times.Remove(key);
+            }
+
+            Logger.Log($"[EzLocalTextureFactory] Cleaned {oldestEntries.Count} old cache entries",
+                LoggingTarget.Performance, LogLevel.Debug);
+        }
+
+        private List<Texture> getCachedTextureFrames(string component, string currentNoteSetName)
+        {
+            string cacheKey = $"{currentNoteSetName}_{component}";
+
+            lock (global_cache_lock)
+            {
+                if (global_texture_cache.TryGetValue(cacheKey, out var cachedFrames))
+                {
+                    cache_access_times[cacheKey] = DateTime.Now;
+                    return cachedFrames;
+                }
+            }
+
+            var frames = loadTextureFrames(component, currentNoteSetName);
+
+            lock (global_cache_lock)
+            {
+                cleanOldCacheEntries();
+
+                if (frames.Count > 0)
+                {
+                    global_texture_cache[cacheKey] = frames;
+                    global_component_cache[cacheKey] = true;
+                    cache_access_times[cacheKey] = DateTime.Now;
+                }
+                else
+                {
+                    global_component_cache[cacheKey] = false;
+                }
+            }
+
+            return frames;
+        }
+
+        public static void ClearGlobalCache()
+        {
+            lock (global_cache_lock)
+            {
+                Logger.Log($"[EzLocalTextureFactory] Clearing global cache ({global_texture_cache.Count} entries)",
+                    LoggingTarget.Performance, LogLevel.Important);
+
+                global_texture_cache.Clear();
+                global_component_cache.Clear();
+                cache_access_times.Clear();
+            }
+        }
+
+        private List<Texture> loadTextureFrames(string component, string noteSetName)
+        {
+            var frames = new List<Texture>();
+
+            string[] pathsToTry = new[]
+            {
+                $"note/{noteSetName}/{component}",
+                $"note/circle/{component}"
+            };
+
+            foreach (string basePath in pathsToTry)
+            {
+                try
+                {
+                    for (int i = 0; i < max_frames_to_load; i++)
+                    {
+                        string frameFile = $"{basePath}/{i:D3}.png";
+                        var texture = textureStore.Get(frameFile);
+
+                        if (texture == null) break;
+
+                        frames.Add(texture);
+                    }
+
+                    if (frames.Count > 0)
+                        break;
+                }
+                catch (Exception ex)
+                {
+                    Logger.Log($"Error loading texture frames for {basePath}: {ex.Message}",
+                        LoggingTarget.Runtime, LogLevel.Error);
+                }
+            }
+
+            return frames;
+        }
+
+        #endregion
+
+        #region Note Animation Creation
+
         private bool isHitCom(string componentName)
         {
             return componentName.Contains("flare", StringComparison.InvariantCultureIgnoreCase);
         }
 
-        public virtual TextureAnimation CreateAnimation(string component)
+        public virtual TextureAnimation CreateAnimation(string component, int? columnIndex = null)
         {
-            bool isHit = isHitCom(component);
+            string currentNoteSetName = NoteSetName.Value;
+            // string cacheKey = $"{currentNoteSetName}_{component}";
+            // bool fromCache;
+            //
+            // lock (global_cache_lock)
+            // {
+            //     fromCache = global_texture_cache.ContainsKey(cacheKey);
+            // }
 
-            TextureAnimation animation = new TextureAnimation
+// #if DEBUG
+//             string callerType = new System.Diagnostics.StackTrace().GetFrame(1)?.GetMethod()?.DeclaringType?.Name ?? "Unknown";
+//             Logger.Log($"[EzLocalTextureFactory] Creating texture {currentNoteSetName}/{component} from {callerType} (cached: {fromCache})",
+//                 LoggingTarget.Runtime, LogLevel.Debug);
+// #endif
+
+            bool isHit = isHitCom(component);
+            var animation = new TextureAnimation
             {
-                Anchor = Anchor.Centre,
+                Anchor = isHit ? Anchor.BottomCentre : Anchor.Centre,
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = isHit ? Axes.None : Axes.Both,
                 FillMode = isHit ? FillMode.Fit : FillMode.Stretch,
                 Loop = !isHit
             };
 
-            if (!isHit)
-                animation.DefaultFrameLength = 1000.0 / 60.0 * 4;
+            if (!isHit) animation.DefaultFrameLength = default_frame_length;
 
-            string[] pathsToTry =
+            var frames = getCachedTextureFrames(component, currentNoteSetName);
+
+// #if DEBUG
+//             if (frames.Count > 0)
+//             {
+//                 Logger.Log($"[EzLocalTextureFactory] Created animation for {component} with {frames.Count} frames",
+//                     LoggingTarget.Runtime, LogLevel.Debug);
+//             }
+// #endif
+
+            foreach (var texture in frames)
             {
-                $"note/{NoteSetName.Value}/{component}",
-                $"note/circle/{component}"
-            };
-
-            foreach (string basePath in pathsToTry)
-            {
-                for (int i = 0; i < 300; i++)
-                {
-                    string frameFile = $"{basePath}/{i:D3}.png";
-                    var texture = textureStore.Get(frameFile);
-
-                    if (texture == null)
-                        break;
-
-                    animation.AddFrame(texture);
-                }
-
-                if (animation.FrameCount > 0)
-                    break;
+                animation.AddFrame(texture);
             }
 
             return animation;
         }
 
+        #endregion
+
+        #region Stage Creation
+
         private bool isStageBody(string componentName)
         {
             return componentName.Contains("Body", StringComparison.InvariantCultureIgnoreCase);
@@ -179,52 +386,17 @@ namespace osu.Game.Screens.LAsEzExtensions
                     FillMode = FillMode.Fill,
                     Y = 0,
                     AutoSizeAxes = Axes.X,
-                    Height = 247f,
+                    Height = default_stage_body_height,
                     Masking = true,
                 };
 
                 addStageComponent(container, $"{basePath}/fivekey/{component}");
                 addStageComponent(container, $"{basePath}/GrooveLight");
-                string overObjectPath = $"{basePath}/Stage/{StageName.Value}_OverObject/{StageName.Value}_OverObject";
-
-                var animation = new TextureAnimation
-                {
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.BottomCentre,
-                    RelativeSizeAxes = Axes.None,
-                    FillMode = FillMode.Fill,
-                    Loop = true,
-                    DefaultFrameLength = 1000.0 / 60.0 * 4
-                };
-
-                for (int i = 0; i < 120; i++)
-                {
-                    var texture = textureStore.Get($"{overObjectPath}_{i}.png");
-                    if (texture == null)
-                        break;
-
-                    animation.AddFrame(texture);
-                }
-
-                container.Add(animation);
+                createStageAnimation(container, basePath);
             }
             else
             {
-                string baseKeyPath = $"{basePath}/eightkey/{component}";
-                string[] pathsToTry =
-                {
-                    $"{baseKeyPath}/KeyBase",
-                    $"{baseKeyPath}/KeyPress",
-                    $"{baseKeyPath}/KeyBase_0",
-                    $"{baseKeyPath}/KeyPress_0",
-                    $"{baseKeyPath}/2KeyBase_0",
-                    $"{baseKeyPath}/2KeyPress_0",
-                };
-
-                foreach (string paths in pathsToTry)
-                {
-                    addStageComponent(container, $"{paths}");
-                }
+                createStageKeys(container, basePath, component);
             }
 
             return container;
@@ -244,50 +416,88 @@ namespace osu.Game.Screens.LAsEzExtensions
                 Width = texture.Width,
                 Height = texture.Height,
                 Texture = texture,
-                // Blending = BlendingParameters.Additive,
             });
 
-            Logger.Log($"Factory load {basePath}");
+#if DEBUG
+            Logger.Log($"[EzLocalTextureFactory] Loaded stage component: {basePath}",
+                LoggingTarget.Runtime, LogLevel.Debug);
+#endif
+        }
+
+        private void createStageAnimation(Container container, string basePath)
+        {
+            string overObjectPath = $"{basePath}/Stage/{StageName.Value}_OverObject/{StageName.Value}_OverObject";
+
+            var animation = new TextureAnimation
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                RelativeSizeAxes = Axes.None,
+                FillMode = FillMode.Fill,
+                Loop = true,
+                DefaultFrameLength = default_frame_length
+            };
+
+            try
+            {
+                for (int i = 0; i < max_stage_frames; i++)
+                {
+                    var texture = textureStore.Get($"{overObjectPath}_{i}.png");
+                    if (texture == null)
+                        break;
+
+                    animation.AddFrame(texture);
+                }
+
+                if (animation.FrameCount > 0)
+                    container.Add(animation);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error loading stage animation: {ex.Message}", LoggingTarget.Runtime, LogLevel.Error);
+            }
+        }
+
+        private void createStageKeys(Container container, string basePath, string component)
+        {
+            string baseKeyPath = $"{basePath}/eightkey/{component}";
+            string[] pathsToTry =
+            {
+                $"{baseKeyPath}/KeyBase",
+                $"{baseKeyPath}/KeyPress",
+                $"{baseKeyPath}/KeyBase_0",
+                $"{baseKeyPath}/KeyPress_0",
+                $"{baseKeyPath}/2KeyBase_0",
+                $"{baseKeyPath}/2KeyPress_0",
+            };
+
+            foreach (string path in pathsToTry)
+            {
+                addStageComponent(container, path);
+            }
         }
 
         private Texture? loadStageTexture(string basePath, int i = -1)
         {
-            string texturePath;
-
-            if (i < 0) { texturePath = $"{basePath}.png"; }
-            else
-            {
-                texturePath = i == 0
-                    ? $"{basePath}.png"
-                    : $"{basePath}_{i}.png";
-            }
+            string texturePath = i < 0
+                ? $"{basePath}.png"
+                : (i == 0 ? $"{basePath}.png" : $"{basePath}_{i}.png");
 
             return textureStore.Get(texturePath);
         }
 
-        private readonly Dictionary<string, float> ratioCache = new Dictionary<string, float>();
+        #endregion
 
-        public float GetRatio(string component)
+        protected override void Dispose(bool isDisposing)
         {
-            string path = $"note/{NoteSetName.Value}/{component}";
+            if (isDisposing)
+            {
+                foreach (var loader in loaderStoreCache.Values)
+                    loader.Dispose();
+                loaderStoreCache.Clear();
+            }
 
-            if (ratioCache.TryGetValue(path, out float cachedRatio))
-                return cachedRatio;
-
-            Texture texture = textureStore.Get($"{path}/000.png") ?? textureStore.Get($"{path}/001.png");
-
-            float ratio = texture == null
-                ? 1.0f
-                : texture.Height / (float)texture.Width;
-
-            ratioCache[path] = ratio;
-            return ratio;
-        }
-
-        public bool IsSquareNote(string component)
-        {
-            float ratio = GetRatio(component);
-            return ratio >= 0.75f;
+            base.Dispose(isDisposing);
         }
     }
 
diff --git a/osu.Game/Screens/LAsEzExtensions/EzSelectorColour.cs b/osu.Game/Screens/LAsEzExtensions/EzSelectorColour.cs
index 815160073c..0fc88bea36 100644
--- a/osu.Game/Screens/LAsEzExtensions/EzSelectorColour.cs
+++ b/osu.Game/Screens/LAsEzExtensions/EzSelectorColour.cs
@@ -38,10 +38,11 @@ namespace osu.Game.Screens.LAsEzExtensions
             // 优化：使用懒加载初始化默认颜色
             defaultColors = new Lazy<Dictionary<string, Color4>>(() => new Dictionary<string, Color4>
             {
-                ["A"] = Color4.White,
-                ["B"] = Color4.DodgerBlue,
-                ["S1"] = Color4.LimeGreen,
-                ["S2"] = Color4.Red
+                [EzConstants.COLUMN_TYPE_A] = Color4.White,
+                [EzConstants.COLUMN_TYPE_B] = Color4.DodgerBlue,
+                [EzConstants.COLUMN_TYPE_S] = Color4.IndianRed,
+                [EzConstants.COLUMN_TYPE_E] = Color4.IndianRed,
+                [EzConstants.COLUMN_TYPE_P] = Color4.LimeGreen
             });
 
             if (colorMapping != null)
@@ -95,14 +96,14 @@ namespace osu.Game.Screens.LAsEzExtensions
 
             AddButtons(items);
 
-            Current.ValueChanged += e =>
+            Current.BindValueChanged(e =>
             {
                 if (e.OldValue != null && buttonsByName.TryGetValue(e.OldValue, out var oldButton))
                     oldButton.Selected = false;
 
                 if (e.NewValue != null && buttonsByName.TryGetValue(e.NewValue, out var newButton))
                     newButton.Selected = true;
-            };
+            });
         }
 
         // 添加悬浮事件处理
@@ -167,6 +168,22 @@ namespace osu.Game.Screens.LAsEzExtensions
 
             return defaultColors.Value.TryGetValue(name, out color) ? color : Color4.White;
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                foreach (var button in buttonsByName.Values)
+                {
+                    button.Action = null;
+                }
+
+                buttonsByName.Clear();
+                colorMap.Clear();
+            }
+
+            base.Dispose(isDisposing);
+        }
     }
 
     public partial class ColorButton : CompositeDrawable
diff --git a/osu.Game/Screens/Menu/MenuTipDisplay.cs b/osu.Game/Screens/Menu/MenuTipDisplay.cs
index 9430d65433..d9e38e8aa0 100644
--- a/osu.Game/Screens/Menu/MenuTipDisplay.cs
+++ b/osu.Game/Screens/Menu/MenuTipDisplay.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -12,6 +13,8 @@ using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Input;
+using osu.Game.Input.Bindings;
 using osuTK;
 using osuTK.Graphics;
 using osu.Game.Localisation;
@@ -27,6 +30,9 @@ namespace osu.Game.Screens.Menu
 
         private Bindable<bool> showMenuTips = null!;
 
+        [Resolved]
+        private RealmKeyBindingStore keyBindingStore { get; set; } = null!;
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -97,42 +103,103 @@ namespace osu.Game.Screens.Menu
                 .FadeOutFromOne(2000, Easing.OutQuint);
         }
 
+        private const int available_tips = 29;
+
         private LocalisableString getRandomTip()
         {
-            LocalisableString[] tips =
-            {
-                MenuTipStrings.ToggleToolbarShortcut,
-                MenuTipStrings.GameSettingsShortcut,
-                MenuTipStrings.DynamicSettings,
-                MenuTipStrings.NewFeaturesAreComingOnline,
-                MenuTipStrings.UIScalingSettings,
-                MenuTipStrings.ScreenScalingSettings,
-                MenuTipStrings.FreeOsuDirect,
-                MenuTipStrings.ReplaySeeking,
-                MenuTipStrings.MultithreadingSupport,
-                MenuTipStrings.TryNewMods,
-                MenuTipStrings.EmbeddedWebContent,
-                MenuTipStrings.BeatmapRightClick,
-                MenuTipStrings.TemporaryDeleteOperations,
-                MenuTipStrings.DiscoverPlaylists,
-                MenuTipStrings.ToggleAdvancedFPSCounter,
-                MenuTipStrings.GlobalStatisticsShortcut,
-                MenuTipStrings.ReplayPausing,
-                MenuTipStrings.ConfigurableHotkeys,
-                MenuTipStrings.PeekHUDWhenHidden,
-                MenuTipStrings.SkinEditor,
-                MenuTipStrings.DragAndDropImageInSkinEditor,
-                MenuTipStrings.ModPresets,
-                MenuTipStrings.ModCustomisationSettings,
-                MenuTipStrings.RandomSkinShortcut,
-                MenuTipStrings.ToggleReplaySettingsShortcut,
-                MenuTipStrings.CopyModsFromScore,
-                MenuTipStrings.AutoplayBeatmapShortcut,
-                MenuTipStrings.LazerIsNotAWord,
-                MenuTipStrings.RightMouseAbsoluteScroll,
-            };
+            int tipIndex = RNG.Next(0, available_tips);
 
-            return tips[RNG.Next(0, tips.Length)];
+            switch (tipIndex)
+            {
+                case 0:
+                    return MenuTipStrings.ToggleToolbarShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleToolbar).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 1:
+                    return MenuTipStrings.GameSettingsShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleSettings).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 2:
+                    return MenuTipStrings.DynamicSettings;
+
+                case 3:
+                    return MenuTipStrings.NewFeaturesAreComingOnline;
+
+                case 4:
+                    return MenuTipStrings.UIScalingSettings;
+
+                case 5:
+                    return MenuTipStrings.ScreenScalingSettings;
+
+                case 6:
+                    return MenuTipStrings.FreeOsuDirect(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleBeatmapListing).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 7:
+                    return MenuTipStrings.ReplaySeeking;
+
+                case 8:
+                    return MenuTipStrings.MultithreadingSupport;
+
+                case 9:
+                    return MenuTipStrings.TryNewMods;
+
+                case 10:
+                    return MenuTipStrings.EmbeddedWebContent;
+
+                case 11:
+                    return MenuTipStrings.BeatmapRightClick;
+
+                case 12:
+                    return MenuTipStrings.TemporaryDeleteOperations;
+
+                case 13:
+                    return MenuTipStrings.DiscoverPlaylists;
+
+                case 14:
+                    return MenuTipStrings.ToggleAdvancedFPSCounter;
+
+                case 15:
+                    return MenuTipStrings.GlobalStatisticsShortcut;
+
+                case 16:
+                    return MenuTipStrings.ReplayPausing(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.TogglePauseReplay).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 17:
+                    return MenuTipStrings.ConfigurableHotkeys;
+
+                case 18:
+                    return MenuTipStrings.PeekHUDWhenHidden(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.HoldForHUD).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 19:
+                    return MenuTipStrings.SkinEditor(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleSkinEditor).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 20:
+                    return MenuTipStrings.DragAndDropImageInSkinEditor;
+
+                case 21:
+                    return MenuTipStrings.ModPresets;
+
+                case 22:
+                    return MenuTipStrings.ModCustomisationSettings;
+
+                case 23:
+                    return MenuTipStrings.RandomSkinShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.RandomSkin).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 24:
+                    return MenuTipStrings.ToggleReplaySettingsShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleReplaySettings).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+
+                case 25:
+                    return MenuTipStrings.CopyModsFromScore;
+
+                case 26:
+                    return MenuTipStrings.AutoplayBeatmapShortcut;
+
+                case 27:
+                    return MenuTipStrings.LazerIsNotAWord;
+
+                case 28:
+                    return MenuTipStrings.RightMouseAbsoluteScroll;
+            }
+
+            return string.Empty;
         }
     }
 }
diff --git a/osu.Game/Screens/Menu/SupporterDisplay.cs b/osu.Game/Screens/Menu/SupporterDisplay.cs
index 9602f4f61d..d33698a8a8 100644
--- a/osu.Game/Screens/Menu/SupporterDisplay.cs
+++ b/osu.Game/Screens/Menu/SupporterDisplay.cs
@@ -105,7 +105,7 @@ namespace osu.Game.Screens.Menu
 
                     Schedule(() =>
                     {
-                        heart?.FlashColour(Color4.White, 750, Easing.OutQuint).Loop();
+                        heart.FlashColour(Color4.White, 750, Easing.OutQuint).Loop();
                     });
                 });
             }, true);
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index db1b8262b7..689a8df12f 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -83,6 +83,21 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         /// </summary>
         protected bool ExitConfirmed { get; private set; }
 
+        /// <summary>
+        /// Used for testing - whether the local user style can be edited.
+        /// False if the beatmap hasn't been downloaded yet, or if freestyle isn't enabled.
+        /// </summary>
+        internal bool UserStyleEditingEnabled
+        {
+            get
+            {
+                if (!userStyleDisplayContainer.IsPresent)
+                    return false;
+
+                return userStyleDisplayContainer.SingleOrDefault()?.AllowEditing == true;
+            }
+        }
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
@@ -466,7 +481,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             if (settings.PlaylistItemId != lastPlaylistItemId)
             {
-                Scheduler.AddOnce(updateGameplayState);
+                onActivePlaylistItemChanged();
                 lastPlaylistItemId = settings.PlaylistItemId;
             }
 
@@ -479,7 +494,29 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private void onItemChanged(MultiplayerPlaylistItem item)
         {
             if (item.ID == client.Room?.Settings.PlaylistItemId)
-                Scheduler.AddOnce(updateGameplayState);
+                onActivePlaylistItemChanged();
+        }
+
+        /// <summary>
+        /// Responds to changes in the active playlist item resulting from the playlist item being edited or the room settings changing.
+        /// </summary>
+        private void onActivePlaylistItemChanged()
+        {
+            if (client.Room == null)
+                return;
+
+            // Check if we need to make this the current screen as a result of the beatmap set changing while the user's selecting a style.
+            if (this.GetChildScreen() is MultiplayerMatchFreestyleSelect)
+            {
+                MultiplayerPlaylistItem item = client.Room.CurrentPlaylistItem;
+
+                var newBeatmap = beatmapManager.QueryBeatmap($@"{nameof(BeatmapInfo.OnlineID)} == $0 AND {nameof(BeatmapInfo.MD5Hash)} == {nameof(BeatmapInfo.OnlineMD5Hash)}", item.BeatmapID);
+
+                if (!Beatmap.Value.BeatmapSetInfo.Equals(newBeatmap?.BeatmapSet))
+                    this.MakeCurrent();
+            }
+
+            Scheduler.AddOnce(updateGameplayState);
         }
 
         /// <summary>
@@ -636,16 +673,18 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 userStyleSection.Show();
 
                 PlaylistItem apiItem = new PlaylistItem(item).With(beatmap: new Optional<IBeatmapInfo>(new APIBeatmap { OnlineID = gameplayBeatmapId }), ruleset: gameplayRulesetId);
+                DrawableRoomPlaylistItem? currentDisplay = userStyleDisplayContainer.SingleOrDefault();
 
-                if (!apiItem.Equals(userStyleDisplayContainer.SingleOrDefault()?.Item))
+                if (!apiItem.Equals(currentDisplay?.Item))
                 {
-                    userStyleDisplayContainer.Child = new DrawableRoomPlaylistItem(apiItem, true)
+                    userStyleDisplayContainer.Child = currentDisplay = new DrawableRoomPlaylistItem(apiItem, true)
                     {
                         AllowReordering = false,
-                        AllowEditing = true,
-                        RequestEdit = _ => showUserStyleSelect()
+                        RequestEdit = _ => ShowUserStyleSelect()
                     };
                 }
+
+                currentDisplay.AllowEditing = localBeatmap != null;
             }
             else
                 userStyleSection.Hide();
@@ -677,7 +716,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         /// <summary>
         /// Shows the user style selection.
         /// </summary>
-        private void showUserStyleSelect()
+        public void ShowUserStyleSelect()
         {
             if (!this.IsCurrentScreen() || client.Room == null || client.LocalUser == null)
                 return;
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
index 7ad8bdf454..1f96f0d371 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
@@ -154,7 +154,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             });
             leaderboardFlow.Insert(0, Leaderboard = new DrawableGameplayLeaderboard
             {
-                CollapseDuringGameplay = { Value = false }
+                CollapseDuringGameplay = { Value = false },
+                AlwaysShown = true,
             });
 
             LoadComponentAsync(new GameplayChatDisplay(room)
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayFreestyleSelect.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayFreestyleSelect.cs
index 66218c0e9e..13ac406396 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlayFreestyleSelect.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayFreestyleSelect.cs
@@ -97,17 +97,22 @@ namespace osu.Game.Screens.OnlinePlay
         private partial class DifficultySelectFilterControl : FilterControl
         {
             private readonly PlaylistItem item;
-            private double itemLength;
-            private int beatmapSetId;
+
+            [Resolved]
+            private RealmAccess realm { get; set; } = null!;
 
             public DifficultySelectFilterControl(PlaylistItem item)
             {
                 this.item = item;
             }
 
-            [BackgroundDependencyLoader]
-            private void load(RealmAccess realm)
+            public override FilterCriteria CreateCriteria()
             {
+                var criteria = base.CreateCriteria();
+
+                double itemLength = 0;
+                int beatmapSetId = 0;
+
                 realm.Run(r =>
                 {
                     int beatmapId = item.Beatmap.OnlineID;
@@ -116,11 +121,6 @@ namespace osu.Game.Screens.OnlinePlay
                     itemLength = beatmap?.Length ?? 0;
                     beatmapSetId = beatmap?.BeatmapSet?.OnlineID ?? 0;
                 });
-            }
-
-            public override FilterCriteria CreateCriteria()
-            {
-                var criteria = base.CreateCriteria();
 
                 // Must be from the same set as the playlist item.
                 criteria.BeatmapSetId = beatmapSetId;
@@ -131,7 +131,6 @@ namespace osu.Game.Screens.OnlinePlay
                 criteria.Length.Max = itemLength + 30000;
                 criteria.Length.IsLowerInclusive = true;
                 criteria.Length.IsUpperInclusive = true;
-
                 return criteria;
             }
         }
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
index 74b12b6d3c..4b7ffe42ea 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using System.Threading.Tasks;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Scoring;
@@ -27,6 +28,20 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             this.scoreId = scoreId;
         }
 
+        protected override Task<ScoreInfo[]> FetchScores()
+        {
+            // Don't attempt to index scores if the given score has an invalid online ID.
+            // This can happen if the score failed to submit but is otherwise in a presentable state.
+            return scoreId <= 0 ? Task.FromResult<ScoreInfo[]>([]) : base.FetchScores();
+        }
+
+        protected override Task<ScoreInfo[]> FetchNextPage(int direction)
+        {
+            // Don't attempt to index scores if the given score has an invalid online ID.
+            // This can happen if the score failed to submit but is otherwise in a presentable state.
+            return scoreId <= 0 ? Task.FromResult<ScoreInfo[]>([]) : base.FetchNextPage(direction);
+        }
+
         protected override APIRequest<MultiplayerScore> CreateScoreRequest() => new ShowPlaylistScoreRequest(RoomId, PlaylistItem.ID, scoreId);
 
         protected override void OnScoresAdded(ScoreInfo[] scores)
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index cfd651ba4d..5b42bcf254 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -630,17 +630,18 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                 userStyleSection.Show();
 
                 PlaylistItem gameplayItem = item.With(ruleset: gameplayRuleset.OnlineID, beatmap: new Optional<IBeatmapInfo>(gameplayBeatmap));
-                PlaylistItem? currentItem = userStyleDisplayContainer.SingleOrDefault()?.Item;
+                DrawableRoomPlaylistItem? currentDisplay = userStyleDisplayContainer.SingleOrDefault();
 
-                if (!gameplayItem.Equals(currentItem))
+                if (!gameplayItem.Equals(currentDisplay?.Item))
                 {
-                    userStyleDisplayContainer.Child = new DrawableRoomPlaylistItem(gameplayItem, true)
+                    userStyleDisplayContainer.Child = currentDisplay = new DrawableRoomPlaylistItem(gameplayItem, true)
                     {
                         AllowReordering = false,
-                        AllowEditing = true,
                         RequestEdit = _ => showUserStyleSelect()
                     };
                 }
+
+                currentDisplay.AllowEditing = localBeatmap != null;
             }
             else
                 userStyleSection.Hide();
diff --git a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
index dd55e5f926..e02ef03dea 100644
--- a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
@@ -28,6 +28,8 @@ namespace osu.Game.Screens.Play.HUD
 
         public DrawableGameplayLeaderboardScore? TrackedScore { get; private set; }
 
+        public bool AlwaysShown { get; init; }
+
         [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.CollapseDuringGameplay), nameof(SkinnableComponentStrings.CollapseDuringGameplayDescription))]
         public Bindable<bool> CollapseDuringGameplay { get; } = new BindableBool(true);
 
@@ -109,7 +111,7 @@ namespace osu.Game.Screens.Play.HUD
             if (Flow.Alpha < 1)
                 scroll.ScrollToStart(false);
 
-            Flow.FadeTo(player?.Configuration.ShowLeaderboard != false && configVisibility.Value ? 1 : 0, 100, Easing.OutQuint);
+            Flow.FadeTo(player?.Configuration.ShowLeaderboard != false && (configVisibility.Value || AlwaysShown) ? 1 : 0, 100, Easing.OutQuint);
             expanded.Value = !CollapseDuringGameplay.Value || userPlayingState.Value != LocalUserPlayingState.Playing || holdingForHUD.Value;
         }
 
diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
index bc542ca8b7..c8d0c8eb44 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
@@ -125,7 +125,7 @@ namespace osu.Game.Screens.Select.Carousel
 
             if (manager != null)
             {
-                hideRequested = manager.Hide;
+                hideRequested = b => manager.Hide(b);
 
                 if (ruleset.Value.OnlineID == 3)
                 {
diff --git a/osu.Game/Screens/Select/Details/AdvancedStats.cs b/osu.Game/Screens/Select/Details/AdvancedStats.cs
index 152398dee3..90a4af48f0 100644
--- a/osu.Game/Screens/Select/Details/AdvancedStats.cs
+++ b/osu.Game/Screens/Select/Details/AdvancedStats.cs
@@ -185,9 +185,7 @@ namespace osu.Game.Screens.Select.Details
 
                 if (Ruleset.Value != null)
                 {
-                    double rate = ModUtils.CalculateRateWithMods(Mods.Value);
-
-                    adjustedDifficulty = Ruleset.Value.CreateInstance().GetRateAdjustedDisplayDifficulty(originalDifficulty, rate);
+                    adjustedDifficulty = Ruleset.Value.CreateInstance().GetAdjustedDisplayDifficulty(originalDifficulty, Mods.Value);
 
                     TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
                 }
diff --git a/osu.Game/Screens/Select/Filter/GroupMode.cs b/osu.Game/Screens/Select/Filter/GroupMode.cs
index b3a4f36c91..04aef2fe18 100644
--- a/osu.Game/Screens/Select/Filter/GroupMode.cs
+++ b/osu.Game/Screens/Select/Filter/GroupMode.cs
@@ -34,6 +34,9 @@ namespace osu.Game.Screens.Select.Filter
         // [Description("Favourites")]
         // Favourites,
 
+        [Description("Last Played")]
+        LastPlayed,
+
         [Description("Length")]
         Length,
 
@@ -46,8 +49,8 @@ namespace osu.Game.Screens.Select.Filter
         [Description("Ranked Status")]
         RankedStatus,
 
-        [Description("Last Played")]
-        LastPlayed,
+        [Description("Source")]
+        Source,
 
         [Description("Title")]
         Title,
diff --git a/osu.Game/Screens/Select/Filter/SortMode.cs b/osu.Game/Screens/Select/Filter/SortMode.cs
index be055c7f0b..7f2b33adbe 100644
--- a/osu.Game/Screens/Select/Filter/SortMode.cs
+++ b/osu.Game/Screens/Select/Filter/SortMode.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.ComponentModel;
 using osu.Framework.Localisation;
 using osu.Game.Resources.Localisation.Web;
 
@@ -11,22 +12,22 @@ namespace osu.Game.Screens.Select.Filter
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingArtist))]
         Artist,
 
-        [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingAuthor))]
+        [Description("Author")]
         Author,
 
         [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.ArtistTracksBpm))]
         BPM,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.DateSubmitted))]
+        [Description("Date Submitted")]
         DateSubmitted,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.DateAdded))]
+        [Description("Date Added")]
         DateAdded,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.DateRanked))]
+        [Description("Date Ranked")]
         DateRanked,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.LastPlayed))]
+        [Description("Last Played")]
         LastPlayed,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingDifficulty))]
@@ -39,7 +40,7 @@ namespace osu.Game.Screens.Select.Filter
         // [Description("Rank Achieved")]
         // RankAchieved,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.ArtistTracksSource))]
+        [Description("Source")]
         Source,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingTitle))]
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index 4119807692..eb360a1f60 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -143,10 +143,77 @@ namespace osu.Game.Screens.SelectV2
                     break;
 
                 case NotifyCollectionChangedAction.Remove:
+                    bool selectedSetDeleted = false;
+
                     foreach (var set in oldItems!)
                     {
                         foreach (var beatmap in set.Beatmaps)
+                        {
                             Items.RemoveAll(i => i is BeatmapInfo bi && beatmap.Equals(bi));
+                            selectedSetDeleted |= CheckModelEquality(CurrentSelection, beatmap);
+                        }
+                    }
+
+                    // After removing all items in this batch, we want to make an immediate reselection
+                    // based on adjacency to the previous selection if it was deleted.
+                    //
+                    // This needs to be done immediately to avoid song select making a random selection.
+                    // This needs to be done in this class because we need to know final display order.
+                    // This needs to be done with attention to detail of which beatmaps have not been deleted.
+                    if (selectedSetDeleted && CurrentSelectionIndex != null)
+                    {
+                        var items = GetCarouselItems()!;
+                        if (items.Count == 0)
+                            break;
+
+                        bool success = false;
+
+                        // Try selecting forwards first
+                        for (int i = CurrentSelectionIndex.Value + 1; i < items.Count; i++)
+                        {
+                            if (attemptSelection(items[i]))
+                            {
+                                success = true;
+                                break;
+                            }
+                        }
+
+                        if (success)
+                            break;
+
+                        // Then try backwards (we might be at the end of available items).
+                        for (int i = Math.Min(items.Count - 1, CurrentSelectionIndex.Value); i >= 0; i--)
+                        {
+                            if (attemptSelection(items[i]))
+                                break;
+                        }
+
+                        bool attemptSelection(CarouselItem item)
+                        {
+                            if (CheckValidForSetSelection(item))
+                            {
+                                if (item.Model is BeatmapInfo beatmapInfo)
+                                {
+                                    // check the new selection wasn't deleted above
+                                    if (!Items.Contains(beatmapInfo))
+                                        return false;
+
+                                    RequestSelection(beatmapInfo);
+                                    return true;
+                                }
+
+                                if (item.Model is BeatmapSetInfo beatmapSetInfo)
+                                {
+                                    if (oldItems.Contains(beatmapSetInfo))
+                                        return false;
+
+                                    RequestRecommendedSelection(beatmapSetInfo.Beatmaps);
+                                    return true;
+                                }
+                            }
+
+                            return false;
+                        }
                     }
 
                     break;
@@ -822,9 +889,31 @@ namespace osu.Game.Screens.SelectV2
     /// <summary>
     /// Defines a grouping header for a set of carousel items.
     /// </summary>
-    /// <param name="Order">The order of this group in the carousel, sorted using ascending order.</param>
-    /// <param name="Title">The title of this group.</param>
-    public record GroupDefinition(int Order, string Title);
+    public record GroupDefinition
+    {
+        /// <summary>
+        /// The order of this group in the carousel, sorted using ascending order.
+        /// </summary>
+        public int Order { get; }
+
+        /// <summary>
+        /// The title of this group.
+        /// </summary>
+        public string Title { get; }
+
+        private readonly string uncasedTitle;
+
+        public GroupDefinition(int order, string title)
+        {
+            Order = order;
+            Title = title;
+            uncasedTitle = title.ToLowerInvariant();
+        }
+
+        public virtual bool Equals(GroupDefinition? other) => uncasedTitle == other?.uncasedTitle;
+
+        public override int GetHashCode() => HashCode.Combine(uncasedTitle);
+    }
 
     /// <summary>
     /// Defines a grouping header for a set of carousel items grouped by star difficulty.
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
index 772d4123c2..eb55e03d6b 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
@@ -202,6 +202,9 @@ namespace osu.Game.Screens.SelectV2
                         return defineGroupByLength(length);
                     }, items);
 
+                case GroupMode.Source:
+                    return getGroupsBy(b => defineGroupBySource(b.BeatmapSet!.Metadata.Source), items);
+
                 // TODO: need implementation
                 //
                 // case GroupMode.Collections:
@@ -225,6 +228,7 @@ namespace osu.Game.Screens.SelectV2
         {
             return items.GroupBy(i => getGroup((BeatmapInfo)i.Model))
                         .OrderBy(s => s.Key.Order)
+                        .ThenBy(s => s.Key.Title)
                         .Select(g => new GroupMapping(g.Key, g.ToList()))
                         .ToList();
         }
@@ -355,6 +359,14 @@ namespace osu.Game.Screens.SelectV2
             return new GroupDefinition(11, "Over 10 minutes");
         }
 
+        private GroupDefinition defineGroupBySource(string source)
+        {
+            if (string.IsNullOrEmpty(source))
+                return new GroupDefinition(1, "Unsourced");
+
+            return new GroupDefinition(0, source);
+        }
+
         private static T? aggregateMax<T>(BeatmapInfo b, Func<BeatmapInfo, T> func)
         {
             var beatmaps = b.BeatmapSet!.Beatmaps.Where(bb => !bb.Hidden);
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
index 0554b1b815..11e1f281e5 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
@@ -397,8 +397,7 @@ namespace osu.Game.Screens.SelectV2
             float fadeBottom = (float)(scoresScroll.Current + scoresScroll.DrawHeight);
             float fadeTop = (float)(scoresScroll.Current);
 
-            if (!scoresScroll.IsScrolledToStart())
-                fadeTop += height;
+            fadeTop += (float)Math.Min(height, Math.Log10(Math.Max(fadeTop, 0) + 1) * height);
 
             foreach (var c in scoresContainer)
             {
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
index a4be87953c..2b1469d6e2 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
@@ -24,10 +24,8 @@ using osu.Game.Online;
 using osu.Game.Online.Chat;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Utils;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
@@ -303,9 +301,7 @@ namespace osu.Game.Screens.SelectV2
 
                 Ruleset rulesetInstance = ruleset.Value.CreateInstance();
 
-                double rate = ModUtils.CalculateRateWithMods(mods.Value);
-
-                adjustedDifficulty = rulesetInstance.GetRateAdjustedDisplayDifficulty(adjustedDifficulty, rate);
+                adjustedDifficulty = rulesetInstance.GetAdjustedDisplayDifficulty(adjustedDifficulty, mods.Value);
                 difficultyStatisticsDisplay.TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
 
                 StatisticDifficulty.Data firstStatistic;
@@ -322,20 +318,20 @@ namespace osu.Game.Screens.SelectV2
                         // - Using the difficulty adjustment mod to adjust OD doesn't have an effect on conversion.
                         int keyCount = legacyRuleset.GetKeyCount(beatmap.Value.BeatmapInfo, mods.Value);
 
-                        firstStatistic = new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsCsMania, keyCount, keyCount, 10);
+                        firstStatistic = new StatisticDifficulty.Data(SongSelectStrings.KeyCount, keyCount, keyCount, 10);
                         break;
 
                     default:
-                        firstStatistic = new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsCs, originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
+                        firstStatistic = new StatisticDifficulty.Data(SongSelectStrings.CircleSize, originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
                         break;
                 }
 
                 difficultyStatisticsDisplay.Statistics = new[]
                 {
                     firstStatistic,
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsAr, originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate, 10),
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsAccuracy, originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10),
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsDrain, originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.ApproachRate, originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.Accuracy, originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.HPDrain, originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10),
                 };
             });
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
index b533d21c1e..d0b6acca88 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
@@ -98,10 +98,11 @@ namespace osu.Game.Screens.SelectV2
                                 },
                             },
                         },
-                        labelText = new OsuSpriteText
+                        labelText = new TruncatingSpriteText
                         {
                             Margin = new MarginPadding { Top = 2f },
                             Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                            MaxWidth = 85,
                         },
                         new FillFlowContainer
                         {
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
index 28a6bfc83a..a6a54eeade 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -227,8 +226,7 @@ namespace osu.Game.Screens.SelectV2
             var beatmap = (BeatmapInfo)Item.Model;
             var beatmapSet = beatmap.BeatmapSet!;
 
-            // Choice of background image matches BSS implementation (always uses the lowest `beatmap_id` from the set).
-            background.Beatmap = beatmaps.GetWorkingBeatmap(beatmapSet.Beatmaps.MinBy(b => b.OnlineID));
+            background.Beatmap = beatmaps.GetWorkingBeatmap(beatmap);
 
             titleText.Text = new RomanisableString(beatmapSet.Metadata.TitleUnicode, beatmapSet.Metadata.Title);
             artistText.Text = new RomanisableString(beatmapSet.Metadata.ArtistUnicode, beatmapSet.Metadata.Artist);
diff --git a/osu.Game/Screens/SelectV2/SoloSongSelect.cs b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
index 4c4df7f389..2b0ff66f91 100644
--- a/osu.Game/Screens/SelectV2/SoloSongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
@@ -84,7 +84,9 @@ namespace osu.Game.Screens.SelectV2
             {
                 Icon = FontAwesome.Solid.Eraser
             };
-            yield return new OsuMenuItem(WebCommonStrings.ButtonsHide.ToSentence(), MenuItemType.Destructive, () => beatmaps.Hide(beatmap));
+
+            if (beatmaps.CanHide(beatmap))
+                yield return new OsuMenuItem(WebCommonStrings.ButtonsHide.ToSentence(), MenuItemType.Destructive, () => beatmaps.Hide(beatmap));
         }
 
         protected override void OnStart()
diff --git a/osu.Game/Screens/SelectV2/SongSelect.cs b/osu.Game/Screens/SelectV2/SongSelect.cs
index 8030290aab..c4d12844eb 100644
--- a/osu.Game/Screens/SelectV2/SongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -163,15 +163,9 @@ namespace osu.Game.Screens.SelectV2
                                     Width = 0.6f,
                                     Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.3f), Color4.Black.Opacity(0f)),
                                 },
-                                new GridContainer // used for max width implementation
+                                mainGridContainer = new GridContainer // used for max width implementation
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    ColumnDimensions = new[]
-                                    {
-                                        new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 700),
-                                        new Dimension(),
-                                        new Dimension(GridSizeMode.Relative, 0.5f, minSize: 500, maxSize: 900),
-                                    },
                                     Content = new[]
                                     {
                                         new[]
@@ -244,7 +238,7 @@ namespace osu.Game.Screens.SelectV2
                                                                 RelativeSizeAxes = Axes.Both,
                                                                 RequestPresentBeatmap = b => SelectAndRun(b, OnStart),
                                                                 RequestSelection = queueBeatmapSelection,
-                                                                RequestRecommendedSelection = b => queueBeatmapSelection(difficultyRecommender?.GetRecommendedBeatmap(b) ?? b.First()),
+                                                                RequestRecommendedSelection = requestRecommendedSelection,
                                                                 NewItemsPresented = newItemsPresented,
                                                             },
                                                             noResultsPlaceholder = new NoResultsPlaceholder
@@ -288,6 +282,11 @@ namespace osu.Game.Screens.SelectV2
             });
         }
 
+        private void requestRecommendedSelection(IEnumerable<BeatmapInfo> b)
+        {
+            queueBeatmapSelection(difficultyRecommender?.GetRecommendedBeatmap(b) ?? b.First());
+        }
+
         /// <summary>
         /// Called when a selection is made to progress away from the song select screen.
         ///
@@ -354,6 +353,15 @@ namespace osu.Game.Screens.SelectV2
             base.Update();
 
             detailsArea.Height = wedgesContainer.DrawHeight - titleWedge.LayoutSize.Y - 4;
+
+            float widescreenBonusWidth = Math.Max(0, DrawWidth / DrawHeight - 2f);
+
+            mainGridContainer.ColumnDimensions = new[]
+            {
+                new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 700 + widescreenBonusWidth * 100),
+                new Dimension(),
+                new Dimension(GridSizeMode.Relative, 0.5f, minSize: 500, maxSize: 700 + widescreenBonusWidth * 300),
+            };
         }
 
         #region Audio
@@ -502,16 +510,39 @@ namespace osu.Game.Screens.SelectV2
             var currentBeatmap = beatmaps.GetWorkingBeatmap(Beatmap.Value.BeatmapInfo, true);
             bool validSelection = checkBeatmapValidForSelection(currentBeatmap.BeatmapInfo, filterControl.CreateCriteria());
 
-            if (Beatmap.IsDefault || !validSelection)
+            if (validSelection)
+            {
+                carousel.CurrentSelection = currentBeatmap.BeatmapInfo;
+                return true;
+            }
+
+            // If there was no beatmap selected, pick a random one.
+            if (Beatmap.IsDefault)
             {
                 validSelection = carousel.NextRandom();
                 finaliseBeatmapSelection();
+                return validSelection;
             }
 
-            if (validSelection)
-                carousel.CurrentSelection = Beatmap.Value.BeatmapInfo;
-            else
-                Beatmap.SetDefault();
+            // If a previous non-default selection became non-valid, it was likely hidden or deleted.
+            if (!validSelection)
+            {
+                // In the case a difficulty was hidden or removed, prefer selecting another difficulty from the same set.
+                var activeSet = currentBeatmap.BeatmapSetInfo;
+                var criteria = filterControl.CreateCriteria();
+
+                var validBeatmaps = activeSet.Beatmaps.Where(b => checkBeatmapValidForSelection(b, criteria)).ToArray();
+
+                if (validBeatmaps.Any())
+                {
+                    requestRecommendedSelection(validBeatmaps);
+                    return true;
+                }
+            }
+
+            // If all else fails, use the default beatmap.
+            Beatmap.SetDefault();
+            finaliseBeatmapSelection();
 
             return validSelection;
         }
@@ -777,6 +808,8 @@ namespace osu.Game.Screens.SelectV2
 
         private ScheduledDelegate? revealingBackground;
 
+        private GridContainer mainGridContainer = null!;
+
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             var containingInputManager = GetContainingInputManager();
diff --git a/osu.Game/Skinning/Components/BeatmapAttributeText.cs b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
index 58821f869a..60a03f4351 100644
--- a/osu.Game/Skinning/Components/BeatmapAttributeText.cs
+++ b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
@@ -243,10 +243,7 @@ namespace osu.Game.Skinning.Components
                     mod.ApplyToDifficulty(difficulty);
 
                 if (ruleset.Value is RulesetInfo rulesetInfo)
-                {
-                    double rate = ModUtils.CalculateRateWithMods(mods.Value);
-                    difficulty = rulesetInfo.CreateInstance().GetRateAdjustedDisplayDifficulty(difficulty, rate);
-                }
+                    difficulty = rulesetInfo.CreateInstance().GetAdjustedDisplayDifficulty(difficulty, mods.Value);
 
                 return difficulty;
             }
diff --git a/osu.Game/Skinning/EzStyleProSkin.cs b/osu.Game/Skinning/EzStyleProSkin.cs
index 8b8a919b39..56224a24ca 100644
--- a/osu.Game/Skinning/EzStyleProSkin.cs
+++ b/osu.Game/Skinning/EzStyleProSkin.cs
@@ -54,7 +54,17 @@ namespace osu.Game.Skinning
 
         public override ISample? GetSample(ISampleInfo sampleInfo)
         {
-            return Resources.AudioManager?.Samples.Get("Gameplay/Ez/hit.wav");
+            foreach (string lookup in sampleInfo.LookupNames)
+            {
+                var sample = Samples?.Get(lookup)
+                             ?? Resources.AudioManager?.Samples.Get(lookup.Replace(@"Gameplay/", @"Gameplay/Ez/"))
+                             ?? Resources.AudioManager?.Samples.Get(lookup);
+
+                if (sample != null)
+                    return sample;
+            }
+
+            return null;
         }
 
         public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
diff --git a/osu.Game/Skinning/SkinImporter.cs b/osu.Game/Skinning/SkinImporter.cs
index 382a7b56c2..3a50fb9f9a 100644
--- a/osu.Game/Skinning/SkinImporter.cs
+++ b/osu.Game/Skinning/SkinImporter.cs
@@ -157,17 +157,17 @@ namespace osu.Game.Skinning
             // Regardless of whether this is an import or not, let's write the skin.ini if non-existing or non-matching.
             // This is (weirdly) done inside ComputeHash to avoid adding a new method to handle this case. After switching to realm it can be moved into another place.
             if (skinIniSourcedName != item.Name)
-                updateSkinIniMetadata(item, realm);
+                UpdateSkinIniMetadata(item, realm);
         }
 
-        private void updateSkinIniMetadata(SkinInfo item, Realm realm)
+        public void UpdateSkinIniMetadata(SkinInfo item, Realm realm)
         {
             string nameLine = @$"Name: {item.Name}";
             string authorLine = @$"Author: {item.Creator}";
 
             List<string> newLines = new List<string>
             {
-                @"// The following content was automatically added by osu! during import, based on filename / folder metadata.",
+                @"// The following content was automatically added by osu! in order to use metadata that more closely matches user expectations.",
                 @"[General]",
                 nameLine,
                 authorLine,
diff --git a/osu.Game/Skinning/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 77d6155c9c..db92f84ed6 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -352,6 +352,15 @@ namespace osu.Game.Skinning
             });
         }
 
+        public void Rename(Live<SkinInfo> skin, string newName)
+        {
+            skin.PerformWrite(s =>
+            {
+                s.Name = newName;
+                skinImporter.UpdateSkinIniMetadata(s, s.Realm!);
+            });
+        }
+
         public void SetSkinFromConfiguration(string guidString)
         {
             Live<SkinInfo> skinInfo = null;
diff --git a/osu.Game/Tests/Visual/OsuGameTestScene.cs b/osu.Game/Tests/Visual/OsuGameTestScene.cs
index b86273b4a3..fb229194d9 100644
--- a/osu.Game/Tests/Visual/OsuGameTestScene.cs
+++ b/osu.Game/Tests/Visual/OsuGameTestScene.cs
@@ -82,10 +82,11 @@ namespace osu.Game.Tests.Visual
         [TearDownSteps]
         public virtual void TearDownSteps()
         {
-            if (DebugUtils.IsNUnitRunning && Game != null)
+            if (DebugUtils.IsNUnitRunning)
             {
-                AddStep("exit game", () => Game.Exit());
-                AddUntilStep("wait for game exit", () => Game.Parent == null);
+                AddStep("exit game", () => Game?.Exit());
+                AddUntilStep("wait for game exit", () => Game?.Parent == null);
+                AddStep("dispose game", () => Game?.Dispose());
             }
         }
 
diff --git a/osu.Game/Updater/UpdateManager.cs b/osu.Game/Updater/UpdateManager.cs
index 335f6085a9..c74adc7ee2 100644
--- a/osu.Game/Updater/UpdateManager.cs
+++ b/osu.Game/Updater/UpdateManager.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -10,9 +11,11 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Logging;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Localisation;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Utils;
@@ -56,15 +59,26 @@ namespace osu.Game.Updater
             string version = game.Version;
             string lastVersion = config.Get<string>(OsuSetting.Version);
 
-            if (game.IsDeployedBuild && version != lastVersion)
+            if (game.IsDeployedBuild)
             {
                 // only show a notification if we've previously saved a version to the config file (ie. not the first run).
-                if (!string.IsNullOrEmpty(lastVersion))
+                if (!string.IsNullOrEmpty(lastVersion) && version != lastVersion)
                     Notifications.Post(new UpdateCompleteNotification(version));
 
+                // make sure the release stream setting matches the build which was just run.
+                if (FixedReleaseStream != null)
+                    config.SetValue(OsuSetting.ReleaseStream, FixedReleaseStream.Value);
+
+                // notify the user if they're using a build that is not officially sanctioned.
                 if (RuntimeInfo.EntryAssembly.GetCustomAttribute<OfficialBuildAttribute>() == null)
                     Notifications.Post(new SimpleNotification { Text = NotificationsStrings.NotOfficialBuild });
             }
+            else
+            {
+                // log that this is not an official build, for if users build their own game without an assembly version.
+                // this is only logged because a notification would be too spammy in local test builds.
+                Logger.Log(NotificationsStrings.NotOfficialBuild.ToString());
+            }
 
             // debug / local compilations will reset to a non-release string.
             // can be useful to check when an install has transitioned between release and otherwise (see OsuConfigManager's migrations).
@@ -81,13 +95,16 @@ namespace osu.Game.Updater
         /// </summary>
         public void CheckForUpdate()
         {
-            _ = CheckForUpdateAsync();
+            CheckForUpdateAsync().FireAndForget();
         }
 
         /// <summary>
         /// Immediately checks for any available update.
         /// </summary>
-        /// <returns><c>true</c> if any updates are available, <c>false</c> otherwise.</returns>
+        /// <returns>
+        /// <c>true</c> if any updates are available, <c>false</c> otherwise.
+        /// May return true if an error occured (there is potentially an update available).
+        /// </returns>
         public async Task<bool> CheckForUpdateAsync(CancellationToken cancellationToken = default) => await Task.Run(async () =>
         {
             if (!CanCheckForUpdate)
@@ -99,7 +116,15 @@ namespace osu.Game.Updater
             using (var lastCts = Interlocked.Exchange(ref updateCancellationSource, cts))
                 await lastCts.CancelAsync().ConfigureAwait(false);
 
-            return await PerformUpdateCheck(cts.Token).ConfigureAwait(false);
+            try
+            {
+                return await PerformUpdateCheck(cts.Token).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Logger.Log($"{nameof(PerformUpdateCheck)} failed ({e.Message})");
+                return true;
+            }
         }, cancellationToken).ConfigureAwait(false);
 
         /// <summary>
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index d1f3d3f107..1caee62c43 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -40,7 +40,6 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="20.1.0" />
-<!--    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.605.0" />-->
     <PackageReference Include="Sentry" Version="5.1.1" />
     <!-- Held back due to 0.34.0 failing AOT compilation on ZstdSharp.dll dependency. -->
     <PackageReference Include="SharpCompress" Version="0.39.0" />
@@ -48,13 +47,14 @@
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.10" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     <PackageReference Include="TagLibSharp" Version="2.3.0" />
-    <ProjectReference Include="..\..\osu-resources\osu.Game.Resources\osu.Game.Resources.csproj" />
+
     <!-- Required since Veldrid references a library that depends on Microsoft.DotNet.PlatformAbstractions (2.0.3), which doesn't play nice with Realm. -->
     <PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
     <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
     <PackageReference Include="System.Runtime.Handles" Version="4.3.0" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\osu-resources\osu.Game.Resources\osu.Game.Resources.csproj" />
     <ProjectReference Include="..\..\osu-framework\osu.Framework\osu.Framework.csproj" />
   </ItemGroup>
 </Project>
diff --git a/osu.iOS.props b/osu.iOS.props
index bb5e3da49e..99eed6c204 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -17,6 +17,6 @@
     <MtouchInterpreter>-all</MtouchInterpreter>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.704.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.718.0" />
   </ItemGroup>
 </Project>
diff --git a/osu.sln b/osu.sln
index 3878444d1c..f5f1560598 100644
--- a/osu.sln
+++ b/osu.sln
@@ -105,10 +105,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "osu.Framework", "..\osu-fra
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "osu.Framework.NativeLibs", "..\osu-framework\osu.Framework.NativeLibs\osu.Framework.NativeLibs.csproj", "{F5037F74-E137-4940-8CE7-4D3E5DF0FB39}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "osu.Framework.Android", "..\osu-framework\osu.Framework.Android\osu.Framework.Android.csproj", "{5ABDA3A9-BDAD-48A2-945E-EF78228FD5FC}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "osu.Framework.iOS", "..\osu-framework\osu.Framework.iOS\osu.Framework.iOS.csproj", "{335CB301-EB9C-4108-A353-CD68AFA200AA}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -160,13 +156,13 @@ Global
 		{6A2D5D58-0261-4A75-BE84-2BE8B076B7C2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6A2D5D58-0261-4A75-BE84-2BE8B076B7C2}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5672CA4D-1B37-425B-A118-A8DA26E78938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5672CA4D-1B37-425B-A118-A8DA26E78938}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5672CA4D-1B37-425B-A118-A8DA26E78938}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5672CA4D-1B37-425B-A118-A8DA26E78938}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5672CA4D-1B37-425B-A118-A8DA26E78938}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5789E78D-38F9-4072-AB7B-978F34B2C17F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5789E78D-38F9-4072-AB7B-978F34B2C17F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5789E78D-38F9-4072-AB7B-978F34B2C17F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5789E78D-38F9-4072-AB7B-978F34B2C17F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5789E78D-38F9-4072-AB7B-978F34B2C17F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3F082D0B-A964-43D7-BDF7-C256D76A50D0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3F082D0B-A964-43D7-BDF7-C256D76A50D0}.Release|Any CPU.Build.0 = Release|Any CPU
 		{3F082D0B-A964-43D7-BDF7-C256D76A50D0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
@@ -232,35 +228,27 @@ Global
 		{93632F2D-2BB4-46C1-A7B8-F8CF2FB27118}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{93632F2D-2BB4-46C1-A7B8-F8CF2FB27118}.Release|Any CPU.Build.0 = Release|Any CPU
 		{9014CA66-5217-49F6-8C1E-3430FD08EF61}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9014CA66-5217-49F6-8C1E-3430FD08EF61}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9014CA66-5217-49F6-8C1E-3430FD08EF61}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9014CA66-5217-49F6-8C1E-3430FD08EF61}.Release|Any CPU.Build.0 = Release|Any CPU
 		{561DFD5E-5896-40D1-9708-4D692F5BAE66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{561DFD5E-5896-40D1-9708-4D692F5BAE66}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{561DFD5E-5896-40D1-9708-4D692F5BAE66}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{561DFD5E-5896-40D1-9708-4D692F5BAE66}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B325271C-85E7-4DB3-8BBB-B70F242954F8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B325271C-85E7-4DB3-8BBB-B70F242954F8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B325271C-85E7-4DB3-8BBB-B70F242954F8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B325271C-85E7-4DB3-8BBB-B70F242954F8}.Release|Any CPU.Build.0 = Release|Any CPU
 		{4C834F7F-07CA-46C7-8C7B-F10A1B3BC738}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4C834F7F-07CA-46C7-8C7B-F10A1B3BC738}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4C834F7F-07CA-46C7-8C7B-F10A1B3BC738}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4C834F7F-07CA-46C7-8C7B-F10A1B3BC738}.Release|Any CPU.Build.0 = Release|Any CPU
 		{AD923016-F318-49B7-B08B-89DED6DC2422}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{AD923016-F318-49B7-B08B-89DED6DC2422}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AD923016-F318-49B7-B08B-89DED6DC2422}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{AD923016-F318-49B7-B08B-89DED6DC2422}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B9B92246-02EB-4118-9C6F-85A0D726AA70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B9B92246-02EB-4118-9C6F-85A0D726AA70}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B9B92246-02EB-4118-9C6F-85A0D726AA70}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B9B92246-02EB-4118-9C6F-85A0D726AA70}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B9022390-8184-4548-9DB1-50EB8878D20A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B9022390-8184-4548-9DB1-50EB8878D20A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B9022390-8184-4548-9DB1-50EB8878D20A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B9022390-8184-4548-9DB1-50EB8878D20A}.Release|Any CPU.Build.0 = Release|Any CPU
 		{1743BF7C-E6AE-4A06-BAD9-166D62894303}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1743BF7C-E6AE-4A06-BAD9-166D62894303}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1743BF7C-E6AE-4A06-BAD9-166D62894303}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1743BF7C-E6AE-4A06-BAD9-166D62894303}.Release|Any CPU.Build.0 = Release|Any CPU
 		{18ED4ABC-6064-46F1-9A05-4E0BE88A635A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
@@ -275,14 +263,6 @@ Global
 		{F5037F74-E137-4940-8CE7-4D3E5DF0FB39}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F5037F74-E137-4940-8CE7-4D3E5DF0FB39}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F5037F74-E137-4940-8CE7-4D3E5DF0FB39}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5ABDA3A9-BDAD-48A2-945E-EF78228FD5FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5ABDA3A9-BDAD-48A2-945E-EF78228FD5FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5ABDA3A9-BDAD-48A2-945E-EF78228FD5FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5ABDA3A9-BDAD-48A2-945E-EF78228FD5FC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{335CB301-EB9C-4108-A353-CD68AFA200AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{335CB301-EB9C-4108-A353-CD68AFA200AA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{335CB301-EB9C-4108-A353-CD68AFA200AA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{335CB301-EB9C-4108-A353-CD68AFA200AA}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE