diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f041f2e916..7dfe3d11c2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -131,7 +131,7 @@ jobs:
 
   build-only-ios:
     name: Build only (iOS)
-    runs-on: macos-latest
+    runs-on: macos-15
     timeout-minutes: 60
     steps:
       - name: Checkout
@@ -143,7 +143,12 @@ jobs:
           dotnet-version: "8.0.x"
 
       - name: Install .NET Workloads
-        run: dotnet workload install ios --from-rollback-file https://raw.githubusercontent.com/ppy/osu-framework/refs/heads/master/workloads.json
+        run: dotnet workload install ios
+
+      # https://github.com/dotnet/macios/issues/19157
+      # https://github.com/actions/runner-images/issues/12758
+      - name: Use Xcode 16.4
+        run: sudo xcode-select -switch /Applications/Xcode_16.4.app
 
       - name: Build
         run: dotnet build -c Debug osu.iOS.slnf
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..5d9158a45a 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.903.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/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/Program.cs b/osu.Desktop/Program.cs
index 50d0f06150..612edb2470 100644
--- a/osu.Desktop/Program.cs
+++ b/osu.Desktop/Program.cs
@@ -36,7 +36,7 @@ namespace osu.Desktop
             // IMPORTANT DON'T IGNORE: For general sanity, velopack's setup needs to run before anything else.
             // This has bitten us in the rear before (bricked updater), and although the underlying issue from
             // last time has been fixed, let's not tempt fate.
-            setupVelopack();
+            setupVelopack(args);
 
             if (OperatingSystem.IsWindows())
             {
@@ -174,8 +174,21 @@ namespace osu.Desktop
             return false;
         }
 
-        private static void setupVelopack()
+        private static void setupVelopack(string[] args)
         {
+            // Arguments being present indicate the user is either starting the game in a special (aka tournament) mode,
+            // or is running with pending imports via file association or otherwise.
+            //
+            // In both these scenarios, we'd hope the game does not attempt to update.
+            //
+            // Special consideration for velopack startup arguments, which must be handled during update.
+            // See https://docs.velopack.io/integrating/hooks#command-line-hooks.
+            if (args.Length > 0 && !args[0].StartsWith("--velo", StringComparison.Ordinal))
+            {
+                Logger.Log("Handling arguments, skipping velopack setup.");
+                return;
+            }
+
             if (OsuGameDesktop.IsPackageManaged)
             {
                 Logger.Log("Updates are being managed by an external provider. Skipping Velopack setup.");
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/lazer.ico b/osu.Desktop/lazer.ico
index d5dbf933c1..64f75df256 100644
Binary files a/osu.Desktop/lazer.ico and b/osu.Desktop/lazer.ico differ
diff --git a/osu.Desktop/osu!.res b/osu.Desktop/osu!.res
deleted file mode 100644
index 7c70e30401..0000000000
Binary files a/osu.Desktop/osu!.res and /dev/null differ
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..3af581fcf3 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
 {
@@ -21,8 +22,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
         }
@@ -32,8 +34,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModHalfTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
         }
@@ -43,8 +46,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             var ruleset = new CatchRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new CatchModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(7.67).Within(0.01));
         }
diff --git a/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModMovingFast.cs b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModMovingFast.cs
new file mode 100644
index 0000000000..85f02d49cb
--- /dev/null
+++ b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModMovingFast.cs
@@ -0,0 +1,21 @@
+// 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 NUnit.Framework;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    public partial class TestSceneCatchModMovingFast : ModTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+
+        [Test]
+        public void TestMovingFast() => CreateModTest(new ModTestData
+        {
+            Mod = new CatchModMovingFast(),
+            PassCondition = () => true
+        });
+    }
+}
diff --git a/osu.Game.Rulesets.Catch/CatchRuleset.cs b/osu.Game.Rulesets.Catch/CatchRuleset.cs
index d253b9893f..02d266228a 100644
--- a/osu.Game.Rulesets.Catch/CatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/CatchRuleset.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -11,6 +12,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Catch.Edit;
@@ -25,6 +27,7 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Scoring.Legacy;
@@ -33,6 +36,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
@@ -150,6 +154,7 @@ namespace osu.Game.Rulesets.Catch
                         new CatchModFloatingFruits(),
                         new CatchModMuted(),
                         new CatchModNoScope(),
+                        new CatchModMovingFast(),
                     };
 
                 case ModType.System:
@@ -265,9 +270,10 @@ namespace osu.Game.Rulesets.Catch
         }
 
         /// <seealso cref="CatchHitObject.ApplyDefaultsToSelf"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
         {
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, CatchHitObject.PREEMPT_MAX, CatchHitObject.PREEMPT_MID, CatchHitObject.PREEMPT_MIN);
             preempt /= rate;
@@ -276,6 +282,33 @@ namespace osu.Game.Rulesets.Catch
             return adjustedDifficulty;
         }
 
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            var effectiveDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.CircleSize, @"CS", originalDifficulty.CircleSize, effectiveDifficulty.CircleSize, 10)
+            {
+                Description = "Affects the size of fruits.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Hit circle radius", (CatchHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(effectiveDifficulty.CircleSize)).ToLocalisableString("0.#"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ApproachRate, @"AR", originalDifficulty.ApproachRate, effectiveDifficulty.ApproachRate, 10)
+            {
+                Description = "Affects how early fruits fade in on the screen.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Fade-in time", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(effectiveDifficulty.ApproachRate, CatchHitObject.PREEMPT_RANGE):#,0.##} ms"))
+                ]
+            };
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, effectiveDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
         public override bool EditorShowScrollSpeed => false;
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs b/osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs
index 374ab16633..0783ec72e9 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs
@@ -18,6 +18,9 @@ namespace osu.Game.Rulesets.Catch.Edit
             new CheckBananaShowerGap(),
             new CheckConcurrentObjects(),
 
+            // Spread
+            new CheckCatchLowestDiffDrainTime(),
+
             // Settings
             new CheckCatchAbnormalDifficultySettings(),
         };
diff --git a/osu.Game.Rulesets.Catch/Edit/Checks/CheckBananaShowerGap.cs b/osu.Game.Rulesets.Catch/Edit/Checks/CheckBananaShowerGap.cs
index 4b2933c0e1..8e4fe3d3c2 100644
--- a/osu.Game.Rulesets.Catch/Edit/Checks/CheckBananaShowerGap.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Checks/CheckBananaShowerGap.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
             (int expectedStartDelta, int expectedEndDelta) = spinner_delta_threshold[context.InterpretedDifficulty];
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
diff --git a/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs b/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs
index d2c3df0872..cb1d5fd9cb 100644
--- a/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))
diff --git a/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchLowestDiffDrainTime.cs b/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchLowestDiffDrainTime.cs
new file mode 100644
index 0000000000..960469112f
--- /dev/null
+++ b/osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchLowestDiffDrainTime.cs
@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Catch.Edit.Checks
+{
+    public class CheckCatchLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21catch#general
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 2, 30).TotalMilliseconds, "Platter");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 3, 15).TotalMilliseconds, "Rain");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 4, 0).TotalMilliseconds, "Overdose");
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModAutoplay.cs b/osu.Game.Rulesets.Catch/Mods/CatchModAutoplay.cs
index 50e48101d3..5d8cfa7997 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModAutoplay.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModAutoplay.cs
@@ -1,7 +1,9 @@
 // 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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
@@ -10,6 +12,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModAutoplay : ModAutoplay
     {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
     }
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModCinema.cs b/osu.Game.Rulesets.Catch/Mods/CatchModCinema.cs
index 7eda6b37d3..f3a4be156b 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModCinema.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModCinema.cs
@@ -1,7 +1,9 @@
 // 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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -11,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModCinema : ModCinema<CatchHitObject>
     {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new ModReplayData(new CatchAutoGenerator(beatmap).Generate(), new ModCreatedUser { Username = "osu!salad" });
     }
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModFlashlight.cs b/osu.Game.Rulesets.Catch/Mods/CatchModFlashlight.cs
index 40450c6729..a5308f4cde 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModFlashlight.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModFlashlight.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 
         public override BindableBool ComboBasedSize { get; } = new BindableBool(true);
 
-        public override float DefaultFlashlightSize => 325;
+        public override float DefaultFlashlightSize => 203.125f;
 
         protected override Flashlight CreateFlashlight() => new CatchFlashlight(this, playfield);
 
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModFloatingFruits.cs b/osu.Game.Rulesets.Catch/Mods/CatchModFloatingFruits.cs
index f933b9a28f..88f26bfd63 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModFloatingFruits.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModFloatingFruits.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
@@ -16,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override string Acronym => "FF";
         public override LocalisableString Description => "The fruits are... floating?";
         public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon => FontAwesome.Solid.Cloud;
+        public override IconUsage? Icon => OsuIcon.ModFloatingFruits;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
         {
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModMovingFast.cs b/osu.Game.Rulesets.Catch/Mods/CatchModMovingFast.cs
new file mode 100644
index 0000000000..4612ed62ac
--- /dev/null
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModMovingFast.cs
@@ -0,0 +1,82 @@
+// 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.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    public partial class CatchModMovingFast : Mod, IApplicableToDrawableRuleset<CatchHitObject>, IApplicableToPlayer
+    {
+        public override string Name => "Moving Fast";
+        public override string Acronym => "MF";
+        public override LocalisableString Description => "Dashing by default, slow down!";
+        public override ModType Type => ModType.Fun;
+        public override double ScoreMultiplier => 1;
+        public override IconUsage? Icon => OsuIcon.ModMovingFast;
+        public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
+
+        private DrawableCatchRuleset drawableRuleset = null!;
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
+        {
+            this.drawableRuleset = (DrawableCatchRuleset)drawableRuleset;
+        }
+
+        public void ApplyToPlayer(Player player)
+        {
+            if (!drawableRuleset.HasReplayLoaded.Value)
+            {
+                var catchPlayfield = (CatchPlayfield)drawableRuleset.Playfield;
+                catchPlayfield.Catcher.Dashing = true;
+                catchPlayfield.CatcherArea.Add(new InvertDashInputHelper(catchPlayfield.CatcherArea));
+            }
+        }
+
+        private partial class InvertDashInputHelper : Drawable, IKeyBindingHandler<CatchAction>
+        {
+            private readonly CatcherArea catcherArea;
+
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
+            public InvertDashInputHelper(CatcherArea catcherArea)
+            {
+                this.catcherArea = catcherArea;
+
+                RelativeSizeAxes = Axes.Both;
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<CatchAction> e)
+            {
+                switch (e.Action)
+                {
+                    case CatchAction.MoveLeft or CatchAction.MoveRight:
+                        break;
+
+                    case CatchAction.Dash:
+                        catcherArea.Catcher.Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<CatchAction> e)
+            {
+                if (e.Action == CatchAction.Dash)
+                    catcherArea.Catcher.Dashing = true;
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModRelax.cs b/osu.Game.Rulesets.Catch/Mods/CatchModRelax.cs
index 83ad96d5b4..194f66815b 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModRelax.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModRelax.cs
@@ -1,6 +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.
 
+using System;
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
@@ -19,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.Mods
     {
         public override LocalisableString Description => @"Use the mouse to control the catcher.";
 
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(CatchModMovingFast) }).ToArray();
+
         private DrawableCatchRuleset drawableRuleset = null!;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
diff --git a/osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs b/osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs
index deaa566864..41deaa0d82 100644
--- a/osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs
+++ b/osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs
@@ -150,7 +150,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_RANGE);
 
             Scale = LegacyRulesetExtensions.CalculateScaleFromCircleSize(difficulty.CircleSize);
         }
@@ -203,6 +203,8 @@ namespace osu.Game.Rulesets.Catch.Objects
         /// </summary>
         public const double PREEMPT_MAX = 1800;
 
+        public static readonly DifficultyRange PREEMPT_RANGE = new DifficultyRange(PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+
         /// <summary>
         /// The Y position of the hit object is not used in the normal osu!catch gameplay.
         /// It is preserved to maximize the backward compatibility with the legacy editor, in which the mappers use the Y position to organize the patterns.
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs
index 5af2af9314..731263b25c 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs
@@ -55,6 +55,16 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
             });
         }
 
+        [Test]
+        public void TestHoldNotesAlmostConcurrentOnSameColumn()
+        {
+            assertAlmostConcurrentSame(new List<HitObject>
+            {
+                createHoldNote(startTime: 100, endTime: 400.75d, column: 1),
+                createHoldNote(startTime: 408, endTime: 700.75d, column: 1)
+            });
+        }
+
         private void assertOk(List<HitObject> hitobjects)
         {
             Assert.That(check.Run(getContext(hitobjects)), Is.Empty);
@@ -65,7 +75,17 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
             var issues = check.Run(getContext(hitobjects)).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(count));
-            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here")));
+        }
+
+        private void assertAlmostConcurrentSame(List<HitObject> hitobjects)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart")));
         }
 
         private BeatmapVerifierContext getContext(List<HitObject> hitobjects)
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapSampleConversionTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapSampleConversionTest.cs
index 99598557a6..b4f084a07c 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapSampleConversionTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapSampleConversionTest.cs
@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         [TestCase("convert-samples")]
         [TestCase("mania-samples")]
+        [TestCase("mania-slider")] // e.g. second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407
         [TestCase("slider-convert-samples")]
         public void Test(string name) => base.Test(name);
 
@@ -32,6 +33,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 StartTime = hitObject.StartTime,
                 EndTime = hitObject.GetEndTime(),
                 Column = ((ManiaHitObject)hitObject).Column,
+                PlaySlidingSamples = hitObject is HoldNote holdNote && holdNote.PlaySlidingSamples,
                 Samples = getSampleNames(hitObject.Samples),
                 NodeSamples = getNodeSampleNames((hitObject as HoldNote)?.NodeSamples)
             };
@@ -57,12 +59,14 @@ namespace osu.Game.Rulesets.Mania.Tests
         public double StartTime;
         public double EndTime;
         public int Column;
+        public bool PlaySlidingSamples;
         public IList<string> Samples;
         public IList<IList<string>> NodeSamples;
 
         public bool Equals(SampleConvertValue other)
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
+               && PlaySlidingSamples == other.PlaySlidingSamples
                && samplesEqual(Samples, other.Samples)
                && nodeSamplesEqual(NodeSamples, other.NodeSamples);
 
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
index 24da447482..ad3cf4e05f 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestFilterIntersection()
+        public void TestKeysFilterIntersection()
         {
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestInvalidFilters()
+        public void TestInvalidKeysFilters()
         {
             var criteria = new ManiaFilterCriteria();
 
@@ -183,5 +183,132 @@ namespace osu.Game.Rulesets.Mania.Tests
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
         }
+
+        [TestCase]
+        public void TestLnsEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsGreaterOrEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsNotManiaRuleset()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.LessOrEqual, "100");
+            BeatmapInfo beatmapInfo = new BeatmapInfo
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 50
+            };
+            Assert.False(criteria.Matches(beatmapInfo, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestInvalidLnsFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json
index 4d298bb671..273dd33452 100644
--- a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json
+++ b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json
@@ -5,6 +5,7 @@
       "StartTime": 1000.0,
       "EndTime": 2750.0,
       "Column": 1,
+      "PlaySlidingSamples": true,
       "NodeSamples": [
         ["Gameplay/normal-hitnormal"],
         ["Gameplay/soft-hitnormal"],
@@ -15,6 +16,7 @@
       "StartTime": 1875.0,
       "EndTime": 2750.0,
       "Column": 0,
+      "PlaySlidingSamples": true,
       "NodeSamples": [
         ["Gameplay/soft-hitnormal"],
         ["Gameplay/drum-hitnormal"]
diff --git a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-samples-expected-conversion.json b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-samples-expected-conversion.json
index fd0c0cad60..eb0c5df10b 100644
--- a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-samples-expected-conversion.json
+++ b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-samples-expected-conversion.json
@@ -5,6 +5,7 @@
       "StartTime": 500.0,
       "EndTime": 1500.0,
       "Column": 0,
+      "PlaySlidingSamples": false,
       "NodeSamples": [
         ["Gameplay/normal-hitnormal"],
         []
@@ -17,6 +18,7 @@
       "StartTime": 2000.0,
       "EndTime": 3000.0,
       "Column": 2,
+      "PlaySlidingSamples": false,
       "NodeSamples": [
         ["Gameplay/drum-hitnormal"],
         []
diff --git a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider-expected-conversion.json b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider-expected-conversion.json
new file mode 100644
index 0000000000..bf097f589e
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider-expected-conversion.json
@@ -0,0 +1,18 @@
+{
+  "Mappings": [{
+    "StartTime": 500.0,
+    "Objects": [{
+      "StartTime": 500.0,
+      "EndTime": 2500,
+      "Column": 2,
+      "PlaySlidingSamples": true,
+      "NodeSamples": [
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"],
+        ["Gameplay/soft-hitnormal"]
+      ],
+      "Samples": ["Gameplay/soft-hitnormal"]
+    }]
+  }]
+}
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider.osu b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider.osu
new file mode 100644
index 0000000000..c6e44ab9bf
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/Resources/Testing/Beatmaps/mania-slider.osu
@@ -0,0 +1,29 @@
+osu file format v5
+
+[General]
+StackLeniency: 0.7
+Mode: 3
+
+[Difficulty]
+HPDrainRate:2
+CircleSize:5
+OverallDifficulty:2
+SliderMultiplier:1
+SliderTickRate:2
+
+[Events]
+//Background and Video events
+//Break Periods
+//Storyboard Layer 0 (Background)
+//Storyboard Layer 1 (Failing)
+//Storyboard Layer 2 (Passing)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Sound Samples
+//Background Colour Transformations
+3,100,163,162,255
+
+[TimingPoints]
+355,476.190476190476,4,2,1,60,1,0
+
+[HitObjects]
+256,352,500,2,0,L|256:208,3,140
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneManiaTouchInput.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneManiaTouchInput.cs
index 3e83f4a5e8..f445af9caf 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneManiaTouchInput.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneManiaTouchInput.cs
@@ -203,7 +203,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         private void toggleTouchControls(bool enabled)
         {
             var maniaConfig = (ManiaRulesetConfigManager)RulesetConfigs.GetConfigFor(CreatePlayerRuleset())!;
-            maniaConfig.SetValue(ManiaRulesetSetting.MobileLayout, enabled ? ManiaMobileLayout.LandscapeWithOverlay : ManiaMobileLayout.Portrait);
+            maniaConfig.SetValue(ManiaRulesetSetting.TouchOverlay, enabled);
         }
 
         private ManiaTouchInputArea? getTouchOverlay() => this.ChildrenOfType<ManiaTouchInputArea>().SingleOrDefault();
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneTimingBasedNoteColouring.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneTimingBasedNoteColouring.cs
index b5b265792b..eb47e96670 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneTimingBasedNoteColouring.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneTimingBasedNoteColouring.cs
@@ -47,8 +47,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                         drawableRuleset = (DrawableManiaRuleset)Ruleset.Value.CreateInstance().CreateDrawableRulesetWith(createTestBeatmap())
                     }
                 };
-
-                drawableRuleset.AllowBackwardsSeeks = true;
             });
             AddStep("retrieve config bindable", () =>
             {
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
index 96550618c0..c55465762b 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
@@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
         }
 
-        public static int GetColumnCount(LegacyBeatmapConversionDifficultyInfo difficulty, IReadOnlyList<Mod>? mods = null)
+        public static int GetColumnCount(LegacyBeatmapConversionDifficultyInfo difficulty, IReadOnlyCollection<Mod>? mods = null)
         {
             var converter = new ManiaBeatmapConverter(null, difficulty, new ManiaRuleset());
 
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PassThroughPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PassThroughPatternGenerator.cs
index efeb99e8b4..2c6c4d1a5c 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PassThroughPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PassThroughPatternGenerator.cs
@@ -3,8 +3,10 @@
 
 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Utils;
 
@@ -30,12 +32,18 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             if (HitObject is IHasDuration endTimeData)
             {
+                // despite the beatmap originally being made for mania, if the object is parsed as a slider rather than a hold, sliding samples should still be played.
+                // this is seemingly only possible to achieve by modifying the .osu file directly, but online beatmaps that do that exist
+                // (see second and fourth notes of https://osu.ppy.sh/beatmapsets/73883#mania/216407)
+                bool playSlidingSamples = (HitObject is IHasLegacyHitObjectType hasType && hasType.LegacyType == LegacyHitObjectType.Slider) || HitObject is IHasPath;
+
                 pattern.Add(new HoldNote
                 {
                     StartTime = HitObject.StartTime,
                     Duration = endTimeData.Duration,
                     Column = column,
                     Samples = HitObject.Samples,
+                    PlaySlidingSamples = playSlidingSamples,
                     NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? HoldNote.CreateDefaultNodeSamples(HitObject)
                 });
             }
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/SliderPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/SliderPatternGenerator.cs
index e539baa94a..dee990f842 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/SliderPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/SliderPatternGenerator.cs
@@ -521,6 +521,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     Duration = endTime - startTime,
                     Column = column,
                     Samples = HitObject.Samples,
+                    PlaySlidingSamples = true,
                     NodeSamples = nodeSamplesAt(startTime)
                 };
             }
diff --git a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
index b999a521d5..d58347076d 100644
--- a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
+++ b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
@@ -14,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         public ManiaRulesetConfigManager(SettingsStore? settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
+            Migrate();
         }
 
         protected override void InitialiseDefaults()
@@ -24,6 +25,20 @@ namespace osu.Game.Rulesets.Mania.Configuration
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
             SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
+            SetDefault(ManiaRulesetSetting.TouchOverlay, false);
+        }
+
+        public void Migrate()
+        {
+            var mobileLayout = GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout);
+
+#pragma warning disable CS0618 // Type or member is obsolete
+            if (mobileLayout.Value == ManiaMobileLayout.LandscapeWithOverlay)
+#pragma warning restore CS0618 // Type or member is obsolete
+            {
+                mobileLayout.Value = ManiaMobileLayout.Landscape;
+                SetValue(ManiaRulesetSetting.TouchOverlay, true);
+            }
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -44,5 +59,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
         ScrollDirection,
         TimingBasedNoteColouring,
         MobileLayout,
+        TouchOverlay,
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs
index 51ead5f423..09394b2046 100644
--- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
 
             if (diff.CircleSize < 4)
             {
diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs
index 233c602c21..cdea7c88a7 100644
--- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))
diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs
index 569217207c..4cf44e27ac 100644
--- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
     {
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
             {
@@ -28,14 +28,18 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks
                         continue;
 
                     // Two hitobjects cannot be concurrent without also being concurrent with all objects in between.
-                    // So if the next object is not concurrent, then we know no future objects will be either.
-                    if (!AreConcurrent(hitobject, nextHitobject))
+                    // So if the next object is not concurrent or almost concurrent, then we know no future objects will be either.
+                    if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject))
                         break;
 
-                    if (hitobject.GetType() == nextHitobject.GetType())
-                        yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject);
-                    else
-                        yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject);
+                    if (AreConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject);
+                    }
+                    else if (AreAlmostConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject);
+                    }
                 }
             }
         }
diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaLowestDiffDrainTime.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaLowestDiffDrainTime.cs
new file mode 100644
index 0000000000..5e2223467d
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaLowestDiffDrainTime.cs
@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Mania.Edit.Checks
+{
+    public class CheckManiaLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21mania#rules
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 2, 30).TotalMilliseconds, "Hard");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 2, 45).TotalMilliseconds, "Insane");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 3, 30).TotalMilliseconds, "Expert");
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs b/osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs
index efb1d354af..17997ed463 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs
@@ -16,6 +16,9 @@ namespace osu.Game.Rulesets.Mania.Edit
             // Compose
             new CheckManiaConcurrentObjects(),
 
+            // Spread
+            new CheckManiaLowestDiffDrainTime(),
+
             // Settings
             new CheckKeyCount(),
             new CheckManiaAbnormalDifficultySettings(),
diff --git a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
index 9b2700c6e8..3f7a018dd1 100644
--- a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
+++ b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.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.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -19,12 +20,16 @@ namespace osu.Game.Rulesets.Mania
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
         private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
+        private FilterCriteria.OptionalRange<float> longNotePercentage;
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
             int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
 
-            return includedKeyCounts.Contains(keyCount);
+            bool keyCountMatch = includedKeyCounts.Contains(keyCount);
+            bool longNotePercentageMatch = !longNotePercentage.HasFilter || (!isConvertedBeatmap(beatmapInfo) && longNotePercentage.IsInRange(calculateLongNotePercentage(beatmapInfo)));
+
+            return keyCountMatch && longNotePercentageMatch;
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
@@ -84,6 +89,10 @@ namespace osu.Game.Rulesets.Mania
                             return false;
                     }
                 }
+
+                case "ln":
+                case "lns":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref longNotePercentage, op, strValues);
             }
 
             return false;
@@ -103,5 +112,18 @@ namespace osu.Game.Rulesets.Mania
 
             return false;
         }
+
+        private static bool isConvertedBeatmap(BeatmapInfo beatmapInfo)
+        {
+            return !beatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+        }
+
+        private static float calculateLongNotePercentage(BeatmapInfo beatmapInfo)
+        {
+            int holdNotes = beatmapInfo.EndTimeObjectCount;
+            int totalNotes = Math.Max(1, beatmapInfo.TotalObjectCount);
+
+            return holdNotes / (float)totalNotes * 100;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaMobileLayout.cs b/osu.Game.Rulesets.Mania/ManiaMobileLayout.cs
index 7d70dba092..fb41a83417 100644
--- a/osu.Game.Rulesets.Mania/ManiaMobileLayout.cs
+++ b/osu.Game.Rulesets.Mania/ManiaMobileLayout.cs
@@ -1,20 +1,25 @@
 // 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.Framework.Localisation;
 using osu.Game.Localisation;
+using osu.Game.Rulesets.Mania.Configuration;
 
 namespace osu.Game.Rulesets.Mania
 {
     public enum ManiaMobileLayout
     {
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.PortraitExpandedColumns))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.Portrait))]
         Portrait,
 
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeExpandedColumns))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.Landscape))]
         Landscape,
 
-        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeTouchOverlay))]
+        [LocalisableDescription(typeof(RulesetSettingsStrings), nameof(RulesetSettingsStrings.LandscapeExpandedColumns))]
+        LandscapeExpandedColumns,
+
+        [Obsolete($"Use {nameof(ManiaRulesetSetting.TouchOverlay)} instead.")] // todo: can be removed 20260211
         LandscapeWithOverlay,
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaRuleset.cs b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
index c2bcba38ab..c7bf1f3538 100644
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
@@ -12,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
@@ -414,6 +416,70 @@ namespace osu.Game.Rulesets.Mania
             }), true)
         };
 
+        /// <seealso cref="ManiaHitWindows"/>
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            // 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);
+            adjustedDifficulty.CircleSize = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), mods);
+
+            return adjustedDifficulty;
+        }
+
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            // a special touch-up of key count is required to the original difficulty, since key conversion mods are not `IApplicableToDifficulty`
+            var originalDifficulty = new BeatmapDifficulty(beatmapInfo.Difficulty)
+            {
+                CircleSize = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), [])
+            };
+            var adjustedDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var colours = new OsuColour();
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.KeyCount, @"KC", originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 18)
+            {
+                Description = "Affects the number of key columns on the playfield."
+            };
+
+            var hitWindows = new ManiaHitWindows();
+            hitWindows.SetDifficulty(adjustedDifficulty.OverallDifficulty);
+            hitWindows.IsConvert = !beatmapInfo.Ruleset.Equals(RulesetInfo);
+            hitWindows.ClassicModActive = mods.Any(m => m is ManiaModClassic);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.Accuracy, @"OD", originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10)
+            {
+                Description = "Affects timing requirements for notes.",
+                AdditionalMetrics = hitWindows.GetAllAvailableWindows()
+                                              .Reverse()
+                                              .Select(window => new RulesetBeatmapAttribute.AdditionalMetric(
+                                                  $"{window.result.GetDescription().ToUpperInvariant()} hit window",
+                                                  LocalisableString.Interpolate($@"±{hitWindows.WindowFor(window.result):0.##} ms"),
+                                                  colours.ForHitResult(window.result)
+                                              )).ToArray()
+            };
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
         public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
         {
             return new ManiaFilterCriteria();
diff --git a/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs b/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
index 5ae7ec9480..791f46d407 100644
--- a/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
+++ b/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
@@ -1,6 +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.
 
+using System;
+using System.Linq;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -48,12 +50,21 @@ namespace osu.Game.Rulesets.Mania
                 },
             };
 
+            Add(new SettingsCheckbox
+            {
+                LabelText = RulesetSettingsStrings.TouchOverlay,
+                Current = config.GetBindable<bool>(ManiaRulesetSetting.TouchOverlay)
+            });
+
             if (RuntimeInfo.IsMobile)
             {
                 Add(new SettingsEnumDropdown<ManiaMobileLayout>
                 {
                     LabelText = RulesetSettingsStrings.MobileLayout,
                     Current = config.GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout),
+#pragma warning disable CS0618 // Type or member is obsolete
+                    Items = Enum.GetValues<ManiaMobileLayout>().Where(l => l != ManiaMobileLayout.LandscapeWithOverlay),
+#pragma warning restore CS0618 // Type or member is obsolete
                 });
             }
         }
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/ManiaModConstantSpeed.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModConstantSpeed.cs
index d8e6bcd424..ab493410a5 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModConstantSpeed.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModConstantSpeed.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "No more tricky speed changes!";
 
-        public override IconUsage? Icon => FontAwesome.Solid.Equals;
+        public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
 
         public override ModType Type => ModType.Conversion;
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModCover.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModCover.cs
index b7b53587ab..3ebfcedfd1 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModCover.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModCover.cs
@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -14,6 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Cover";
         public override string Acronym => "CO";
+        public override IconUsage? Icon => OsuIcon.ModCover;
 
         public override LocalisableString Description => @"Decrease the playfield's viewing area.";
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModDualStages.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModDualStages.cs
index 2457aa75d7..e6b3541154 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModDualStages.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModDualStages.cs
@@ -1,8 +1,10 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
@@ -13,6 +15,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Dual Stages";
         public override string Acronym => "DS";
         public override LocalisableString Description => @"Double the stages, double the fun!";
+        public override IconUsage? Icon => OsuIcon.ModDualStages;
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
index c9a84051d5..16872c45c4 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModEasy.cs
@@ -13,19 +13,19 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         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)
         {
-            const double multiplier = 1 / 1.4;
-
             switch (hitObject)
             {
                 case Note:
-                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = multiplier;
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
                     break;
 
                 case HoldNote hold:
-                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = multiplier;
-                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = multiplier;
+                    ((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/ManiaModFadeIn.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs
index f340608fd1..337fd61b91 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs
@@ -3,7 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -12,6 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
+        public override IconUsage? Icon => OsuIcon.ModFadeIn;
         public override LocalisableString Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
         public override bool ValidForFreestyleAsRequiredMod => false;
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
index a73bd94566..13f86bd641 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs
@@ -13,19 +13,19 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override double ScoreMultiplier => 1;
         public override bool Ranked => false;
 
+        public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;
+
         void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
         {
-            const double multiplier = 1.4;
-
             switch (hitObject)
             {
                 case Note:
-                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = multiplier;
+                    ((ManiaHitWindows)hitObject.HitWindows).DifficultyMultiplier = HIT_WINDOW_DIFFICULTY_MULTIPLIER;
                     break;
 
                 case HoldNote hold:
-                    ((ManiaHitWindows)hold.Head.HitWindows).DifficultyMultiplier = multiplier;
-                    ((ManiaHitWindows)hold.Tail.HitWindows).DifficultyMultiplier = multiplier;
+                    ((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/ManiaModHoldOff.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModHoldOff.cs
index eba0b2effe..9a1f1948e9 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModHoldOff.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModHoldOff.cs
@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Framework.Graphics.Sprites;
 using System.Collections.Generic;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.DotCircle;
+        public override IconUsage? Icon => OsuIcon.ModHoldOff;
 
         public override ModType Type => ModType.Conversion;
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModInvert.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModInvert.cs
index d1912e3690..f0fc9c0685 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModInvert.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModInvert.cs
@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "Hold the keys. To the beat.";
 
-        public override IconUsage? Icon => FontAwesome.Solid.YinYang;
+        public override IconUsage? Icon => OsuIcon.ModInvert;
 
         public override ModType Type => ModType.Conversion;
 
@@ -63,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Mods
                         StartTime = locations[i].startTime,
                         Duration = duration,
                         NodeSamples = new List<IList<HitSampleInfo>> { locations[i].samples, Array.Empty<HitSampleInfo>() }
+                        // intentionally don't play sliding samples here, it doesn't work in this mod.
                     });
                 }
 
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey1.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey1.cs
index 7dd0c499da..290e40fbf3 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey1.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey1.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 1;
         public override string Name => "One Key";
         public override string Acronym => "1K";
+        public override IconUsage? Icon => OsuIcon.ModOneKey;
         public override LocalisableString Description => @"Play with one key.";
         public override bool Ranked => false;
     }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey10.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey10.cs
index a6c57d4597..18687148df 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey10.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey10.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 10;
         public override string Name => "Ten Keys";
         public override string Acronym => "10K";
+        public override IconUsage? Icon => OsuIcon.ModTenKeys;
         public override LocalisableString Description => @"Play with ten keys.";
         public override bool Ranked => false;
     }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey2.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey2.cs
index 0d04395a52..041d38b98a 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey2.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey2.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 2;
         public override string Name => "Two Keys";
         public override string Acronym => "2K";
+        public override IconUsage? Icon => OsuIcon.ModTwoKeys;
         public override LocalisableString Description => @"Play with two keys.";
         public override bool Ranked => false;
     }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey3.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey3.cs
index c83b0979ee..fea5366811 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey3.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey3.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 3;
         public override string Name => "Three Keys";
         public override string Acronym => "3K";
+        public override IconUsage? Icon => OsuIcon.ModThreeKeys;
         public override LocalisableString Description => @"Play with three keys.";
         public override bool Ranked => false;
     }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey4.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey4.cs
index d3a4546dce..4a9fe7e3df 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey4.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey4.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 4;
         public override string Name => "Four Keys";
         public override string Acronym => "4K";
+        public override IconUsage? Icon => OsuIcon.ModFourKeys;
         public override LocalisableString Description => @"Play with four keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey5.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey5.cs
index 693182a952..aea2fe9bbe 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey5.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey5.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 5;
         public override string Name => "Five Keys";
         public override string Acronym => "5K";
+        public override IconUsage? Icon => OsuIcon.ModFiveKeys;
         public override LocalisableString Description => @"Play with five keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey6.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey6.cs
index ab911292f7..e66ea32585 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey6.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey6.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 6;
         public override string Name => "Six Keys";
         public override string Acronym => "6K";
+        public override IconUsage? Icon => OsuIcon.ModSixKeys;
         public override LocalisableString Description => @"Play with six keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey7.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey7.cs
index ab401ef1d0..07aa60a0a8 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey7.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey7.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 7;
         public override string Name => "Seven Keys";
         public override string Acronym => "7K";
+        public override IconUsage? Icon => OsuIcon.ModSevenKeys;
         public override LocalisableString Description => @"Play with seven keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey8.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey8.cs
index b3e8a45dda..b6b2016790 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey8.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey8.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 8;
         public override string Name => "Eight Keys";
         public override string Acronym => "8K";
+        public override IconUsage? Icon => OsuIcon.ModEightKeys;
         public override LocalisableString Description => @"Play with eight keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModKey9.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModKey9.cs
index 5972cbf0fe..089bb0402b 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModKey9.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModKey9.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
@@ -10,6 +12,7 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override int KeyCount => 9;
         public override string Name => "Nine Keys";
         public override string Acronym => "9K";
+        public override IconUsage? Icon => OsuIcon.ModNineKeys;
         public override LocalisableString Description => @"Play with nine keys.";
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModNoRelease.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModNoRelease.cs
index 143a5f1bdc..d72e2ce70c 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModNoRelease.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModNoRelease.cs
@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using System.Threading;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -26,6 +28,8 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override double ScoreMultiplier => 0.9;
 
+        public override IconUsage? Icon => OsuIcon.ModNoRelease;
+
         public override ModType Type => ModType.DifficultyReduction;
 
         public override Type[] IncompatibleMods => new[] { typeof(ManiaModHoldOff) };
@@ -80,7 +84,9 @@ namespace osu.Game.Rulesets.Mania.Mods
                 StartTime = hold.StartTime;
                 Duration = hold.Duration;
                 Column = hold.Column;
+                Samples = hold.Samples;
                 NodeSamples = hold.NodeSamples;
+                PlaySlidingSamples = hold.PlaySlidingSamples;
             }
 
             protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
diff --git a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
index 23c062164e..210cd2a103 100644
--- a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
@@ -355,7 +355,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         private void updateSlidingSample(ValueChangedEvent<bool> tracking)
         {
-            if (tracking.NewValue)
+            if (tracking.NewValue && HitObject.PlaySlidingSamples)
                 slidingSample?.Play();
             else
                 slidingSample?.Stop();
diff --git a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
index 98060dd226..15c570e34a 100644
--- a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
@@ -86,6 +86,11 @@ namespace osu.Game.Rulesets.Mania.Objects
         /// </summary>
         public HoldNoteBody Body { get; protected set; }
 
+        /// <summary>
+        /// Whether sliding samples should be played when held.
+        /// </summary>
+        public bool PlaySlidingSamples { get; init; }
+
         public override double MaximumJudgementOffset => Tail.MaximumJudgementOffset;
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
diff --git a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
index fe47b297dd..abff91926a 100644
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
@@ -9,7 +9,7 @@ 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);
@@ -151,7 +151,7 @@ namespace osu.Game.Rulesets.Mania.Scoring
             }
             else
             {
-                perfect = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, perfect_window_range) * totalMultiplier) + 0.5;
+                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;
diff --git a/osu.Game.Rulesets.Mania/UI/Column.cs b/osu.Game.Rulesets.Mania/UI/Column.cs
index eccececd22..dec30043f5 100644
--- a/osu.Game.Rulesets.Mania/UI/Column.cs
+++ b/osu.Game.Rulesets.Mania/UI/Column.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public readonly Bindable<Color4> AccentColour = new Bindable<Color4>(Color4.Black);
 
-        private IBindable<ManiaMobileLayout> mobilePlayStyle = null!;
+        private IBindable<bool> touchOverlay = null!;
 
         private float leftColumnSpacing;
         private float rightColumnSpacing;
@@ -123,7 +123,7 @@ namespace osu.Game.Rulesets.Mania.UI
             RegisterPool<HoldNoteBody, DrawableHoldNoteBody>(10, 50);
 
             if (rulesetConfig != null)
-                mobilePlayStyle = rulesetConfig.GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout);
+                touchOverlay = rulesetConfig.GetBindable<bool>(ManiaRulesetSetting.TouchOverlay);
         }
 
         private void onSourceChanged()
@@ -214,7 +214,7 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override bool OnTouchDown(TouchDownEvent e)
         {
             // if touch overlay is visible, disallow columns from handling touch directly.
-            if (mobilePlayStyle.Value == ManiaMobileLayout.LandscapeWithOverlay)
+            if (touchOverlay.Value)
                 return false;
 
             maniaInputManager?.KeyBindingContainer.TriggerPressed(Action.Value);
diff --git a/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs b/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
index 953be8d507..03e5791519 100644
--- a/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
+++ b/osu.Game.Rulesets.Mania/UI/ColumnFlow.cs
@@ -104,7 +104,7 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             float mobileAdjust = 1f;
 
-            if (RuntimeInfo.IsMobile && mobileLayout.Value == ManiaMobileLayout.Landscape)
+            if (RuntimeInfo.IsMobile && mobileLayout.Value == ManiaMobileLayout.LandscapeExpandedColumns)
             {
                 // GridContainer+CellContainer containing this stage (gets split up for dual stages).
                 Vector2? containingCell = this.FindClosestParent<Stage>()?.Parent?.DrawSize;
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index fe3535d857..d9a03d1c30 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -59,6 +59,7 @@ namespace osu.Game.Rulesets.Mania.UI
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
         private readonly BindableDouble configScrollSpeed = new BindableDouble();
         private readonly Bindable<ManiaMobileLayout> mobileLayout = new Bindable<ManiaMobileLayout>();
+        private readonly Bindable<bool> touchOverlay = new Bindable<bool>();
 
         public double TargetTimeRange { get; protected set; }
 
@@ -122,24 +123,23 @@ namespace osu.Game.Rulesets.Mania.UI
 
             Config.BindWith(ManiaRulesetSetting.MobileLayout, mobileLayout);
             mobileLayout.BindValueChanged(_ => updateMobileLayout(), true);
+
+            Config.BindWith(ManiaRulesetSetting.TouchOverlay, touchOverlay);
+            touchOverlay.BindValueChanged(_ => updateMobileLayout(), true);
         }
 
         private ManiaTouchInputArea? touchInputArea;
 
         private void updateMobileLayout()
         {
-            switch (mobileLayout.Value)
+            if (touchOverlay.Value)
+                KeyBindingInputManager.Add(touchInputArea = new ManiaTouchInputArea(this));
+            else
             {
-                case ManiaMobileLayout.LandscapeWithOverlay:
-                    KeyBindingInputManager.Add(touchInputArea = new ManiaTouchInputArea(this));
-                    break;
+                if (touchInputArea != null)
+                    KeyBindingInputManager.Remove(touchInputArea, true);
 
-                default:
-                    if (touchInputArea != null)
-                        KeyBindingInputManager.Remove(touchInputArea, true);
-
-                    touchInputArea = null;
-                    break;
+                touchInputArea = null;
             }
         }
 
diff --git a/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs b/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
index 2195c9e1b9..5e4da2d480 100644
--- a/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
+++ b/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
@@ -42,13 +42,22 @@ namespace osu.Game.Rulesets.Mania
             var bindings = new List<KeyBinding>();
 
             for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
-                bindings.Add(new KeyBinding(LeftKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(LeftKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             if (columns % 2 == 1)
-                bindings.Add(new KeyBinding(SpecialKey, currentAction++));
+            {
+                bindings.Add(new KeyBinding(SpecialKey, currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             for (int i = 0; i < columns / 2; i++)
-                bindings.Add(new KeyBinding(RightKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(RightKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             return bindings;
         }
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
index f257ed5987..c6893a5bdf 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
@@ -9,6 +9,7 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
@@ -284,5 +285,70 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                        && Precision.AlmostEquals(composer.GridLineRotation.Value, 0.09, 0.01);
             });
         }
+
+        [Test]
+        public void TestGridPlacementCommittedByDragSelection()
+        {
+            AddStep("add circle", () => EditorBeatmap.Add(new HitCircle
+            {
+                Position = new Vector2(64, 64),
+                StartTime = EditorClock.CurrentTime,
+            }));
+
+            AddStep("select circle tool", () => InputManager.Key(Key.Number2));
+            AddStep("select grid tool", () => InputManager.Key(Key.Number5));
+            AddStep("move cursor to centre", () => InputManager.MoveMouseTo(Editor));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            AddStep("move cursor to (-1, -1)", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(new Vector2(-1, -1)));
+            });
+            AddStep("drag to center", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(Editor);
+            });
+            AddStep("release left", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("one selection", () => Editor.ChildrenOfType<OsuSelectionHandler>().Single().SelectedBlueprints, () => Has.One.Items);
+            AddAssert("selection is circle", () => Editor.ChildrenOfType<OsuSelectionHandler>().Single().SelectedBlueprints.Single(), Is.TypeOf<HitCircleSelectionBlueprint>);
+
+            AddStep("move cursor to slider", () =>
+            {
+                var composer = Editor.ChildrenOfType<RectangularPositionSnapGrid>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(((Slider)EditorBeatmap.HitObjects.ElementAt(1)).EndPosition + new Vector2(1, 1)));
+            });
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("one selection", () => Editor.ChildrenOfType<OsuSelectionHandler>().Single().SelectedBlueprints, () => Has.One.Items);
+            AddAssert("selection is slider", () => Editor.ChildrenOfType<OsuSelectionHandler>().Single().SelectedBlueprints.Single(), Is.TypeOf<SliderSelectionBlueprint>);
+        }
+
+        [Test]
+        public void TestGridPlacementRevertsToLastTool()
+        {
+            AddStep("select circle tool", () => InputManager.Key(Key.Number2));
+            AddStep("select grid tool", () => InputManager.Key(Key.Number5));
+            AddStep("move cursor to centre", () => InputManager.MoveMouseTo(Editor));
+            AddStep("start grid placement", () => InputManager.Click(MouseButton.Left));
+            AddStep("end grid placement", () => InputManager.Click(MouseButton.Left));
+            AddAssert("tool reverted to circle", () => getComposer().BlueprintContainer.CurrentTool, Is.TypeOf<HitCircleCompositionTool>);
+
+            HitObjectComposer getComposer() => Editor.ChildrenOfType<HitObjectComposer>().Single();
+        }
+
+        [Test]
+        public void TestGridPlacementDoesNotOverrideToolChange()
+        {
+            AddStep("select circle tool", () => InputManager.Key(Key.Number2));
+            AddStep("select grid tool", () => InputManager.Key(Key.Number5));
+            AddStep("move cursor to centre", () => InputManager.MoveMouseTo(Editor));
+            AddStep("start grid placement", () => InputManager.Click(MouseButton.Left));
+            AddStep("select circle tool again", () => InputManager.Key(Key.Number2));
+            AddAssert("circle tool selected", () => getComposer().BlueprintContainer.CurrentTool, Is.TypeOf<HitCircleCompositionTool>);
+
+            HitObjectComposer getComposer() => Editor.ChildrenOfType<HitObjectComposer>().Single();
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
index 496e7610ff..f4f7f9d44b 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
@@ -32,26 +32,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
         [Test]
         public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new OsuModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
 
-        [Test]
-        public void TestPlayfieldBasedSize()
-        {
-            OsuModFlashlight flashlight;
-            CreateModTest(new ModTestData
-            {
-                Mods = [flashlight = new OsuModFlashlight(), new OsuModBarrelRoll()],
-                PassCondition = () =>
-                {
-                    var flashlightOverlay = Player.DrawableRuleset.Overlays
-                                                  .ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>()
-                                                  .First();
-
-                    // the combo check is here because the flashlight radius decreases for the first time at 100 combo
-                    // and hardcoding it here eliminates the need to meddle in flashlight internals further by e.g. exposing `GetComboScaleFor()`
-                    return flashlightOverlay.GetSize() < flashlight.DefaultFlashlightSize && Player.GameplayState.ScoreProcessor.Combo.Value < 100;
-                }
-            });
-        }
-
         [Test]
         public void TestSliderDimsOnlyAfterStartTime()
         {
diff --git a/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs b/osu.Game.Rulesets.Osu.Tests/OsuRateAdjustedDisplayDifficultyTest.cs
index aa903205c8..fd929dd8f4 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
 {
@@ -21,8 +22,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty { ApproachRate = originalApproachRate };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(originalApproachRate));
         }
@@ -32,8 +34,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty { OverallDifficulty = originalOverallDifficulty };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(originalOverallDifficulty));
         }
@@ -43,8 +46,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new OsuModHalfTime()]);
 
             Assert.That(adjustedDifficulty.ApproachRate, Is.EqualTo(1.67).Within(0.01));
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(2.22).Within(0.01));
@@ -55,8 +59,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var ruleset = new OsuRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [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/Resources/old-skin/sliderpoint10.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint10.png
new file mode 100644
index 0000000000..3e2fe66a1c
Binary files /dev/null and b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint10.png differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png
new file mode 100644
index 0000000000..d883279d81
Binary files /dev/null and b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png differ
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneAimErrorMeter.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneAimErrorMeter.cs
new file mode 100644
index 0000000000..65ab6e7e15
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneAimErrorMeter.cs
@@ -0,0 +1,162 @@
+// 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.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Scoring;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using NUnit.Framework;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Utils;
+using osu.Framework.Threading;
+using osu.Game.Rulesets.Osu.HUD;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public partial class TestSceneAimErrorMeter : OsuManualInputManagerTestScene
+    {
+        private DependencyProvidingContainer dependencyContainer = null!;
+        private ScoreProcessor scoreProcessor = null!;
+
+        private TestAimErrorMeter aimErrorMeter = null!;
+
+        private CircularContainer gameObject = null!;
+
+        private ScheduledDelegate? automaticAdditionDelegate;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddSliderStep("Hit marker size", 0f, 12f, 7f, t =>
+            {
+                if (aimErrorMeter.IsNotNull())
+                    aimErrorMeter.HitMarkerSize.Value = t;
+            });
+            AddSliderStep("Average position marker size", 1f, 25f, 7f, t =>
+            {
+                if (aimErrorMeter.IsNotNull())
+                    aimErrorMeter.AverageMarkerSize.Value = t;
+            });
+        }
+
+        [SetUpSteps]
+        public void SetupSteps() => AddStep("Create components", () =>
+        {
+            automaticAdditionDelegate?.Cancel();
+            automaticAdditionDelegate = null;
+
+            var ruleset = new OsuRuleset();
+
+            scoreProcessor = new ScoreProcessor(ruleset);
+            Child = dependencyContainer = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[]
+                {
+                    (typeof(ScoreProcessor), scoreProcessor)
+                }
+            };
+            dependencyContainer.Children = new Drawable[]
+            {
+                aimErrorMeter = new TestAimErrorMeter
+                {
+                    Margin = new MarginPadding
+                    {
+                        Top = 100
+                    },
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    Scale = new Vector2(2),
+                },
+
+                gameObject = new CircularContainer
+                {
+                    Size = new Vector2(2 * OsuHitObject.OBJECT_RADIUS),
+                    Position = new Vector2(256, 192),
+                    Colour = Color4.Yellow,
+                    Masking = true,
+                    BorderThickness = 2,
+                    BorderColour = Color4.White,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        },
+                        new Circle
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(4),
+                        }
+                    }
+                }
+            };
+        });
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            // the division by 2 is because CS=5 applies a 0.5x (plus fudge) multiplier to `OBJECT_RADIUS`
+            aimErrorMeter.AddPoint((gameObject.ToLocalSpace(e.ScreenSpaceMouseDownPosition) - new Vector2(OsuHitObject.OBJECT_RADIUS)) / 2);
+            return true;
+        }
+
+        [Test]
+        public void TestManyHitPointsAutomatic()
+        {
+            AddStep("add scheduled delegate", () =>
+            {
+                automaticAdditionDelegate = Scheduler.AddDelayed(() =>
+                {
+                    var randomPos = new Vector2(
+                        RNG.NextSingle(0, 2 * OsuHitObject.OBJECT_RADIUS),
+                        RNG.NextSingle(0, 2 * OsuHitObject.OBJECT_RADIUS));
+
+                    aimErrorMeter.AddPoint(randomPos - new Vector2(OsuHitObject.OBJECT_RADIUS));
+                    InputManager.MoveMouseTo(gameObject.ToScreenSpace(randomPos));
+                }, 1, true);
+            });
+            AddWaitStep("wait for some hit points", 10);
+        }
+
+        [Test]
+        public void TestDisplayStyles()
+        {
+            AddStep("Switch hit position marker style to +", () => aimErrorMeter.HitMarkerStyle.Value = AimErrorMeter.MarkerStyle.Plus);
+            AddStep("Switch hit position marker style to x", () => aimErrorMeter.HitMarkerStyle.Value = AimErrorMeter.MarkerStyle.X);
+            AddStep("Switch average position marker style to +", () => aimErrorMeter.AverageMarkerStyle.Value = AimErrorMeter.MarkerStyle.Plus);
+            AddStep("Switch average position marker style to x", () => aimErrorMeter.AverageMarkerStyle.Value = AimErrorMeter.MarkerStyle.X);
+
+            AddStep("Switch position display to absolute", () => aimErrorMeter.PositionDisplayStyle.Value = AimErrorMeter.PositionDisplay.Absolute);
+            AddStep("Switch position display to relative", () => aimErrorMeter.PositionDisplayStyle.Value = AimErrorMeter.PositionDisplay.Normalised);
+        }
+
+        [Test]
+        public void TestManualPlacement()
+        {
+            AddStep("return user input", () => InputManager.UseParentInput = true);
+        }
+
+        private partial class TestAimErrorMeter : AimErrorMeter
+        {
+            public void AddPoint(Vector2 position)
+            {
+                OnNewJudgement(new OsuHitCircleJudgementResult(new HitCircle(), new OsuJudgement())
+                {
+                    CursorPositionAtHit = position
+                });
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneDrawableJudgementSliderTicks.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneDrawableJudgementSliderTicks.cs
new file mode 100644
index 0000000000..5843a9233c
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneDrawableJudgementSliderTicks.cs
@@ -0,0 +1,160 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.Sprites;
+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 osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public partial class TestSceneDrawableJudgementSliderTicks : OsuSkinnableTestScene
+    {
+        private bool classic;
+        private readonly JudgementPooler<DrawableOsuJudgement>[] judgementPools;
+
+        public TestSceneDrawableJudgementSliderTicks()
+        {
+            judgementPools = new JudgementPooler<DrawableOsuJudgement>[Rows * Cols];
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            int cellIndex = 0;
+
+            SetContents(_ =>
+            {
+                var container = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        judgementPools[cellIndex] = new JudgementPooler<DrawableOsuJudgement>(new[]
+                        {
+                            HitResult.Great,
+                            HitResult.Miss,
+                            HitResult.LargeTickHit,
+                            HitResult.SliderTailHit,
+                            HitResult.LargeTickMiss,
+                            HitResult.IgnoreMiss,
+                        }),
+                        new GridContainer
+                        {
+                            Padding = new MarginPadding { Top = 26f },
+                            RelativeSizeAxes = Axes.Both,
+                            RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
+                            ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
+                            Content =
+                                new[]
+                                {
+                                    new[]
+                                    {
+                                        Empty(),
+                                        new OsuSpriteText
+                                        {
+                                            Text = "hit",
+                                            Anchor = Anchor.BottomCentre,
+                                            Origin = Anchor.BottomCentre,
+                                        },
+                                        new OsuSpriteText
+                                        {
+                                            Text = "miss",
+                                            Anchor = Anchor.BottomCentre,
+                                            Origin = Anchor.BottomCentre,
+                                        },
+                                    },
+                                }.Concat(new[]
+                                {
+                                    "head",
+                                    "tick",
+                                    "repeat",
+                                    "tail",
+                                    "slider",
+                                }.Select(label => new Drawable[]
+                                {
+                                    new OsuSpriteText
+                                    {
+                                        Text = label,
+                                        Anchor = Anchor.CentreRight,
+                                        Origin = Anchor.CentreRight,
+                                    },
+                                    new Container<DrawableOsuJudgement> { RelativeSizeAxes = Axes.Both },
+                                    new Container<DrawableOsuJudgement> { RelativeSizeAxes = Axes.Both },
+                                })).ToArray(),
+                        },
+                    },
+                };
+
+                cellIndex++;
+
+                return container;
+            });
+
+            AddToggleStep("Toggle classic behaviour", c => classic = c);
+
+            AddStep("Show judgements", createAllJudgements);
+        }
+
+        private void createAllJudgements()
+        {
+            for (int cellIndex = 0; cellIndex < Rows * Cols; cellIndex++)
+            {
+                var slider = new Slider { StartTime = Time.Current, ClassicSliderBehaviour = classic };
+                slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                var drawableHitObjects = new DrawableOsuHitObject[]
+                {
+                    new DrawableSliderHead(new SliderHeadCircle { StartTime = Time.Current, ClassicSliderBehaviour = classic }),
+                    new DrawableSliderTick(new SliderTick { StartTime = Time.Current }),
+                    new DrawableSliderRepeat(new SliderRepeat(slider) { StartTime = Time.Current }),
+                    new DrawableSliderTail(new SliderTailCircle(slider) { StartTime = Time.Current, ClassicSliderBehaviour = classic }),
+                    new DrawableSlider(slider),
+                };
+
+                var containers = Cell(cellIndex).ChildrenOfType<Container<DrawableOsuJudgement>>().ToArray();
+
+                for (int i = 0; i < drawableHitObjects.Length; i++)
+                {
+                    createJudgement(judgementPools[cellIndex], containers[i * 2], drawableHitObjects[i], true);
+                    createJudgement(judgementPools[cellIndex], containers[i * 2 + 1], drawableHitObjects[i], false);
+                }
+            }
+        }
+
+        private void createJudgement(JudgementPooler<DrawableOsuJudgement> pool, Container<DrawableOsuJudgement> container, DrawableOsuHitObject drawableHitObject, bool hit)
+        {
+            container.Clear(false);
+
+            if (!drawableHitObject.DisplayResult)
+                return;
+
+            var hitObject = drawableHitObject.HitObject;
+            var result = new OsuJudgementResult(hitObject, hitObject.Judgement)
+            {
+                Type = hit ? hitObject.Judgement.MaxResult : hitObject.Judgement.MinResult,
+            };
+
+            var judgement = pool.Get(result.Type, d =>
+            {
+                d.Anchor = Anchor.Centre;
+                d.Origin = Anchor.Centre;
+                d.Scale = new Vector2(0.7f);
+                d.Apply(result, null);
+            });
+
+            if (judgement != null)
+                container.Add(judgement);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
index 3cfbfc905a..0e37142940 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
@@ -475,7 +475,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             performTest(hitObjects, new List<ReplayFrame>
             {
                 new OsuReplayFrame { Time = time_stack_start - 450, Position = new Vector2(55), Actions = { OsuAction.LeftButton } },
-            });
+            }, extraMods: [new OsuModNoFail()]);
 
             addClickActionAssert(0, ClickAction.Ignore);
         }
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/Edit/Blueprints/GridPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
index d9edc8dbd4..f54dc2c85b 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
@@ -36,9 +36,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints
 
             base.EndPlacement(commit);
 
-            // You typically only place the grid once, so we switch back to the last tool after placement.
-            if (commit && hitObjectComposer is OsuHitObjectComposer osuHitObjectComposer)
-                osuHitObjectComposer.SetLastTool();
+            // You typically only place the grid once, so we switch back to the last tool after placement -
+            // but only if the tool hasn't changed from under us (which is possible, as external tool changes will commit any ongoing placements, including this one)
+            if (commit && hitObjectComposer?.BlueprintContainer.CurrentTool is GridFromPointsTool)
+                hitObjectComposer.SetLastTool();
         }
 
         protected override bool OnClick(ClickEvent e)
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs
index 084a3e5ea1..565499fc58 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
             if (context.InterpretedDifficulty > DifficultyRating.Easy)
                 yield break;
 
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
             {
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs
index a342c2a821..6910c721ac 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            foreach (var hitobject in context.Beatmap.HitObjects)
+            foreach (var hitobject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 switch (hitobject)
                 {
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuAbnormalDifficultySettings.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuAbnormalDifficultySettings.cs
index 1c44d54633..a53c6bf7a1 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuAbnormalDifficultySettings.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuAbnormalDifficultySettings.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuLowestDiffDrainTime.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuLowestDiffDrainTime.cs
new file mode 100644
index 0000000000..283f3b93af
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuLowestDiffDrainTime.cs
@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckOsuLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21#general
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 3, 30).TotalMilliseconds, "Hard");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 4, 15).TotalMilliseconds, "Insane");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 5, 0).TotalMilliseconds, "Expert");
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs
index 585bd35bd9..ac3faa1a09 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs
@@ -78,7 +78,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
                 yield break;
 
             var prevObservedTimeDistances = new List<ObservedTimeDistance>();
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
             {
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSliders.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSliders.cs
index 159498c479..8752920b44 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSliders.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSliders.cs
@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
             if (context.InterpretedDifficulty > DifficultyRating.Easy)
                 yield break;
 
-            foreach (var hitObject in context.Beatmap.HitObjects)
+            foreach (var hitObject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 if (hitObject is Slider slider && slider.SpanDuration < span_duration_threshold)
                     yield return new IssueTemplateTooShort(this).Create(slider);
diff --git a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSpinners.cs b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSpinners.cs
index f0aade1b7f..a1ba0cf530 100644
--- a/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSpinners.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSpinners.cs
@@ -19,14 +19,14 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            double od = context.Beatmap.Difficulty.OverallDifficulty;
+            double od = context.CurrentDifficulty.Playable.Difficulty.OverallDifficulty;
 
             // These are meant to reflect the duration necessary for auto to score at least 1000 points on the spinner.
             // It's difficult to eliminate warnings here, as auto achieving 1000 points depends on the approach angle on some spinners.
             double warningThreshold = 500 + (od < 5 ? (5 - od) * -21.8 : (od - 5) * 20); // Anything above this is always ok.
             double problemThreshold = 450 + (od < 5 ? (5 - od) * -17 : (od - 5) * 17); // Anything below this is never ok.
 
-            foreach (var hitObject in context.Beatmap.HitObjects)
+            foreach (var hitObject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 if (!(hitObject is Spinner spinner))
                     continue;
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBeatmapVerifier.cs b/osu.Game.Rulesets.Osu/Edit/OsuBeatmapVerifier.cs
index c3796124b8..67fddfb8a4 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBeatmapVerifier.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBeatmapVerifier.cs
@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             new CheckTimeDistanceEquality(),
             new CheckLowDiffOverlaps(),
             new CheckTooShortSliders(),
+            new CheckOsuLowestDiffDrainTime(),
 
             // Settings
             new CheckOsuAbnormalDifficultySettings(),
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
index 04d6afc925..f3739ab445 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
@@ -176,6 +176,11 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private void applyPosition()
         {
+            // can happen if popover is dismissed by a keyboard key press while dragging UI controls
+            // it doesn't cause a crash, but it looks wrong
+            if (!editorBeatmap.TransactionActive)
+                return;
+
             editorBeatmap.PerformOnSelection(ho =>
             {
                 if (!initialPositions.TryGetValue(ho, out var initialPosition))
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index ae8ad2c01b..e2cde1a325 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
@@ -157,6 +157,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             rotationInfo.BindValueChanged(rotation =>
             {
+                // can happen if the popover is dismissed by a keyboard key press while dragging UI controls
+                if (!rotationHandler.OperationInProgress.Value)
+                    return;
+
                 rotationHandler.Update(rotation.NewValue.Degrees, getOriginPosition(rotation.NewValue));
             });
         }
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index ac6d9fbb19..ca4a99b9cd 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -220,6 +220,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             scaleInfo.BindValueChanged(scale =>
             {
+                // can happen if the popover is dismissed by a keyboard key press while dragging UI controls
+                if (!scaleHandler.OperationInProgress.Value)
+                    return;
+
                 var newScale = new Vector2(scale.NewValue.Scale, scale.NewValue.Scale);
                 scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), getRotation(scale.NewValue));
             });
diff --git a/osu.Game.Rulesets.Osu/HUD/AimErrorMeter.cs b/osu.Game.Rulesets.Osu/HUD/AimErrorMeter.cs
new file mode 100644
index 0000000000..46593a56bb
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/HUD/AimErrorMeter.cs
@@ -0,0 +1,475 @@
+// 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 System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Localisation.HUD;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Statistics;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD.HitErrorMeters;
+using osuTK;
+using osuTK.Graphics;
+using Container = osu.Framework.Graphics.Containers.Container;
+
+namespace osu.Game.Rulesets.Osu.HUD
+{
+    [Cached]
+    public partial class AimErrorMeter : HitErrorMeter
+    {
+        [SettingSource(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.HitMarkerSize), nameof(AimErrorMeterStrings.HitMarkerSizeDescription))]
+        public BindableNumber<float> HitMarkerSize { get; } = new BindableNumber<float>(7f)
+        {
+            MinValue = 0f,
+            MaxValue = 12f,
+            Precision = 1f
+        };
+
+        [SettingSource(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.HitMarkerStyle), nameof(AimErrorMeterStrings.HitMarkerStyleDescription))]
+        public Bindable<MarkerStyle> HitMarkerStyle { get; } = new Bindable<MarkerStyle>();
+
+        [SettingSource(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.AverageMarkerSize), nameof(AimErrorMeterStrings.AverageMarkerSizeDescription))]
+        public BindableNumber<float> AverageMarkerSize { get; } = new BindableNumber<float>(12f)
+        {
+            MinValue = 7f,
+            MaxValue = 25f,
+            Precision = 1f
+        };
+
+        [SettingSource(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.AverageMarkerStyle), nameof(AimErrorMeterStrings.AverageMarkerStyleDescription))]
+        public Bindable<MarkerStyle> AverageMarkerStyle { get; } = new Bindable<MarkerStyle>(MarkerStyle.Plus);
+
+        [SettingSource(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.PositionDisplayStyle), nameof(AimErrorMeterStrings.PositionDisplayStyleDescription))]
+        public Bindable<PositionDisplay> PositionDisplayStyle { get; } = new Bindable<PositionDisplay>();
+
+        // used for calculate relative position.
+        private Vector2? lastObjectPosition;
+
+        private Container averagePositionMarker = null!;
+        private Container averagePositionMarkerRotationContainer = null!;
+        private Vector2? averagePosition;
+
+        private readonly DrawablePool<HitPositionMarker> hitPositionPool = new DrawablePool<HitPositionMarker>(30);
+        private Container hitPositionMarkerContainer = null!;
+
+        private Container arrowBackgroundContainer = null!;
+        private UprightAspectMaintainingContainer rotateFixedContainer = null!;
+        private Container mainContainer = null!;
+
+        private float objectRadius;
+
+        private const int max_concurrent_judgements = 30;
+
+        private const float line_thickness = 2;
+        private const float inner_portion = 0.85f;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public AimErrorMeter()
+        {
+            AutoSizeAxes = Axes.Both;
+            AlwaysPresent = true;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IBindable<WorkingBeatmap> beatmap, ScoreProcessor processor)
+        {
+            InternalChild = new Container
+            {
+                Height = 100,
+                Width = 100,
+                Children = new Drawable[]
+                {
+                    hitPositionPool,
+                    rotateFixedContainer = new UprightAspectMaintainingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                }
+            };
+
+            mainContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    new CircularContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        BorderColour = Colour4.White,
+                        Masking = true,
+                        BorderThickness = 2,
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(inner_portion),
+                        Child = new Box
+                        {
+                            Colour = Colour4.Gray,
+                            Alpha = 0.3f,
+                            RelativeSizeAxes = Axes.Both
+                        },
+                    },
+                    arrowBackgroundContainer = new Container
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Name = "Arrow Background",
+                        RelativeSizeAxes = Axes.Both,
+                        Rotation = 45,
+                        Alpha = 0f,
+                        Children = new Drawable[]
+                        {
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Height = inner_portion + 0.2f,
+                                Width = line_thickness / 2,
+                            },
+                            new Circle
+                            {
+                                Height = 5f,
+                                Width = line_thickness / 2,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.TopCentre,
+                                Margin = new MarginPadding(-line_thickness / 4),
+                                RelativePositionAxes = Axes.Both,
+                                Y = -(inner_portion + 0.2f) / 2,
+                                Rotation = -45
+                            },
+                            new Circle
+                            {
+                                Height = 5f,
+                                Width = line_thickness / 2,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.TopCentre,
+                                Margin = new MarginPadding(-line_thickness / 4),
+                                RelativePositionAxes = Axes.Both,
+                                Y = -(inner_portion + 0.2f) / 2,
+                                Rotation = 45
+                            }
+                        }
+                    },
+                    new Container
+                    {
+                        Name = "Cross Background",
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.5f,
+                                Width = line_thickness,
+                                Height = inner_portion * 0.9f
+                            },
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.5f,
+                                Width = line_thickness,
+                                Height = inner_portion * 0.9f,
+                                Rotation = 90
+                            },
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.2f,
+                                Width = line_thickness / 2,
+                                Height = inner_portion * 0.9f,
+                                Rotation = 45
+                            },
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.2f,
+                                Width = line_thickness / 2,
+                                Height = inner_portion * 0.9f,
+                                Rotation = 135
+                            },
+                        }
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Children = new Drawable[]
+                        {
+                            hitPositionMarkerContainer = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre
+                            },
+                            averagePositionMarker = new UprightAspectMaintainingContainer
+                            {
+                                RelativePositionAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Child = averagePositionMarkerRotationContainer = new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Children = new Drawable[]
+                                    {
+                                        new Circle
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Width = 0.25f,
+                                        },
+                                        new Circle
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Width = 0.25f,
+                                            Rotation = 90
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            // handle IApplicableToDifficulty for CS change.
+            BeatmapDifficulty newDifficulty = new BeatmapDifficulty();
+            beatmap.Value.Beatmap.Difficulty.CopyTo(newDifficulty);
+
+            var mods = processor.Mods.Value;
+
+            foreach (var mod in mods.OfType<IApplicableToDifficulty>())
+                mod.ApplyToDifficulty(newDifficulty);
+
+            objectRadius = OsuHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(newDifficulty.CircleSize, true);
+
+            AverageMarkerSize.BindValueChanged(size => averagePositionMarker.Size = new Vector2(size.NewValue), true);
+            AverageMarkerStyle.BindValueChanged(style => averagePositionMarkerRotationContainer.Rotation = style.NewValue == MarkerStyle.Plus ? 0 : 45, true);
+
+            PositionDisplayStyle.BindValueChanged(s =>
+            {
+                Clear();
+
+                if (s.NewValue == PositionDisplay.Normalised)
+                {
+                    arrowBackgroundContainer.FadeIn(100);
+                    rotateFixedContainer.Remove(mainContainer, false);
+                    AddInternal(mainContainer);
+                }
+                else
+                {
+                    arrowBackgroundContainer.FadeOut(100);
+                    // when in absolute mode, rotation of the aim error meter as a whole should not affect how the component is displayed
+                    RemoveInternal(mainContainer, false);
+                    rotateFixedContainer.Add(mainContainer);
+                }
+            }, true);
+        }
+
+        protected override void OnNewJudgement(JudgementResult judgement)
+        {
+            if (judgement is not OsuHitCircleJudgementResult circleJudgement) return;
+
+            if (circleJudgement.CursorPositionAtHit == null) return;
+
+            if (hitPositionMarkerContainer.Count > max_concurrent_judgements)
+            {
+                const double quick_fade_time = 300;
+
+                // check with a bit of lenience to avoid precision error in comparison.
+                var old = hitPositionMarkerContainer.FirstOrDefault(j => j.LifetimeEnd > Clock.CurrentTime + quick_fade_time * 1.1);
+
+                if (old != null)
+                {
+                    old.ClearTransforms();
+                    old.FadeOut(quick_fade_time).Expire();
+                }
+            }
+
+            Vector2 hitPosition;
+
+            if (PositionDisplayStyle.Value == PositionDisplay.Normalised && lastObjectPosition != null)
+            {
+                hitPosition = AccuracyHeatmap.FindRelativeHitPosition(lastObjectPosition.Value, ((OsuHitObject)circleJudgement.HitObject).StackedEndPosition,
+                    circleJudgement.CursorPositionAtHit.Value, objectRadius, 45) * (inner_portion / 2);
+            }
+            else
+            {
+                // get relative position between mouse position and current object.
+                hitPosition = (circleJudgement.CursorPositionAtHit.Value - ((OsuHitObject)circleJudgement.HitObject).StackedPosition) / objectRadius / 2 * inner_portion;
+            }
+
+            hitPosition = Vector2.Clamp(hitPosition, new Vector2(-0.5f), new Vector2(0.5f));
+
+            hitPositionPool.Get(drawableHit =>
+            {
+                drawableHit.X = hitPosition.X;
+                drawableHit.Y = hitPosition.Y;
+                drawableHit.Colour = getColourForPosition(hitPosition);
+
+                hitPositionMarkerContainer.Add(drawableHit);
+            });
+
+            var newAveragePosition = 0.1f * hitPosition + 0.9f * (averagePosition ?? hitPosition);
+            averagePositionMarker.MoveTo(newAveragePosition, 800, Easing.OutQuint);
+            averagePosition = newAveragePosition;
+            lastObjectPosition = ((OsuHitObject)circleJudgement.HitObject).StackedPosition;
+        }
+
+        private Color4 getColourForPosition(Vector2 position)
+        {
+            float distance = Vector2.Distance(position, Vector2.Zero);
+
+            if (distance >= 0.5f * inner_portion)
+                return colours.Red;
+
+            if (distance >= 0.35f * inner_portion)
+                return colours.Yellow;
+
+            if (distance >= 0.2f * inner_portion)
+                return colours.Green;
+
+            return colours.Blue;
+        }
+
+        public override void Clear()
+        {
+            averagePosition = null;
+            averagePositionMarker.MoveTo(Vector2.Zero, 800, Easing.OutQuint);
+            lastObjectPosition = null;
+
+            foreach (var h in hitPositionMarkerContainer)
+            {
+                h.ClearTransforms();
+                h.Expire();
+            }
+        }
+
+        private partial class HitPositionMarker : PoolableDrawable
+        {
+            [Resolved]
+            private AimErrorMeter aimErrorMeter { get; set; } = null!;
+
+            public readonly BindableNumber<float> MarkerSize = new BindableFloat();
+            public readonly Bindable<MarkerStyle> Style = new Bindable<MarkerStyle>();
+
+            private readonly Container content;
+
+            public HitPositionMarker()
+            {
+                RelativePositionAxes = Axes.Both;
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                InternalChild = new UprightAspectMaintainingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Child = content = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Children = new Drawable[]
+                        {
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Width = 0.25f,
+                                Rotation = -45
+                            },
+                            new Circle
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Width = 0.25f,
+                                Rotation = 45
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                MarkerSize.BindTo(aimErrorMeter.HitMarkerSize);
+                MarkerSize.BindValueChanged(size => Size = new Vector2(size.NewValue), true);
+                Style.BindTo(aimErrorMeter.HitMarkerStyle);
+                Style.BindValueChanged(style => content.Rotation = style.NewValue == MarkerStyle.X ? 0 : 45, true);
+            }
+
+            protected override void PrepareForUse()
+            {
+                base.PrepareForUse();
+
+                const int judgement_fade_in_duration = 100;
+                const int judgement_fade_out_duration = 5000;
+
+                this
+                    .ResizeTo(new Vector2(0))
+                    .FadeInFromZero(judgement_fade_in_duration, Easing.OutQuint)
+                    .ResizeTo(new Vector2(MarkerSize.Value), judgement_fade_in_duration, Easing.OutQuint)
+                    .Then()
+                    .FadeOut(judgement_fade_out_duration)
+                    .Expire();
+            }
+        }
+
+        public enum MarkerStyle
+        {
+            [Description("x")]
+            X,
+
+            [Description("+")]
+            Plus,
+        }
+
+        public enum PositionDisplay
+        {
+            [LocalisableDescription(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.Absolute))]
+            Absolute,
+
+            [LocalisableDescription(typeof(AimErrorMeterStrings), nameof(AimErrorMeterStrings.Normalised))]
+            Normalised,
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModAlternate.cs b/osu.Game.Rulesets.Osu/Mods/OsuModAlternate.cs
index 9bf5d33d4a..d01b561954 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModAlternate.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModAlternate.cs
@@ -5,6 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => @"Alternate";
         public override string Acronym => @"AL";
         public override LocalisableString Description => @"Don't use the same key twice in a row!";
-        public override IconUsage? Icon => FontAwesome.Solid.Keyboard;
+        public override IconUsage? Icon => OsuIcon.ModAlternate;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModSingleTap) }).ToArray();
 
         protected override bool CheckValidNewAction(OsuAction action) => LastAcceptedAction != action;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModApproachDifferent.cs b/osu.Game.Rulesets.Osu/Mods/OsuModApproachDifferent.cs
index f213d9f193..033ab0f861 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModApproachDifferent.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModApproachDifferent.cs
@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -19,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Acronym => "AD";
         public override LocalisableString Description => "Never trust the approach circles...";
         public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon { get; } = FontAwesome.Regular.Circle;
+        public override IconUsage? Icon => OsuIcon.ModApproachDifferent;
 
         public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModFreezeFrame) };
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModBlinds.cs b/osu.Game.Rulesets.Osu/Mods/OsuModBlinds.cs
index bb0e984418..97d76459c6 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModBlinds.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModBlinds.cs
@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -26,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => "Play with blinds on your screen.";
         public override string Acronym => "BL";
 
-        public override IconUsage? Icon => FontAwesome.Solid.Adjust;
+        public override IconUsage? Icon => OsuIcon.ModBlinds;
         public override ModType Type => ModType.DifficultyIncrease;
 
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModBloom.cs b/osu.Game.Rulesets.Osu/Mods/OsuModBloom.cs
index c674074dc6..445fb8b37a 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModBloom.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModBloom.cs
@@ -3,9 +3,11 @@
 
 using System;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mods;
@@ -21,6 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Bloom";
         public override string Acronym => "BM";
+        public override IconUsage? Icon => OsuIcon.ModBloom;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "The cursor blooms into.. a larger cursor!";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModBubbles.cs b/osu.Game.Rulesets.Osu/Mods/OsuModBubbles.cs
index b34cc29741..b706e07a55 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModBubbles.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModBubbles.cs
@@ -11,7 +11,9 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -34,6 +36,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override double ScoreMultiplier => 1;
 
+        public override IconUsage? Icon => OsuIcon.ModBubbles;
+
         public override ModType Type => ModType.Fun;
 
         // Compatibility with these seems potentially feasible in the future, blocked for now because they don't work as one would expect
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModDeflate.cs b/osu.Game.Rulesets.Osu/Mods/OsuModDeflate.cs
index f6622c268d..faceb2ac7c 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModDeflate.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModDeflate.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override string Acronym => "DF";
 
-        public override IconUsage? Icon => FontAwesome.Solid.CompressArrowsAlt;
+        public override IconUsage? Icon => OsuIcon.ModDeflate;
 
         public override LocalisableString Description => "Hit them at the right size!";
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModDepth.cs b/osu.Game.Rulesets.Osu/Mods/OsuModDepth.cs
index 306dcee839..ea0be78c09 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModDepth.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModDepth.cs
@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Depth";
         public override string Acronym => "DP";
-        public override IconUsage? Icon => FontAwesome.Solid.Cube;
+        public override IconUsage? Icon => OsuIcon.ModDepth;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "3D. Almost.";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs b/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
index 3009530b50..a8c2508f80 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override BindableBool ComboBasedSize { get; } = new BindableBool(true);
 
-        public override float DefaultFlashlightSize => 200;
+        public override float DefaultFlashlightSize => 125;
 
         private OsuFlashlight flashlight = null!;
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs b/osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs
index 421b908dc9..e75ed24a7d 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs
@@ -4,8 +4,10 @@
 using System;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -19,6 +21,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override string Acronym => "FR";
 
+        public override IconUsage? Icon => OsuIcon.ModFreezeFrame;
+
         public override double ScoreMultiplier => 1;
 
         public override LocalisableString Description => "Burn the notes into your memory.";
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModGrow.cs b/osu.Game.Rulesets.Osu/Mods/OsuModGrow.cs
index 3d066d3ada..475089ba94 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModGrow.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModGrow.cs
@@ -4,16 +4,17 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModGrow : OsuModObjectScaleTween
+    public class OsuModGrow : OsuModObjectScaleTween
     {
         public override string Name => "Grow";
 
         public override string Acronym => "GR";
 
-        public override IconUsage? Icon => FontAwesome.Solid.ArrowsAltV;
+        public override IconUsage? Icon => OsuIcon.ModGrow;
 
         public override LocalisableString Description => "Hit them at the right size!";
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs b/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
index 5038250261..11b512c882 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
@@ -9,6 +9,7 @@ using osu.Framework.Localisation;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Magnetised";
         public override string Acronym => "MG";
-        public override IconUsage? Icon => FontAwesome.Solid.Magnet;
+        public override IconUsage? Icon => OsuIcon.ModMagnetised;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
         public override double ScoreMultiplier => 0.5;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModRepel.cs b/osu.Game.Rulesets.Osu/Mods/OsuModRepel.cs
index 302e17432e..b95cc9b651 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModRepel.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModRepel.cs
@@ -4,10 +4,12 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -19,10 +21,11 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModRepel : Mod, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    public class OsuModRepel : Mod, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
     {
         public override string Name => "Repel";
         public override string Acronym => "RP";
+        public override IconUsage? Icon => OsuIcon.ModRepel;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Hit objects run away!";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModSingleTap.cs b/osu.Game.Rulesets.Osu/Mods/OsuModSingleTap.cs
index 91731b25cf..6d16598f89 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModSingleTap.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModSingleTap.cs
@@ -3,7 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -11,6 +13,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => @"Single Tap";
         public override string Acronym => @"SG";
+        public override IconUsage? Icon => OsuIcon.ModSingleTap;
         public override LocalisableString Description => @"You must only use one key!";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAlternate) }).ToArray();
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs b/osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs
index 59a1342480..429332bc55 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs
@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -17,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Spin In";
         public override string Acronym => "SI";
-        public override IconUsage? Icon => FontAwesome.Solid.Undo;
+        public override IconUsage? Icon => OsuIcon.ModSpinIn;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Circles spin in. No approach circles.";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
index 5ee8814b5a..16ef639384 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
@@ -4,17 +4,19 @@
 using System;
 using System.Linq;
 using System.Threading;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 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;
 
@@ -24,6 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => @"Strict Tracking";
         public override string Acronym => @"ST";
+        public override IconUsage? Icon => OsuIcon.ModStrictTracking;
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => @"Once you start a slider, follow precisely or get a miss.";
         public override double ScoreMultiplier => 1.0;
@@ -83,7 +86,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/Mods/OsuModTargetPractice.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
index 71080e3d8e..e82ec2fb10 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Target Practice";
         public override string Acronym => "TP";
         public override ModType Type => ModType.Conversion;
-        public override IconUsage? Icon => OsuIcon.ModTarget;
+        public override IconUsage? Icon => OsuIcon.ModTargetPractice;
         public override LocalisableString Description => @"Practice keeping up with the beat of the song.";
         public override double ScoreMultiplier => 0.1;
 
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
index 9091837034..b2a3da285c 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
@@ -4,7 +4,9 @@
 using System;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -18,6 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Traceable";
         public override string Acronym => "TC";
+        public override IconUsage? Icon => OsuIcon.ModTraceable;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Put your faith in the approach circles...";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs
index b6907af119..d0a1350db9 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs
@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -14,11 +15,11 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModTransform : ModWithVisibilityAdjustment
+    public class OsuModTransform : ModWithVisibilityAdjustment
     {
         public override string Name => "Transform";
         public override string Acronym => "TR";
-        public override IconUsage? Icon => FontAwesome.Solid.ArrowsAlt;
+        public override IconUsage? Icon => OsuIcon.ModTransform;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
index d14a821541..7c0faab235 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
@@ -15,11 +16,11 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModWiggle : ModWithVisibilityAdjustment
+    public class OsuModWiggle : ModWithVisibilityAdjustment
     {
         public override string Name => "Wiggle";
         public override string Acronym => "WG";
-        public override IconUsage? Icon => FontAwesome.Solid.Certificate;
+        public override IconUsage? Icon => OsuIcon.ModWiggle;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
index 8b3fcb23cd..0f7812d91a 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
 
-        private Vector2 screenSpacePosition;
+        private Vector2? screenSpacePosition;
 
         [BackgroundDependencyLoader]
         private void load()
@@ -65,7 +65,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Lighting.ResetAnimation();
             Lighting.SetColourFrom(this, Result);
-            Position = Parent!.ToLocalSpace(screenSpacePosition);
+
+            if (screenSpacePosition != null)
+                Position = Parent!.ToLocalSpace(screenSpacePosition.Value);
         }
 
         protected override void ApplyHitAnimations()
@@ -87,7 +89,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.ApplyHitAnimations();
         }
 
-        protected override Drawable CreateDefaultJudgement(HitResult result) => new OsuJudgementPiece(result);
+        protected override Drawable CreateDefaultJudgement(HitResult result) =>
+            // Tick hits don't show a judgement by default
+            result.IsHit() && result.IsTick() ? Empty() : new OsuJudgementPiece(result);
 
         private partial class OsuJudgementPiece : DefaultJudgementPiece
         {
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
index 76b9fdc3ce..55e985c568 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
@@ -16,17 +16,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
 
-        public override bool DisplayResult
-        {
-            get
-            {
-                if (HitObject?.ClassicSliderBehaviour == true)
-                    return false;
-
-                return base.DisplayResult;
-            }
-        }
-
         private readonly IBindable<int> pathVersion = new Bindable<int>();
 
         protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/SkinnableLighting.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/SkinnableLighting.cs
index 3776201626..7bb54487c0 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/SkinnableLighting.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/SkinnableLighting.cs
@@ -3,6 +3,7 @@
 
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osuTK.Graphics;
 
@@ -42,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (targetJudgement == null || targetResult == null)
                 Colour = Color4.White;
             else
-                Colour = targetResult.IsHit ? targetJudgement.AccentColour : Color4.Transparent;
+                Colour = targetResult.IsHit && !targetResult.Type.IsTick() ? targetJudgement.AccentColour : Color4.Transparent;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs b/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
index 9623d1999b..01309c68f6 100644
--- a/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
@@ -46,6 +46,8 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public const double PREEMPT_MAX = 1800;
 
+        public static readonly DifficultyRange PREEMPT_RANGE = new DifficultyRange(PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+
         public double TimePreempt { get; set; } = 600;
         public double TimeFadeIn = 400;
 
@@ -169,7 +171,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_MAX, PREEMPT_MID, PREEMPT_MIN);
+            TimePreempt = (float)IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, PREEMPT_RANGE);
 
             // Preempt time can go below 450ms. Normally, this is achieved via the DT mod which uniformly speeds up all animations game wide regardless of AR.
             // This uniform speedup is hard to match 1:1, however we can at least make AR>10 (via mods) feel good by extending the upper linear function above.
diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 31d00a2610..6f6b848b38 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -21,12 +21,12 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// <summary>
         /// The RPM required to clear the spinner at ODs [ 0, 5, 10 ].
         /// </summary>
-        private static readonly DifficultyRange clear_rpm_range = new DifficultyRange(90, 150, 225);
+        public static readonly DifficultyRange CLEAR_RPM_RANGE = new DifficultyRange(90, 150, 225);
 
         /// <summary>
         /// The RPM required to complete the spinner and receive full score at ODs [ 0, 5, 10 ].
         /// </summary>
-        private static readonly DifficultyRange complete_rpm_range = new DifficultyRange(250, 380, 430);
+        public static readonly DifficultyRange COMPLETE_RPM_RANGE = new DifficultyRange(250, 380, 430);
 
         public double EndTime
         {
@@ -63,10 +63,10 @@ namespace osu.Game.Rulesets.Osu.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             // The average RPS required over the length of the spinner to clear the spinner.
-            double minRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, clear_rpm_range) / 60;
+            double minRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, CLEAR_RPM_RANGE) / 60;
 
             // The RPS required over the length of the spinner to receive full score (all normal + bonus ticks).
-            double maxRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, complete_rpm_range) / 60;
+            double maxRps = IBeatmapDifficultyInfo.DifficultyRange(difficulty.OverallDifficulty, COMPLETE_RPM_RANGE) / 60;
 
             double secondsDuration = Duration / 1000;
 
diff --git a/osu.Game.Rulesets.Osu/OsuRuleset.cs b/osu.Game.Rulesets.Osu/OsuRuleset.cs
index 0edb8046b9..49d945e0aa 100644
--- a/osu.Game.Rulesets.Osu/OsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/OsuRuleset.cs
@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -13,11 +15,13 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Difficulty;
@@ -40,6 +44,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 +370,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(IBeatmapInfo difficulty, IReadOnlyCollection<Mod> mods)
         {
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(difficulty, mods);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.ApproachRate, OsuHitObject.PREEMPT_MAX, OsuHitObject.PREEMPT_MID, OsuHitObject.PREEMPT_MIN);
             preempt /= rate;
@@ -380,6 +386,67 @@ namespace osu.Game.Rulesets.Osu
             return adjustedDifficulty;
         }
 
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            // `modAdjustedDifficulty` contains only the direct effect of mods.
+            // `effectiveDifficulty` contains the "perceived" effect of rate-adjusting mods on OD and AR.
+            // we make a distinction here, because some of the calculations below will require very careful maneuvering between the two for correct results.
+            var modAdjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var effectiveDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var colours = new OsuColour();
+
+            // for circle size, we can use `effectiveDifficulty` directly
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.CircleSize, @"CS", originalDifficulty.CircleSize, effectiveDifficulty.CircleSize, 10)
+            {
+                Description = "Affects the size of hit circles and sliders.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Hit circle radius", (OsuHitObject.OBJECT_RADIUS * LegacyRulesetExtensions.CalculateScaleFromCircleSize(effectiveDifficulty.CircleSize, applyFudge: true)).ToLocalisableString("0.#"))
+                ]
+            };
+
+            // for approach rate, we can use `effectiveDifficulty` directly, and it is even convenient to do so (it correctly handles rate-changing mods like DT/HT)
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ApproachRate, @"AR", originalDifficulty.ApproachRate, effectiveDifficulty.ApproachRate, 10)
+            {
+                Description = "Affects how early objects appear on screen relative to their hit time.",
+                AdditionalMetrics =
+                [
+                    new RulesetBeatmapAttribute.AdditionalMetric("Approach time", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(effectiveDifficulty.ApproachRate, OsuHitObject.PREEMPT_RANGE):#,0.##} ms"))
+                ]
+            };
+
+            // for OD is where it gets difficult.
+            // when displaying hit window ranges with rate-changing mods active, we will want to adjust for rate ourselves, as `effectiveDifficulty` may not be accurate
+            // because `OsuHitWindows` applies a floor-and-round operation that will result in inaccurate results
+            // (the floor-and-round needs to happen *before* rate is taken into account, not after).
+            // for spinner RPM requirements, we do not want to involve rate-changing mods *at all*,
+            // because rate-adjusting mods do not change the spin requirement (see `SpinnerRotationTracker.AddRotation()`).
+            var hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(modAdjustedDifficulty.OverallDifficulty);
+            double rate = ModUtils.CalculateRateWithMods(mods);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.Accuracy, @"OD", originalDifficulty.OverallDifficulty, effectiveDifficulty.OverallDifficulty, 10)
+            {
+                Description = "Affects timing requirements for hit circles and spin speed requirements for spinners.",
+                AdditionalMetrics = hitWindows.GetAllAvailableWindows()
+                                              .Reverse()
+                                              .Select(window => new RulesetBeatmapAttribute.AdditionalMetric(
+                                                  $"{window.result.GetDescription().ToUpperInvariant()} hit window",
+                                                  LocalisableString.Interpolate($@"±{hitWindows.WindowFor(window.result) / rate:0.##} ms"),
+                                                  colours.ForHitResult(window.result)
+                                              )).Concat([
+                                                  new RulesetBeatmapAttribute.AdditionalMetric("RPM required to clear spinners", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(modAdjustedDifficulty.OverallDifficulty, Spinner.CLEAR_RPM_RANGE):N0} RPM")),
+                                                  new RulesetBeatmapAttribute.AdditionalMetric("RPM required to get full spinner bonus", LocalisableString.Interpolate($@"{IBeatmapDifficultyInfo.DifficultyRange(modAdjustedDifficulty.OverallDifficulty, Spinner.COMPLETE_RPM_RANGE):N0} RPM")),
+                                              ]).ToArray()
+            };
+
+            // HP drain is thankfully simple enough.
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, effectiveDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+        }
+
         public override bool EditorShowScrollSpeed => false;
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
index 2d1d5826b1..ecc0f3fd0a 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
@@ -29,6 +29,10 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
 
                     switch (result)
                     {
+                        case HitResult.LargeTickHit:
+                        case HitResult.SliderTailHit:
+                            return null;
+
                         case HitResult.IgnoreMiss:
                         case HitResult.LargeTickMiss:
                             return new ArgonJudgementPieceSliderTickMiss(result);
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyJudgementPieceSliderTickHit.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyJudgementPieceSliderTickHit.cs
new file mode 100644
index 0000000000..8c89f4c9c8
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyJudgementPieceSliderTickHit.cs
@@ -0,0 +1,23 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Judgements;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Skinning.Legacy
+{
+    public partial class LegacyJudgementPieceSliderTickHit : Sprite, IAnimatableJudgement
+    {
+        public void PlayAnimation()
+        {
+            // https://github.com/peppy/osu-stable-reference/blob/0e91e49bc83fe8b21c3ba5f1eb2d5d06456eae84/osu!/GameModes/Play/Rulesets/Ruleset.cs#L804-L806
+            this.MoveToOffset(new Vector2(0, -10), 300, Easing.Out)
+                .Then()
+                .FadeOut(60);
+        }
+
+        public Drawable GetAboveHitObjectsProxiedContent() => CreateProxy();
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
index af1df6dc9c..7118b6f95e 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
@@ -5,7 +5,9 @@ using System;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 using osuTK;
@@ -115,6 +117,39 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                     return null;
 
+                case SkinComponentLookup<HitResult> resultComponent:
+                    switch (resultComponent.Component)
+                    {
+                        case HitResult.LargeTickHit:
+                        case HitResult.SliderTailHit:
+                            if (getSliderPointTexture(resultComponent.Component) is Texture texture)
+                                return new LegacyJudgementPieceSliderTickHit { Texture = texture };
+
+                            break;
+
+                        // If the corresponding hit result displays a judgement and the miss texture isn't provided by this skin, don't look up the miss texture from any further skins.
+                        case HitResult.LargeTickMiss:
+                        case HitResult.IgnoreMiss:
+                            if (getSliderPointTexture(resultComponent.Component == HitResult.LargeTickMiss
+                                    ? HitResult.LargeTickHit
+                                    : HitResult.SliderTailHit) != null)
+                                return base.GetDrawableComponent(lookup) ?? Drawable.Empty();
+
+                            break;
+                    }
+
+                    return base.GetDrawableComponent(lookup);
+
+                    Texture? getSliderPointTexture(HitResult result)
+                    {
+                        // https://github.com/peppy/osu-stable-reference/blob/0e91e49bc83fe8b21c3ba5f1eb2d5d06456eae84/osu!/GameModes/Play/Rulesets/Ruleset.cs#L799
+                        if (GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value < 2m)
+                            // Note that osu!stable used sliderpoint30 for heads and repeats, and sliderpoint10 for ticks, but the mapping is intentionally changed here so that each texture represents one type of HitResult.
+                            return GetTexture(result == HitResult.LargeTickHit ? "sliderpoint30" : "sliderpoint10");
+
+                        return null;
+                    }
+
                 case OsuSkinComponentLookup osuComponent:
                     switch (osuComponent.Component)
                     {
diff --git a/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs b/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
index 41620bc3d8..4a028d677a 100644
--- a/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
+++ b/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
@@ -232,10 +232,47 @@ namespace osu.Game.Rulesets.Osu.Statistics
             if (pointGrid.Content.Count == 0)
                 return;
 
-            double angle1 = Math.Atan2(end.Y - hitPoint.Y, hitPoint.X - end.X); // Angle between the end point and the hit point.
-            double angle2 = Math.Atan2(end.Y - start.Y, start.X - end.X); // Angle between the end point and the start point.
+            Vector2 relativePosition = FindRelativeHitPosition(start, end, hitPoint, radius, rotation);
+
+            var localCentre = new Vector2(points_per_dimension - 1) / 2;
+            float localRadius = localCentre.X * inner_portion;
+            var localPoint = localCentre + localRadius * relativePosition;
+
+            // Find the most relevant hit point.
+            int r = (int)Math.Round(localPoint.Y);
+            int c = (int)Math.Round(localPoint.X);
+
+            if (r < 0 || r >= points_per_dimension || c < 0 || c >= points_per_dimension)
+                return;
+
+            PeakValue = Math.Max(PeakValue, ((GridPoint)pointGrid.Content[r][c]).Increment());
+
+            bufferedGrid.ForceRedraw();
+        }
+
+        /// <summary>
+        /// Normalises the position of a hit on a circle such that it is relative to the movement that was performed to arrive at said circle.
+        /// </summary>
+        /// <param name="previousObjectPosition">The position of the object prior to the one getting hit.</param>
+        /// <param name="nextObjectPosition">The position of the object which is getting hit.</param>
+        /// <param name="hitPoint">The point at which the user hit.</param>
+        /// <param name="objectRadius">The radius of <paramref name="previousObjectPosition"/> and <paramref name="nextObjectPosition"/>.</param>
+        /// <param name="rotation">
+        /// The rotation of the axis which is to be considered in the same direction as the vector
+        /// leading from <paramref name="previousObjectPosition"/> to <paramref name="nextObjectPosition"/>.
+        /// </param>
+        /// <returns>
+        /// A 2D vector representing the <paramref name="hitPoint"/> as relative to the movement between <paramref name="previousObjectPosition"/> and <paramref name="nextObjectPosition"/>
+        /// and relative to the <paramref name="objectRadius"/>.
+        /// If the object was hit perfectly in the middle, the return value will be <see cref="Vector2.Zero"/>.
+        /// If the object was hit perfectly at its edge, the returned vector will have a magnitude of 1.
+        /// </returns>
+        public static Vector2 FindRelativeHitPosition(Vector2 previousObjectPosition, Vector2 nextObjectPosition, Vector2 hitPoint, float objectRadius, float rotation)
+        {
+            double angle1 = Math.Atan2(nextObjectPosition.Y - hitPoint.Y, hitPoint.X - nextObjectPosition.X); // Angle between the end point and the hit point.
+            double angle2 = Math.Atan2(nextObjectPosition.Y - previousObjectPosition.Y, previousObjectPosition.X - nextObjectPosition.X); // Angle between the end point and the start point.
             double finalAngle = angle2 - angle1; // Angle between start, end, and hit points.
-            float normalisedDistance = Vector2.Distance(hitPoint, end) / radius;
+            float normalisedDistance = Vector2.Distance(hitPoint, nextObjectPosition) / objectRadius; // Distance between the hit point and the end point.
 
             // Consider two objects placed horizontally, with the start on the left and the end on the right.
             // The above calculated the angle between {end, start}, and the angle between {end, hitPoint}, in the form:
@@ -254,22 +291,7 @@ namespace osu.Game.Rulesets.Osu.Statistics
             //
             // We also need to apply the anti-clockwise rotation.
             double rotatedAngle = finalAngle - float.DegreesToRadians(rotation);
-            var rotatedCoordinate = -1 * new Vector2((float)Math.Cos(rotatedAngle), (float)Math.Sin(rotatedAngle));
-
-            Vector2 localCentre = new Vector2(points_per_dimension - 1) / 2;
-            float localRadius = localCentre.X * inner_portion * normalisedDistance;
-            Vector2 localPoint = localCentre + localRadius * rotatedCoordinate;
-
-            // Find the most relevant hit point.
-            int r = (int)Math.Round(localPoint.Y);
-            int c = (int)Math.Round(localPoint.X);
-
-            if (r < 0 || r >= points_per_dimension || c < 0 || c >= points_per_dimension)
-                return;
-
-            PeakValue = Math.Max(PeakValue, ((GridPoint)pointGrid.Content[r][c]).Increment());
-
-            bufferedGrid.ForceRedraw();
+            return -normalisedDistance * new Vector2((float)Math.Cos(rotatedAngle), (float)Math.Sin(rotatedAngle));
         }
 
         private abstract partial class GridPoint : CompositeDrawable
diff --git a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
index 7d9f5eb1a8..e379c44314 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
@@ -81,6 +81,8 @@ namespace osu.Game.Rulesets.Osu.UI
                 HitResult.Ok,
                 HitResult.Meh,
                 HitResult.Miss,
+                HitResult.LargeTickHit,
+                HitResult.SliderTailHit,
                 HitResult.LargeTickMiss,
                 HitResult.IgnoreMiss,
             }, onJudgementLoaded));
diff --git a/osu.Game.Rulesets.Taiko.Tests/Editor/Checks/CheckTaikoInconsistentSkipBarLineTest.cs b/osu.Game.Rulesets.Taiko.Tests/Editor/Checks/CheckTaikoInconsistentSkipBarLineTest.cs
new file mode 100644
index 0000000000..7ebbde0360
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko.Tests/Editor/Checks/CheckTaikoInconsistentSkipBarLineTest.cs
@@ -0,0 +1,220 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Taiko.Edit.Checks;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckTaikoInconsistentSkipBarLineTest
+    {
+        private CheckTaikoInconsistentSkipBarLine check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckTaikoInconsistentSkipBarLine();
+        }
+
+        [Test]
+        public void TestConsistentOmitFirstBarLine()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference
+                new[] { (1000.0, false), (2000.0, true) } // Same settings
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestInconsistentOmitFirstBarLine()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference
+                new[] { (1000.0, true), (2000.0, false) } // Different settings
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.All(issue => issue.Template is CheckTaikoInconsistentSkipBarLine.IssueTemplateInconsistentOmitFirstBarLine));
+            Assert.That(issues[0].Time, Is.EqualTo(1000.0));
+            Assert.That(issues[1].Time, Is.EqualTo(2000.0));
+        }
+
+        [Test]
+        public void TestPartiallyInconsistentOmitFirstBarLine()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true), (3000.0, false) }, // Reference
+                new[] { (1000.0, false), (2000.0, false), (3000.0, false) } // Only second differs
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckTaikoInconsistentSkipBarLine.IssueTemplateInconsistentOmitFirstBarLine);
+            Assert.That(issues[0].Time, Is.EqualTo(2000.0));
+        }
+
+        [Test]
+        public void TestSingleDifficulty()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) } // Only one difficulty
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestNonTaikoBeatmaps()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference
+                new[] { (1000.0, true), (2000.0, false) } // Different settings
+            );
+
+            // Make both beatmaps non-taiko
+            beatmaps[0].BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;
+            beatmaps[1].BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestMixedRulesets()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference
+                new[] { (1000.0, true), (2000.0, false) } // Different settings
+            );
+
+            // Make reference taiko, other non-taiko
+            beatmaps[0].BeatmapInfo.Ruleset = new TaikoRuleset().RulesetInfo;
+            beatmaps[1].BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestMissingTimingPoints()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference has 2 points
+                new[] { (1000.0, false) } // Other has only 1 point (missing 2000.0)
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            // Should only check the existing timing point at 1000.0 (consistent, no issue)
+            // The missing 2000.0 point should be ignored by this check
+            Assert.That(issues, Is.Empty);
+        }
+
+        [Test]
+        public void TestExtraTimingPoints()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false) }, // Reference has 1 point
+                new[] { (1000.0, false), (2000.0, true) } // Other has extra point
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            // Should only check the existing timing point at 1000.0 (consistent, no issue)
+            // The extra 2000.0 point should be ignored by this check
+            Assert.That(issues, Is.Empty);
+        }
+
+        [Test]
+        public void TestMultipleDifficultiesWithInconsistencies()
+        {
+            var beatmaps = createBeatmapSetWithTimingPoints(
+                new[] { (1000.0, false), (2000.0, true) }, // Reference
+                new[] { (1000.0, true), (2000.0, true) }, // First differs
+                new[] { (1000.0, false), (2000.0, false) } // Second differs
+            );
+
+            var context = createContextWithMultipleDifficulties(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            // Should have issues for both other difficulties
+            Assert.That(issues, Has.Count.EqualTo(2)); // 1000.0 from diff2, 2000.0 from diff3
+            Assert.That(issues.All(issue => issue.Template is CheckTaikoInconsistentSkipBarLine.IssueTemplateInconsistentOmitFirstBarLine));
+            Assert.That(issues[0].Time, Is.EqualTo(1000.0));
+            Assert.That(issues[1].Time, Is.EqualTo(2000.0));
+        }
+
+        private IBeatmap[] createBeatmapSetWithTimingPoints(params (double time, bool omitFirstBarLine)[][] timingData)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[timingData.Length];
+
+            for (int i = 0; i < timingData.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithTimingPoints(timingData[i], $"Difficulty {i + 1}");
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+                beatmaps[i].BeatmapInfo.Ruleset = new TaikoRuleset().RulesetInfo;
+            }
+
+            // Configure the beatmapset to contain all the beatmap infos
+            foreach (var beatmap in beatmaps)
+                beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private IBeatmap createBeatmapWithTimingPoints((double time, bool omitFirstBarLine)[] timingData, string difficultyName)
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName,
+                    Metadata = new BeatmapMetadata()
+                }
+            };
+
+            foreach ((double time, bool omitFirstBarLine) in timingData)
+            {
+                beatmap.ControlPointInfo.Add(time, new TimingControlPoint
+                {
+                    BeatLength = 500, // Standard BPM
+                    OmitFirstBarLine = omitFirstBarLine
+                });
+            }
+
+            return beatmap;
+        }
+
+        private BeatmapVerifierContext createContextWithMultipleDifficulties(IBeatmap currentBeatmap, IBeatmap[] allDifficulties)
+        {
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = allDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModFlashlight.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModFlashlight.cs
index 05a408c621..6dbd3478f1 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModFlashlight.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModFlashlight.cs
@@ -3,7 +3,10 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.UI;
 using osuTK;
@@ -12,6 +15,34 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
 {
     public partial class TestSceneTaikoModFlashlight : TaikoModTestScene
     {
+        [Test]
+        public void TestAspectRatios([Values] bool withClassicMod)
+        {
+            if (withClassicMod)
+                CreateModTest(new ModTestData { Mods = new Mod[] { new TaikoModFlashlight(), new TaikoModClassic() }, PassCondition = () => true });
+            else
+                CreateModTest(new ModTestData { Mod = new TaikoModFlashlight(), PassCondition = () => true });
+
+            AddStep("clear dim", () => LocalConfig.SetValue(OsuSetting.DimLevel, 0.0));
+
+            AddStep("reset", () => Stack.FillMode = FillMode.Stretch);
+            AddStep("set to 16:9", () =>
+            {
+                Stack.FillAspectRatio = 16 / 9f;
+                Stack.FillMode = FillMode.Fit;
+            });
+            AddStep("set to 4:3", () =>
+            {
+                Stack.FillAspectRatio = 4 / 3f;
+                Stack.FillMode = FillMode.Fit;
+            });
+            AddSliderStep("aspect ratio", 0.01f, 5f, 1f, v =>
+            {
+                Stack.FillAspectRatio = v;
+                Stack.FillMode = FillMode.Fit;
+            });
+        }
+
         [TestCase(1f)]
         [TestCase(0.5f)]
         [TestCase(1.25f)]
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
index e6d5c51902..5336ea604e 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
@@ -5,10 +5,13 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Mods
 {
@@ -69,5 +72,106 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
                 },
             });
         }
+
+        [Test]
+        public void TestIncreasedVisibilityOnFirstObject()
+        {
+            bool firstHitNeverFadedOut = true;
+            AddStep("enable increased visibility", () => LocalConfig.SetValue(OsuSetting.IncreaseFirstObjectVisibility, true));
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModHidden(),
+                Autoplay = true,
+                PassCondition = () =>
+                {
+                    var firstHit = this.ChildrenOfType<DrawableHit>().FirstOrDefault(h => h.HitObject.StartTime == 100);
+
+                    if (firstHit?.Alpha < 1 && !firstHit.IsHit)
+                        firstHitNeverFadedOut = false;
+
+                    return firstHitNeverFadedOut && checkAllMaxResultJudgements(2).Invoke();
+                },
+                CreateBeatmap = () =>
+                {
+                    var beatmap = new Beatmap<TaikoHitObject>
+                    {
+                        HitObjects = new List<TaikoHitObject>
+                        {
+                            new Hit
+                            {
+                                Type = HitType.Rim,
+                                StartTime = 100,
+                            },
+                            new Hit
+                            {
+                                Type = HitType.Centre,
+                                StartTime = 200,
+                            },
+                        },
+                        BeatmapInfo =
+                        {
+                            Difficulty = new BeatmapDifficulty
+                            {
+                                SliderTickRate = 4,
+                                OverallDifficulty = 0,
+                            },
+                            Ruleset = new TaikoRuleset().RulesetInfo
+                        },
+                    };
+
+                    beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+                    return beatmap;
+                },
+            });
+        }
+
+        [Test]
+        public void TestNoIncreasedVisibilityOnFirstObject()
+        {
+            bool firstHitFadedOut = true;
+            AddStep("enable increased visibility", () => LocalConfig.SetValue(OsuSetting.IncreaseFirstObjectVisibility, false));
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModHidden(),
+                Autoplay = true,
+                PassCondition = () =>
+                {
+                    var firstHit = this.ChildrenOfType<DrawableHit>().FirstOrDefault(h => h.HitObject.StartTime == 100);
+                    firstHitFadedOut |= firstHit?.IsHit == false && firstHit.Alpha < 1;
+                    return firstHitFadedOut && checkAllMaxResultJudgements(2).Invoke();
+                },
+                CreateBeatmap = () =>
+                {
+                    var beatmap = new Beatmap<TaikoHitObject>
+                    {
+                        HitObjects = new List<TaikoHitObject>
+                        {
+                            new Hit
+                            {
+                                Type = HitType.Rim,
+                                StartTime = 100,
+                            },
+                            new Hit
+                            {
+                                Type = HitType.Centre,
+                                StartTime = 200,
+                            },
+                        },
+                        BeatmapInfo =
+                        {
+                            Difficulty = new BeatmapDifficulty
+                            {
+                                SliderTickRate = 4,
+                                OverallDifficulty = 0,
+                            },
+                            Ruleset = new TaikoRuleset().RulesetInfo
+                        },
+                    };
+
+                    beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+                    return beatmap;
+                },
+            });
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs b/osu.Game.Rulesets.Taiko.Tests/TaikoRateAdjustedDisplayDifficultyTest.cs
index 4ab3f502ad..0fb92e0d7d 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
 {
@@ -21,8 +22,9 @@ namespace osu.Game.Rulesets.Taiko.Tests
         {
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty { OverallDifficulty = originalOverallDifficulty };
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, []);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(originalOverallDifficulty));
         }
@@ -32,8 +34,9 @@ namespace osu.Game.Rulesets.Taiko.Tests
         {
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 0.75);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new TaikoModHalfTime()]);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(1.11).Within(0.01));
         }
@@ -43,8 +46,9 @@ namespace osu.Game.Rulesets.Taiko.Tests
         {
             var ruleset = new TaikoRuleset();
             var difficulty = new BeatmapDifficulty();
+            var beatmapInfo = new BeatmapInfo { Difficulty = difficulty };
 
-            var adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(difficulty, 1.5);
+            var adjustedDifficulty = ruleset.GetAdjustedDisplayDifficulty(beatmapInfo, [new TaikoModDoubleTime()]);
 
             Assert.That(adjustedDifficulty.OverallDifficulty, Is.EqualTo(8.89).Within(0.01));
         }
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
index b784fd181f..7d66820e5a 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
@@ -146,7 +146,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
                 case IHasDuration endTimeData:
                 {
-                    double hitMultiplier = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.OverallDifficulty, 3, 5, 7.5) * swell_hit_multiplier;
+                    double hitMultiplier = RequiredSwellHitsPerSecond(beatmap.Difficulty.OverallDifficulty);
 
                     yield return new Swell
                     {
@@ -172,6 +172,9 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             }
         }
 
+        public static double RequiredSwellHitsPerSecond(double overallDifficulty)
+            => IBeatmapDifficultyInfo.DifficultyRange(overallDifficulty, 3, 5, 7.5) * swell_hit_multiplier;
+
         private bool shouldConvertSliderToHits(HitObject obj, IBeatmap beatmap, IHasPath pathData, out int taikoDuration, out double tickSpacing)
         {
             // DO NOT CHANGE OR REFACTOR ANYTHING IN HERE WITHOUT TESTING AGAINST _ALL_ BEATMAPS.
diff --git a/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoAbnormalDifficultySettings.cs b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoAbnormalDifficultySettings.cs
index 38ba7b1b01..edf4d29e38 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoAbnormalDifficultySettings.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoAbnormalDifficultySettings.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Checks
 
         public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diff = context.Beatmap.Difficulty;
+            var diff = context.CurrentDifficulty.Playable.Difficulty;
             Issue? issue;
 
             if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))
diff --git a/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoInconsistentSkipBarLine.cs b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoInconsistentSkipBarLine.cs
new file mode 100644
index 0000000000..621d336f85
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoInconsistentSkipBarLine.cs
@@ -0,0 +1,67 @@
+// 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.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Taiko.Edit.Checks
+{
+    public class CheckTaikoInconsistentSkipBarLine : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Timing, "Inconsistent \"Skip Bar Line\" setting", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateInconsistentOmitFirstBarLine(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.AllDifficulties.Count() <= 1)
+                yield break;
+
+            // Inconsistent bar line omission only matters for osu!taiko difficulties, so only check those
+            var taikoBeatmaps = context.AllDifficulties.Where(b => b.Playable.BeatmapInfo.Ruleset.ShortName == "taiko").ToList();
+
+            if (taikoBeatmaps.Count <= 1)
+                yield break;
+
+            var referenceBeatmap = context.CurrentDifficulty.Playable;
+            var referenceTimingPoints = referenceBeatmap.ControlPointInfo.TimingPoints;
+
+            var otherTaikoBeatmaps = taikoBeatmaps.Where(b => b.Playable != referenceBeatmap).ToList();
+
+            foreach (var beatmap in otherTaikoBeatmaps)
+            {
+                var timingPoints = beatmap.Playable.ControlPointInfo.TimingPoints;
+
+                foreach (var referencePoint in referenceTimingPoints)
+                {
+                    var matchingPoint = TimingCheckUtils.FindExactMatchingTimingPoint(timingPoints, referencePoint.Time);
+
+                    if (matchingPoint == null)
+                        // Inconsistent timing points - that's handled by `CheckInconsistentTimingControlPoints`, so skip
+                        continue;
+
+                    if (referencePoint.OmitFirstBarLine != matchingPoint.OmitFirstBarLine)
+                    {
+                        yield return new IssueTemplateInconsistentOmitFirstBarLine(this).Create(referencePoint.Time, beatmap.Playable.BeatmapInfo.DifficultyName);
+                    }
+                }
+            }
+        }
+
+        public class IssueTemplateInconsistentOmitFirstBarLine : IssueTemplate
+        {
+            public IssueTemplateInconsistentOmitFirstBarLine(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent \"Skip Bar Line\" setting in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoLowestDiffDrainTime.cs b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoLowestDiffDrainTime.cs
new file mode 100644
index 0000000000..8ef911c18e
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoLowestDiffDrainTime.cs
@@ -0,0 +1,21 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks;
+
+namespace osu.Game.Rulesets.Taiko.Edit.Checks
+{
+    public class CheckTaikoLowestDiffDrainTime : CheckLowestDiffDrainTime
+    {
+        protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+        {
+            // See lowest difficulty requirements in https://osu.ppy.sh/wiki/en/Ranking_criteria/osu%21taiko#general
+            yield return (DifficultyRating.Hard, new TimeSpan(0, 3, 30).TotalMilliseconds, "Muzukashii");
+            yield return (DifficultyRating.Insane, new TimeSpan(0, 4, 15).TotalMilliseconds, "Oni");
+            yield return (DifficultyRating.Expert, new TimeSpan(0, 5, 0).TotalMilliseconds, "Inner Oni");
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs b/osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs
index 8f695c4834..737347a64c 100644
--- a/osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs
@@ -17,8 +17,14 @@ namespace osu.Game.Rulesets.Taiko.Edit
             // Compose
             new CheckConcurrentObjects(),
 
+            // Spread
+            new CheckTaikoLowestDiffDrainTime(),
+
             // Settings
             new CheckTaikoAbnormalDifficultySettings(),
+
+            // Timing
+            new CheckTaikoInconsistentSkipBarLine(),
         };
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModConstantSpeed.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModConstantSpeed.cs
index 81973e65cc..e6fd5fc93e 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModConstantSpeed.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModConstantSpeed.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Rulesets.Mods;
@@ -17,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override string Acronym => "CS";
         public override double ScoreMultiplier => 0.9;
         public override LocalisableString Description => "No more tricky speed changes!";
-        public override IconUsage? Icon => FontAwesome.Solid.Equals;
+        public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
         public override ModType Type => ModType.Conversion;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<TaikoHitObject> drawableRuleset)
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs
index 64f2f4c18a..02c06850b7 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs
@@ -47,28 +47,15 @@ namespace osu.Game.Rulesets.Taiko.Mods
             {
                 this.taikoPlayfield = taikoPlayfield;
 
-                FlashlightSize = adjustSizeForPlayfieldAspectRatio(GetSize());
+                FlashlightSize = new Vector2(0, GetSize());
                 FlashlightSmoothness = 1.4f;
 
                 AddLayout(flashlightProperties);
             }
 
-            /// <summary>
-            /// Returns the aspect ratio-adjusted size of the flashlight.
-            /// This ensures that the size of the flashlight remains independent of taiko-specific aspect ratio adjustments.
-            /// </summary>
-            /// <param name="size">
-            /// The size of the flashlight.
-            /// The value provided here should always come from <see cref="ModFlashlight{T}.Flashlight.GetSize"/>.
-            /// </param>
-            private Vector2 adjustSizeForPlayfieldAspectRatio(float size)
-            {
-                return new Vector2(0, size * taikoPlayfield.Parent!.Scale.Y);
-            }
-
             protected override void UpdateFlashlightSize(float size)
             {
-                this.TransformTo(nameof(FlashlightSize), adjustSizeForPlayfieldAspectRatio(size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, size), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";
@@ -82,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
                     FlashlightPosition = ToLocalSpace(taikoPlayfield.HitTarget.ScreenSpaceDrawQuad.Centre);
 
                     ClearTransforms(targetMember: nameof(FlashlightSize));
-                    FlashlightSize = adjustSizeForPlayfieldAspectRatio(GetSize());
+                    FlashlightSize = new Vector2(0, GetSize());
 
                     flashlightProperties.Validate();
                 }
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
index 2c3b4a8d18..8b6fb71d51 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            ApplyNormalVisibilityState(hitObject, state);
+            // intentional no-op
         }
 
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
index 6e9b974fbf..2132121cd2 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
@@ -5,10 +5,12 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -21,6 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override string Acronym => "SR";
         public override double ScoreMultiplier => 0.6;
         public override LocalisableString Description => "Simplify tricky rhythms!";
+        public override IconUsage? Icon => OsuIcon.ModSimplifiedRhythm;
         public override ModType Type => ModType.DifficultyReduction;
 
         [SettingSource("1/3 to 1/2 conversion", "Converts 1/3 patterns to 1/2 rhythm.")]
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModSingleTap.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModSingleTap.cs
index 511278dab0..43c8708565 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModSingleTap.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModSingleTap.cs
@@ -6,9 +6,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -24,6 +26,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
     {
         public override string Name => @"Single Tap";
         public override string Acronym => @"SG";
+        public override IconUsage? Icon => OsuIcon.ModSingleTap;
         public override LocalisableString Description => @"One key for dons, one key for kats.";
 
         public override double ScoreMultiplier => 1.0;
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModSwap.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModSwap.cs
index fc3913f56d..f1feb8153a 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModSwap.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModSwap.cs
@@ -3,8 +3,10 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -16,6 +18,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override string Name => "Swap";
         public override string Acronym => "SW";
         public override LocalisableString Description => @"Dons become kats, kats become dons";
+        public override IconUsage? Icon => OsuIcon.ModSwap;
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModRandom)).ToArray();
diff --git a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
index 1cb41e1299..b25672f719 100644
--- a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
@@ -33,11 +34,13 @@ using osu.Game.Screens.Ranking.Statistics;
 using osu.Game.Skinning;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Configuration;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Scoring.Legacy;
 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 +273,10 @@ namespace osu.Game.Rulesets.Taiko
         }
 
         /// <seealso cref="TaikoHitWindows"/>
-        public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDifficultyInfo difficulty, double rate)
+        public override BeatmapDifficulty GetAdjustedDisplayDifficulty(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
         {
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
+            BeatmapDifficulty adjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            double rate = ModUtils.CalculateRateWithMods(mods);
 
             double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, TaikoHitWindows.GREAT_WINDOW_RANGE);
             greatHitWindow /= rate;
@@ -280,5 +284,46 @@ namespace osu.Game.Rulesets.Taiko
 
             return adjustedDifficulty;
         }
+
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            // `modAdjustedDifficulty` contains only the direct effect of mods.
+            // `effectiveDifficulty` contains the "perceived" effect of rate-adjusting mods on OD and AR.
+            // we make a distinction here, because some of the calculations below will require very careful maneuvering between the two for correct results.
+            var modAdjustedDifficulty = base.GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var effectiveDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+            var colours = new OsuColour();
+
+            // when displaying hit window ranges with rate-changing mods active, we will want to adjust for rate ourselves, as `effectiveDifficulty` may not be accurate
+            // because `TaikoHitWindows` applies a floor-and-round operation that will result in inaccurate results
+            // (the floor-and-round needs to happen *before* rate is taken into account, not after).
+            var hitWindows = new TaikoHitWindows();
+            hitWindows.SetDifficulty(modAdjustedDifficulty.OverallDifficulty);
+            double rate = ModUtils.CalculateRateWithMods(mods);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.Accuracy, @"OD", originalDifficulty.OverallDifficulty, effectiveDifficulty.OverallDifficulty, 10)
+            {
+                Description = "Affects timing requirements for hits and mash rate requirements for swells.",
+                AdditionalMetrics = hitWindows.GetAllAvailableWindows()
+                                              .Reverse()
+                                              .Select(window => new RulesetBeatmapAttribute.AdditionalMetric(
+                                                  $"{window.result.GetDescription().ToUpperInvariant()} hit window",
+                                                  LocalisableString.Interpolate($@"±{hitWindows.WindowFor(window.result) / rate:0.##} ms"),
+                                                  colours.ForHitResult(window.result)
+                                              ))
+                                              .Append(new RulesetBeatmapAttribute.AdditionalMetric("Hits per second required to clear swells", LocalisableString.Interpolate($@"{TaikoBeatmapConverter.RequiredSwellHitsPerSecond(modAdjustedDifficulty.OverallDifficulty):0.#}")))
+                                              .ToArray()
+            };
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, effectiveDifficulty.DrainRate, 10)
+            {
+                Description = "Affects the harshness of health drain and the health penalties for missing."
+            };
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ScrollSpeed, @"SS", 1f, (float)(effectiveDifficulty.SliderMultiplier / originalDifficulty.SliderMultiplier), 4)
+            {
+                Description = "Multiplier applied to the baseline scroll speed of the playfield when no mods are active."
+            };
+        }
     }
 }
diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
index de07e2be01..2815c9cd8f 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
@@ -13,6 +13,7 @@ using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Extensions;
 using osu.Game.IO.Legacy;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Replays;
@@ -321,6 +322,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 CountryCode = CountryCode.PL
             };
             scoreInfo.ClientVersion = "2023.1221.0";
+            scoreInfo.Pauses.AddRange([111111, 222222, 333333]);
 
             var beatmap = new TestBeatmap(ruleset);
             var score = new Score
@@ -345,6 +347,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.That(decodedAfterEncode.ScoreInfo.Mods, Is.EqualTo(scoreInfo.Mods));
                 Assert.That(decodedAfterEncode.ScoreInfo.ClientVersion, Is.EqualTo("2023.1221.0"));
                 Assert.That(decodedAfterEncode.ScoreInfo.RealmUser.OnlineID, Is.EqualTo(3035836));
+                Assert.That(decodedAfterEncode.ScoreInfo.Pauses, Is.EquivalentTo(new[] { 111111, 222222, 333333 }));
             });
         }
 
diff --git a/osu.Game.Tests/Database/BeatmapImporterTests.cs b/osu.Game.Tests/Database/BeatmapImporterTests.cs
index 38746f2567..f3ca665380 100644
--- a/osu.Game.Tests/Database/BeatmapImporterTests.cs
+++ b/osu.Game.Tests/Database/BeatmapImporterTests.cs
@@ -1018,6 +1018,49 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        [Test]
+        public void TestBeatmapFilesInNestedDirectoriesAreIgnored()
+        {
+            RunTestWithRealmAsync(async (realm, storage) =>
+            {
+                var importer = new BeatmapImporter(storage, realm);
+                using var store = new RealmRulesetStore(realm, storage);
+
+                string? temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    var subdirectory = Directory.CreateDirectory(Path.Combine(extractedFolder, "subdir"));
+                    string modifiedCopyPath = Path.Combine(subdirectory.FullName, "duplicate.osu");
+                    File.Copy(Directory.GetFiles(extractedFolder, "*.osu").First(), modifiedCopyPath);
+
+                    using (var stream = File.OpenWrite(modifiedCopyPath))
+                    using (var textWriter = new StreamWriter(stream))
+                        await textWriter.WriteLineAsync("# adding a comment so that the hashes are different");
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    await importer.Import(temp);
+
+                    EnsureLoaded(realm.Realm);
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
         [Test]
         public void TestImportNestedStructure()
         {
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/Editing/Checks/CheckConcurrentObjectsTest.cs b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs
index a255f41653..fd63e1b05d 100644
--- a/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs
@@ -57,6 +57,16 @@ namespace osu.Game.Tests.Editing.Checks
             });
         }
 
+        [Test]
+        public void TestCirclesAlmostConcurrentWarning()
+        {
+            assertAlmostConcurrentSame(new List<HitObject>
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 108 }
+            });
+        }
+
         [Test]
         public void TestSlidersSeparate()
         {
@@ -97,6 +107,16 @@ namespace osu.Game.Tests.Editing.Checks
             });
         }
 
+        [Test]
+        public void TestSliderAndCircleAlmostConcurrent()
+        {
+            assertAlmostConcurrentDifferent(new List<HitObject>
+            {
+                getSliderMock(startTime: 100, endTime: 400.75d).Object,
+                new HitCircle { StartTime = 408 }
+            });
+        }
+
         [Test]
         public void TestManyObjectsConcurrent()
         {
@@ -110,8 +130,14 @@ namespace osu.Game.Tests.Editing.Checks
             var issues = check.Run(getContext(hitobjects)).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(3));
-            Assert.That(issues.Where(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentDifferent).ToList(), Has.Count.EqualTo(2));
-            Assert.That(issues.Any(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent));
+
+            // Should have 1 same-type concurrent (Slider & Slider) and 2 different-type concurrent (Slider & Circle)
+            var sameTypeIssues = issues.Where(issue => issue.ToString().Contains("s are concurrent here")).ToList();
+            var differentTypeIssues = issues.Where(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are concurrent here")).ToList();
+
+            Assert.That(sameTypeIssues, Has.Count.EqualTo(1));
+            Assert.That(differentTypeIssues, Has.Count.EqualTo(2));
         }
 
         private Mock<Slider> getSliderMock(double startTime, double endTime, int repeats = 0)
@@ -144,7 +170,8 @@ namespace osu.Game.Tests.Editing.Checks
             var issues = check.Run(getContext(hitobjects)).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(count));
-            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here")));
         }
 
         private void assertConcurrentDifferent(List<HitObject> hitobjects, int count = 1)
@@ -152,7 +179,26 @@ namespace osu.Game.Tests.Editing.Checks
             var issues = check.Run(getContext(hitobjects)).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(count));
-            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentDifferent));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are concurrent here")));
+        }
+
+        private void assertAlmostConcurrentSame(List<HitObject> hitobjects)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart")));
+        }
+
+        private void assertAlmostConcurrentDifferent(List<HitObject> hitobjects)
+        {
+            var issues = check.Run(getContext(hitobjects)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent));
+            Assert.That(issues.All(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are less than 10ms apart")));
         }
 
         private BeatmapVerifierContext getContext(List<HitObject> hitobjects)
diff --git a/osu.Game.Tests/Editing/Checks/CheckHitsoundsFormatTest.cs b/osu.Game.Tests/Editing/Checks/CheckHitsoundsFormatTest.cs
index cb1cf21734..6da391aa8d 100644
--- a/osu.Game.Tests/Editing/Checks/CheckHitsoundsFormatTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckHitsoundsFormatTest.cs
@@ -117,6 +117,52 @@ namespace osu.Game.Tests.Editing.Checks
             }
         }
 
+        [Test]
+        public void TestBeatmapAudioTracksExemptedFromCheck()
+        {
+            using (var resourceStream = TestResources.OpenResource("Samples/corrupt.wav"))
+            {
+                var beatmapSet = new BeatmapSetInfo
+                {
+                    Files =
+                    {
+                        CheckTestHelpers.CreateMockFile("wav"),
+                        CheckTestHelpers.CreateMockFile("mp3")
+                    }
+                };
+
+                var firstPlayable = new Beatmap<HitObject>
+                {
+                    BeatmapInfo = new BeatmapInfo
+                    {
+                        BeatmapSet = beatmapSet,
+                        Metadata = new BeatmapMetadata { AudioFile = beatmapSet.Files[0].Filename }
+                    }
+                };
+                var firstWorking = new Mock<TestWorkingBeatmap>(firstPlayable, null, null);
+                firstWorking.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
+
+                var secondPlayable = new Beatmap<HitObject>
+                {
+                    BeatmapInfo = new BeatmapInfo
+                    {
+                        BeatmapSet = beatmapSet,
+                        Metadata = new BeatmapMetadata { AudioFile = beatmapSet.Files[1].Filename }
+                    }
+                };
+                var secondWorking = new Mock<TestWorkingBeatmap>(secondPlayable, null, null);
+                secondWorking.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
+
+                var context = new BeatmapVerifierContext(
+                    new BeatmapVerifierContext.VerifiedBeatmap(firstWorking.Object, firstPlayable),
+                    [new BeatmapVerifierContext.VerifiedBeatmap(secondWorking.Object, secondPlayable)],
+                    DifficultyRating.ExpertPlus);
+
+                var issues = check.Run(context).ToList();
+                Assert.That(issues, Is.Empty);
+            }
+        }
+
         private BeatmapVerifierContext getContext(Stream? resourceStream)
         {
             var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
diff --git a/osu.Game.Tests/Editing/Checks/CheckInconsistentAudioTest.cs b/osu.Game.Tests/Editing/Checks/CheckInconsistentAudioTest.cs
new file mode 100644
index 0000000000..2846c3d6d5
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckInconsistentAudioTest.cs
@@ -0,0 +1,151 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Models;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckInconsistentAudioTest
+    {
+        private CheckInconsistentAudio check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckInconsistentAudio();
+        }
+
+        [Test]
+        public void TestConsistentAudio()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio.mp3", "audio.mp3");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestInconsistentAudio()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio1.mp3", "audio2.mp3");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckInconsistentAudio.IssueTemplateInconsistentAudio);
+            Assert.That(issues.Single().ToString(), Contains.Substring("audio1.mp3"));
+            Assert.That(issues.Single().ToString(), Contains.Substring("audio2.mp3"));
+        }
+
+        [Test]
+        public void TestInconsistentAudioWithNull()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio.mp3", null);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckInconsistentAudio.IssueTemplateInconsistentAudio);
+            Assert.That(issues.Single().ToString(), Contains.Substring("audio.mp3"));
+            Assert.That(issues.Single().ToString(), Contains.Substring("not set"));
+        }
+
+        [Test]
+        public void TestInconsistentAudioWithEmptyString()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio.mp3", "");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckInconsistentAudio.IssueTemplateInconsistentAudio);
+            Assert.That(issues.Single().ToString(), Contains.Substring("audio.mp3"));
+            Assert.That(issues.Single().ToString(), Contains.Substring("not set"));
+        }
+
+        [Test]
+        public void TestBothAudioNotSet()
+        {
+            var beatmaps = createBeatmapSetWithAudio("", "");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestMultipleInconsistencies()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio1.mp3", "audio2.mp3", "audio3.mp3");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentAudio.IssueTemplateInconsistentAudio));
+        }
+
+        [Test]
+        public void TestSingleDifficulty()
+        {
+            var beatmaps = createBeatmapSetWithAudio("audio.mp3");
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private IBeatmap createBeatmapWithAudio(string audioFile, RealmNamedFileUsage? file)
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata { AudioFile = audioFile },
+                    BeatmapSet = new BeatmapSetInfo()
+                }
+            };
+
+            if (file != null)
+                beatmap.BeatmapInfo.BeatmapSet!.Files.Add(file);
+
+            return beatmap;
+        }
+
+        private IBeatmap[] createBeatmapSetWithAudio(params string?[] audioFiles)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[audioFiles.Length];
+
+            for (int i = 0; i < audioFiles.Length; i++)
+            {
+                string? audioFile = audioFiles[i];
+                var file = !string.IsNullOrEmpty(audioFile) ? CheckTestHelpers.CreateMockFile("mp3") : null;
+
+                beatmaps[i] = createBeatmapWithAudio(audioFile ?? "", file);
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+                beatmaps[i].BeatmapInfo.DifficultyName = $"Difficulty {i + 1}";
+                beatmapSet.Beatmaps.Add(beatmaps[i].BeatmapInfo);
+            }
+
+            return beatmaps;
+        }
+
+        private BeatmapVerifierContext createContextWithMultipleDifficulties(IBeatmap currentBeatmap, IBeatmap[] allDifficulties)
+        {
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = allDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckInconsistentMetadataTest.cs b/osu.Game.Tests/Editing/Checks/CheckInconsistentMetadataTest.cs
new file mode 100644
index 0000000000..09d731152d
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckInconsistentMetadataTest.cs
@@ -0,0 +1,215 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Models;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckInconsistentMetadataTest
+    {
+        private CheckInconsistentMetadata check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckInconsistentMetadata();
+        }
+
+        [Test]
+        public void TestConsistentMetadata()
+        {
+            var metadata = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata, metadata);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestInconsistentArtist()
+        {
+            var metadata1 = createMetadata("Artist One", "Test Title", "Test Source", "Test Creator", "tag1 tag2");
+            var metadata2 = createMetadata("Artist Two", "Test Title", "Test Source", "Test Creator", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent artist fields"));
+            Assert.That(issues[0].ToString(), Contains.Substring("Artist One"));
+            Assert.That(issues[0].ToString(), Contains.Substring("Artist Two"));
+        }
+
+        [Test]
+        public void TestInconsistentTitle()
+        {
+            var metadata1 = createMetadata("Test Artist", "Title One", "Test Source", "Test Creator", "tag1 tag2");
+            var metadata2 = createMetadata("Test Artist", "Title Two", "Test Source", "Test Creator", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent title fields"));
+        }
+
+        [Test]
+        public void TestInconsistentUnicodeArtist()
+        {
+            var metadata1 = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag2", unicodeArtist: "Test Unicode Artist 1");
+            var metadata2 = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag2", unicodeArtist: "Test Unicode Artist 2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent unicode artist fields"));
+        }
+
+        [Test]
+        public void TestInconsistentSource()
+        {
+            var metadata1 = createMetadata("Test Artist", "Test Title", "Source One", "Test Creator", "tag1 tag2");
+            var metadata2 = createMetadata("Test Artist", "Test Title", "Source Two", "Test Creator", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent source fields"));
+        }
+
+        [Test]
+        public void TestInconsistentCreator()
+        {
+            var metadata1 = createMetadata("Test Artist", "Test Title", "Test Source", "Creator One", "tag1 tag2");
+            var metadata2 = createMetadata("Test Artist", "Test Title", "Test Source", "Creator Two", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent creator fields"));
+        }
+
+        [Test]
+        public void TestInconsistentTags()
+        {
+            var metadata1 = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag2 tag3");
+            var metadata2 = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag4 tag5");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentMetadata.IssueTemplateInconsistentTags);
+            Assert.That(issues[0].ToString(), Contains.Substring("Inconsistent tags"));
+            Assert.That(issues[0].ToString(), Contains.Substring("tag2 tag3 tag4 tag5"));
+        }
+
+        [Test]
+        public void TestMultipleInconsistencies()
+        {
+            var metadata1 = createMetadata("Artist One", "Title One", "Test Source", "Test Creator", "tag1 tag2");
+            var metadata2 = createMetadata("Artist Two", "Title Two", "Test Source", "Test Creator", "tag3 tag4");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(3)); // artist, title, tags
+            Assert.That(issues.Count(i => i.Template is CheckInconsistentMetadata.IssueTemplateInconsistentOtherFields), Is.EqualTo(2));
+            Assert.That(issues.Count(i => i.Template is CheckInconsistentMetadata.IssueTemplateInconsistentTags), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSingleDifficulty()
+        {
+            var metadata = createMetadata("Test Artist", "Test Title", "Test Source", "Test Creator", "tag1 tag2");
+            var beatmaps = createBeatmapSetWithMetadata(metadata);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestEmptyStringFieldsAreConsistent()
+        {
+            var metadata1 = createMetadata("Test Artist", "Test Title", "", "Test Creator", "");
+            var metadata2 = createMetadata("Test Artist", "Test Title", "", "Test Creator", "");
+            var beatmaps = createBeatmapSetWithMetadata(metadata1, metadata2);
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private BeatmapMetadata createMetadata(string artist, string title, string source, string creator, string tags, string unicodeArtist = "", string unicodeTitle = "")
+        {
+            return new BeatmapMetadata(new RealmUser { Username = creator })
+            {
+                Artist = artist,
+                Title = title,
+                Source = source,
+                Tags = tags,
+                ArtistUnicode = unicodeArtist,
+                TitleUnicode = unicodeTitle
+            };
+        }
+
+        private IBeatmap[] createBeatmapSetWithMetadata(params BeatmapMetadata[] metadata)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[metadata.Length];
+
+            for (int i = 0; i < metadata.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithMetadata(metadata[i], $"Difficulty {i + 1}");
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+            }
+
+            // Configure the beatmapset to contain all the beatmap infos
+            foreach (var beatmap in beatmaps)
+                beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private Beatmap createBeatmapWithMetadata(BeatmapMetadata metadata, string difficultyName)
+        {
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName,
+                    Metadata = metadata
+                }
+            };
+        }
+
+        private BeatmapVerifierContext createContextWithMultipleDifficulties(IBeatmap currentBeatmap, IBeatmap[] allDifficulties)
+        {
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = allDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckInconsistentSettingsTest.cs b/osu.Game.Tests/Editing/Checks/CheckInconsistentSettingsTest.cs
new file mode 100644
index 0000000000..079c6855a9
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckInconsistentSettingsTest.cs
@@ -0,0 +1,272 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osuTK;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckInconsistentSettingsTest
+    {
+        private CheckInconsistentSettings check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckInconsistentSettings();
+        }
+
+        [Test]
+        public void TestConsistentSettings()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(audioLeadIn: 1000, countdown: CountdownType.Normal, epilepsyWarning: false),
+                createSettings(audioLeadIn: 1000, countdown: CountdownType.Normal, epilepsyWarning: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestInconsistentAudioLeadIn()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(audioLeadIn: 1000),
+                createSettings(audioLeadIn: 2000)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Audio lead-in"));
+            Assert.That(issues[0].ToString(), Contains.Substring("1000"));
+            Assert.That(issues[0].ToString(), Contains.Substring("2000"));
+        }
+
+        [Test]
+        public void TestInconsistentCountdown()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(countdown: CountdownType.Normal),
+                createSettings(countdown: CountdownType.None)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Countdown"));
+            Assert.That(issues[0].ToString(), Contains.Substring("Normal"));
+            Assert.That(issues[0].ToString(), Contains.Substring("None"));
+        }
+
+        [Test]
+        public void TestInconsistentCountdownOffset()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(countdownOffset: 100),
+                createSettings(countdownOffset: 200)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Countdown offset"));
+        }
+
+        [Test]
+        public void TestInconsistentEpilepsyWarning()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(epilepsyWarning: true),
+                createSettings(epilepsyWarning: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Epilepsy warning"));
+        }
+
+        [Test]
+        public void TestInconsistentLetterboxInBreaks()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(letterboxInBreaks: true),
+                createSettings(letterboxInBreaks: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Letterbox during breaks"));
+        }
+
+        [Test]
+        public void TestInconsistentSamplesMatchPlaybackRate()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(samplesMatchPlaybackRate: true),
+                createSettings(samplesMatchPlaybackRate: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Samples match playback rate"));
+        }
+
+        [Test]
+        public void TestInconsistentWidescreenSupport()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(widescreenStoryboard: true),
+                createSettings(widescreenStoryboard: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestInconsistentWidescreenSupportWithStoryboard()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(widescreenStoryboard: true),
+                createSettings(widescreenStoryboard: false)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps, hasStoryboard: true);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Widescreen support"));
+        }
+
+        [Test]
+        public void TestInconsistentSliderTickRate()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(sliderTickRate: 1.0),
+                createSettings(sliderTickRate: 2.0)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues[0].Template is CheckInconsistentSettings.IssueTemplateInconsistentSetting);
+            Assert.That(issues[0].ToString(), Contains.Substring("Tick Rate"));
+        }
+
+        [Test]
+        public void TestMultipleInconsistencies()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(audioLeadIn: 1000, countdown: CountdownType.Normal, epilepsyWarning: false),
+                createSettings(audioLeadIn: 2000, countdown: CountdownType.None, epilepsyWarning: true)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(3));
+            Assert.That(issues.Count(i => i.ToString().Contains("Audio lead-in")), Is.EqualTo(1));
+            Assert.That(issues.Count(i => i.ToString().Contains("Countdown")), Is.EqualTo(1));
+            Assert.That(issues.Count(i => i.ToString().Contains("Epilepsy warning")), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSingleDifficulty()
+        {
+            var beatmaps = createBeatmapSetWithSettings(
+                createSettings(audioLeadIn: 1000)
+            );
+            var context = createContextWithMultipleDifficulties(beatmaps.First(), beatmaps);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private Beatmap createSettings(
+            double audioLeadIn = 0,
+            CountdownType countdown = CountdownType.None,
+            int countdownOffset = 0,
+            bool epilepsyWarning = false,
+            bool letterboxInBreaks = false,
+            bool samplesMatchPlaybackRate = false,
+            bool widescreenStoryboard = false,
+            double sliderTickRate = 1.0)
+        {
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = "Test Difficulty",
+                    StarRating = 5.0
+                },
+                AudioLeadIn = audioLeadIn,
+                Countdown = countdown,
+                CountdownOffset = countdownOffset,
+                EpilepsyWarning = epilepsyWarning,
+                LetterboxInBreaks = letterboxInBreaks,
+                SamplesMatchPlaybackRate = samplesMatchPlaybackRate,
+                WidescreenStoryboard = widescreenStoryboard,
+                Difficulty = new BeatmapDifficulty
+                {
+                    SliderTickRate = sliderTickRate
+                }
+            };
+        }
+
+        private IBeatmap[] createBeatmapSetWithSettings(params IBeatmap[] beatmaps)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+
+            for (int i = 0; i < beatmaps.Length; i++)
+            {
+                beatmaps[i].BeatmapInfo.DifficultyName = $"Difficulty {i + 1}";
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+                beatmapSet.Beatmaps.Add(beatmaps[i].BeatmapInfo);
+            }
+
+            return beatmaps;
+        }
+
+        private BeatmapVerifierContext createContextWithMultipleDifficulties(IBeatmap currentBeatmap, IBeatmap[] allDifficulties, bool hasStoryboard = false)
+        {
+            Storyboard? storyboard = null;
+
+            if (hasStoryboard)
+            {
+                storyboard = new Storyboard();
+                storyboard.GetLayer("Background").Add(new StoryboardSprite("test.png", Anchor.Centre, Vector2.Zero));
+            }
+
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap, storyboard), currentBeatmap);
+            var verifiedOtherBeatmaps = allDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b, storyboard), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckInconsistentTimingControlPointsTest.cs b/osu.Game.Tests/Editing/Checks/CheckInconsistentTimingControlPointsTest.cs
new file mode 100644
index 0000000000..afcb38c858
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckInconsistentTimingControlPointsTest.cs
@@ -0,0 +1,254 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckInconsistentTimingControlPointsTest
+    {
+        private CheckInconsistentTimingControlPoints check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckInconsistentTimingControlPoints();
+        }
+
+        [Test]
+        public void TestConsistentTiming()
+        {
+            var beatmaps = createBeatmapSetWithTiming(
+                new[] { 1000.0, 2000.0 }, // Timing at 1000ms and 2000ms
+                new[] { 1000.0, 2000.0 } // Same timing
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestMissingTimingPoint()
+        {
+            var beatmaps = createBeatmapSetWithTiming(
+                new[] { 1000.0, 2000.0 }, // Reference has timing at 1000ms and 2000ms
+                new[] { 1000.0 } // Second difficulty missing timing at 2000ms
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentTimingControlPoints.IssueTemplateMissingTimingPoint));
+        }
+
+        [Test]
+        public void TestInconsistentBPM()
+        {
+            var beatmaps = createBeatmapSetWithBPM(
+                new[] { (1000.0, 500.0) }, // Reference: 120 BPM (500ms beat length)
+                new[] { (1000.0, 600.0) } // Second: 100 BPM (600ms beat length)
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentTimingControlPoints.IssueTemplateInconsistentBPM));
+        }
+
+        [Test]
+        public void TestInconsistentMeter()
+        {
+            var beatmaps = createBeatmapSetWithMeter(
+                new[] { (1000.0, TimeSignature.SimpleQuadruple) }, // Reference: 4/4
+                new[] { (1000.0, TimeSignature.SimpleTriple) } // Second: 3/4
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentTimingControlPoints.IssueTemplateInconsistentMeter));
+        }
+
+        [Test]
+        public void TestDecimalOffset()
+        {
+            var beatmaps = createBeatmapSetWithTiming(
+                new[] { 1000.0 }, // Reference at exactly 1000ms
+                new[] { 1000.5 } // Second at 1000.5ms (decimal difference)
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentTimingControlPoints.IssueTemplateMissingTimingPointMinor));
+        }
+
+        [Test]
+        public void TestSingleDifficulty()
+        {
+            var beatmaps = createBeatmapSetWithTiming(
+                new[] { 1000.0, 2000.0 } // Only one difficulty
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestExtraTimingPoint()
+        {
+            var beatmaps = createBeatmapSetWithTiming(
+                new[] { 1000.0 }, // Reference has timing at 1000ms
+                new[] { 1000.0, 2000.0 } // Second has additional timing at 2000ms
+            );
+
+            var context = createContext(beatmaps[0], beatmaps);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.All(issue => issue.Template is CheckInconsistentTimingControlPoints.IssueTemplateExtraTimingPoint));
+        }
+
+        private IBeatmap[] createBeatmapSetWithTiming(params double[][] timingPoints)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[timingPoints.Length];
+
+            for (int i = 0; i < timingPoints.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithTiming(timingPoints[i], $"Difficulty {i + 1}");
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+            }
+
+            foreach (var beatmap in beatmaps)
+                beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private IBeatmap[] createBeatmapSetWithBPM(params (double time, double beatLength)[][] timingData)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[timingData.Length];
+
+            for (int i = 0; i < timingData.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithBPM(timingData[i], $"Difficulty {i + 1}");
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+            }
+
+            foreach (var beatmap in beatmaps)
+                beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private IBeatmap[] createBeatmapSetWithMeter(params (double time, TimeSignature meter)[][] timingData)
+        {
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[timingData.Length];
+
+            for (int i = 0; i < timingData.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithMeter(timingData[i], $"Difficulty {i + 1}");
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+            }
+
+            foreach (var beatmap in beatmaps)
+                beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private IBeatmap createBeatmapWithTiming(double[] timingPoints, string difficultyName)
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName,
+                    Metadata = new BeatmapMetadata()
+                },
+                ControlPointInfo = new ControlPointInfo()
+            };
+
+            foreach (double time in timingPoints)
+            {
+                beatmap.ControlPointInfo.Add(time, new TimingControlPoint
+                {
+                    BeatLength = 500 // 120 BPM
+                });
+            }
+
+            return beatmap;
+        }
+
+        private IBeatmap createBeatmapWithBPM((double time, double beatLength)[] timingData, string difficultyName)
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName,
+                    Metadata = new BeatmapMetadata()
+                },
+                ControlPointInfo = new ControlPointInfo()
+            };
+
+            foreach ((double time, double beatLength) in timingData)
+            {
+                beatmap.ControlPointInfo.Add(time, new TimingControlPoint
+                {
+                    BeatLength = beatLength
+                });
+            }
+
+            return beatmap;
+        }
+
+        private IBeatmap createBeatmapWithMeter((double time, TimeSignature meter)[] timingData, string difficultyName)
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName,
+                    Metadata = new BeatmapMetadata()
+                },
+                ControlPointInfo = new ControlPointInfo()
+            };
+
+            foreach ((double time, var meter) in timingData)
+            {
+                beatmap.ControlPointInfo.Add(time, new TimingControlPoint
+                {
+                    BeatLength = 500, // 120 BPM
+                    TimeSignature = meter
+                });
+            }
+
+            return beatmap;
+        }
+
+        private BeatmapVerifierContext createContext(IBeatmap currentBeatmap, IBeatmap[] allDifficulties)
+        {
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = allDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckLowestDiffDrainTimeTest.cs b/osu.Game.Tests/Editing/Checks/CheckLowestDiffDrainTimeTest.cs
new file mode 100644
index 0000000000..91333d2916
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckLowestDiffDrainTimeTest.cs
@@ -0,0 +1,251 @@
+// 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.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckLowestDiffDrainTimeTest
+    {
+        private TestCheckLowestDiffDrainTime check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new TestCheckLowestDiffDrainTime();
+        }
+
+        [Test]
+        public void TestSingleDifficultyMeetsRequirement()
+        {
+            var beatmap = createBeatmapWithDrainTime(4 * 60 * 1000, 3.5, "Hard"); // 4 minutes
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestSingleDifficultyTooShort()
+        {
+            var beatmap = createBeatmapWithDrainTime(2 * 60 * 1000, 3.5, "Hard"); // 2 minutes - too short for Hard
+            assertTooShort(beatmap);
+        }
+
+        [Test]
+        public void TestHardDifficultyAtThreshold()
+        {
+            var beatmap = createBeatmapWithDrainTime((3 * 60 + 30) * 1000, 3.5, "Hard"); // Exactly 3:30
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestHardDifficultyJustUnderThreshold()
+        {
+            var beatmap = createBeatmapWithDrainTime((3 * 60 + 29) * 1000, 3.5, "Hard"); // 3:29 - just under threshold
+            assertTooShort(beatmap);
+        }
+
+        [Test]
+        public void TestInsaneDifficultyAtThreshold()
+        {
+            var beatmap = createBeatmapWithDrainTime((4 * 60 + 15) * 1000, 4.5, "Insane"); // Exactly 4:15
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestInsaneDifficultyTooShort()
+        {
+            var beatmap = createBeatmapWithDrainTime(4 * 60 * 1000, 4.5, "Insane"); // 4:00 - too short for Insane
+            assertTooShort(beatmap);
+        }
+
+        [Test]
+        public void TestExpertDifficultyAtThreshold()
+        {
+            var beatmap = createBeatmapWithDrainTime(5 * 60 * 1000, 5.5, "Expert"); // Exactly 5:00
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestExpertDifficultyTooShort()
+        {
+            var beatmap = createBeatmapWithDrainTime((4 * 60 + 30) * 1000, 5.5, "Expert"); // 4:30 - too short for Expert
+            assertTooShort(beatmap);
+        }
+
+        [Test]
+        public void TestEasyDifficultyMeetsRequirement()
+        {
+            var beatmap = createBeatmapWithDrainTime(2 * 60 * 1000, 1.5, "Easy"); // 2 minutes - should be ok for Easy
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestNormalDifficultyMeetsRequirement()
+        {
+            var beatmap = createBeatmapWithDrainTime(2 * 60 * 1000, 2.5, "Normal"); // 2 minutes - should be ok for Normal
+            assertOk(beatmap);
+        }
+
+        [Test]
+        public void TestMultipleDifficultiesMeetsRequirement()
+        {
+            var difficulties = new List<IBeatmap>
+            {
+                createBeatmapWithDrainTime((3 * 60 + 30) * 1000, 3.5, "Hard"), // Hard - lowest difficulty, 3:30
+                createBeatmapWithDrainTime((3 * 60 + 30) * 1000, 4.5, "Insane"),
+                createBeatmapWithDrainTime((3 * 60 + 30) * 1000, 5.5, "Expert")
+            };
+
+            // All should be ok because lowest difficulty is Hard and drain time meets Hard requirement
+            assertOkWithMultipleDifficulties(difficulties[0], difficulties);
+            assertOkWithMultipleDifficulties(difficulties[1], difficulties);
+            assertOkWithMultipleDifficulties(difficulties[2], difficulties);
+        }
+
+        [Test]
+        public void TestMultipleDifficultiesTooShort()
+        {
+            var difficulties = new List<IBeatmap>
+            {
+                createBeatmapWithDrainTime(4 * 60 * 1000, 4.5, "Insane"), // Insane - lowest difficulty, 4:00
+                createBeatmapWithDrainTime(4 * 60 * 1000, 5.5, "Expert") // Same drain time
+            };
+
+            // Should be too short because lowest difficulty is Insane and requires 4:15
+            assertTooShortWithMultipleDifficulties(difficulties[0], difficulties);
+            assertTooShortWithMultipleDifficulties(difficulties[1], difficulties);
+        }
+
+        [Test]
+        public void TestPlayTimeVsDrainTimeNotHighestDifficulty()
+        {
+            var expertBeatmap = createBeatmapWithPlayTime(5 * 60 * 1000, 5.5, "Expert"); // 5:00 play time
+            expertBeatmap.Breaks.Add(new BreakPeriod(60000, 100000)); // 40-second break
+
+            var difficulties = new List<IBeatmap>
+            {
+                expertBeatmap, // Expert - 5:00 play, 4:20 drain
+                createBeatmapWithPlayTime(5 * 60 * 1000, 6.5, "ExpertPlus") // ExpertPlus - highest difficulty
+            };
+
+            // The Expert difficulty (not highest) should use play time (5:00) and pass the Expert requirement
+            assertOkWithMultipleDifficulties(difficulties[0], difficulties);
+        }
+
+        [Test]
+        public void TestPlayTimeVsDrainTimeHighestDifficulty()
+        {
+            var expertBeatmap = createBeatmapWithPlayTime(5 * 60 * 1000, 5.5, "Expert"); // 5:00 play time
+            expertBeatmap.Breaks.Add(new BreakPeriod(60000, 100000)); // 40-second break
+
+            // As the highest difficulty with breaks > 30s, it should use drain time and fail
+            assertTooShort(expertBeatmap);
+        }
+
+        private IBeatmap createBeatmapWithDrainTime(double drainTimeMs, double starRating = 3.5, string difficultyName = "Default")
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    StarRating = starRating,
+                    DifficultyName = difficultyName,
+                    Ruleset = new OsuRuleset().RulesetInfo
+                },
+                HitObjects = new List<HitObject>
+                {
+                    new HitObject { StartTime = 0 },
+                    new HitObject { StartTime = drainTimeMs } // Last object at drain time
+                }
+            };
+
+            return beatmap;
+        }
+
+        private IBeatmap createBeatmapWithPlayTime(double playTimeMs, double starRating = 3.5, string difficultyName = "Default")
+        {
+            var beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    StarRating = starRating,
+                    DifficultyName = difficultyName,
+                    Ruleset = new OsuRuleset().RulesetInfo
+                },
+                HitObjects = new List<HitObject>
+                {
+                    new HitObject { StartTime = 0 },
+                    new HitObject { StartTime = playTimeMs } // Last object at play time
+                }
+            };
+
+            return beatmap;
+        }
+
+        private void assertOk(IBeatmap beatmap)
+        {
+            var difficultyRating = StarDifficulty.GetDifficultyRating(beatmap.BeatmapInfo.StarRating);
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap), difficultyRating);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private void assertTooShort(IBeatmap beatmap)
+        {
+            var difficultyRating = StarDifficulty.GetDifficultyRating(beatmap.BeatmapInfo.StarRating);
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap), difficultyRating);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.First().Template is CheckLowestDiffDrainTime.IssueTemplateTooShort);
+        }
+
+        private void assertOkWithMultipleDifficulties(IBeatmap currentBeatmap, IEnumerable<IBeatmap> allDifficulties)
+        {
+            var context = createContextWithMultipleDifficulties(currentBeatmap, allDifficulties);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private void assertTooShortWithMultipleDifficulties(IBeatmap currentBeatmap, IEnumerable<IBeatmap> allDifficulties)
+        {
+            var context = createContextWithMultipleDifficulties(currentBeatmap, allDifficulties);
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.First().Template is CheckLowestDiffDrainTime.IssueTemplateTooShort);
+        }
+
+        private BeatmapVerifierContext createContextWithMultipleDifficulties(IBeatmap currentBeatmap, IEnumerable<IBeatmap> allDifficulties)
+        {
+            var difficultiesArray = allDifficulties.ToArray();
+            var currentDifficultyRating = StarDifficulty.GetDifficultyRating(currentBeatmap.BeatmapInfo.StarRating);
+
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = difficultiesArray.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, currentDifficultyRating);
+        }
+
+        private class TestCheckLowestDiffDrainTime : CheckLowestDiffDrainTime
+        {
+            protected override IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds()
+            {
+                // Same thresholds as `CheckOsuLowestDiffDrainTime` for testing
+                yield return (DifficultyRating.Hard, new TimeSpan(0, 3, 30).TotalMilliseconds, "Hard");
+                yield return (DifficultyRating.Insane, new TimeSpan(0, 4, 15).TotalMilliseconds, "Insane");
+                yield return (DifficultyRating.Expert, new TimeSpan(0, 5, 0).TotalMilliseconds, "Expert");
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckMissingGenreLanguageTest.cs b/osu.Game.Tests/Editing/Checks/CheckMissingGenreLanguageTest.cs
new file mode 100644
index 0000000000..df5b207ce7
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckMissingGenreLanguageTest.cs
@@ -0,0 +1,184 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckMissingGenreLanguageTest
+    {
+        private CheckMissingGenreLanguage check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckMissingGenreLanguage();
+        }
+
+        [Test]
+        public void TestHasGenreAndLanguage()
+        {
+            var beatmap = createBeatmapWithTags("rock english instrumental");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestHasGenreOnly()
+        {
+            var beatmap = createBeatmapWithTags("electronic pop");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage);
+        }
+
+        [Test]
+        public void TestHasLanguageOnly()
+        {
+            var beatmap = createBeatmapWithTags("japanese instrumental");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingGenre);
+        }
+
+        [Test]
+        public void TestMissingBoth()
+        {
+            var beatmap = createBeatmapWithTags("tag1 tag2 tag3");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingGenre));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage));
+        }
+
+        [Test]
+        public void TestMultiWordGenreHipHop()
+        {
+            var beatmap = createBeatmapWithTags("hip hop music");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage);
+        }
+
+        [Test]
+        public void TestScatteredMultiWordGenre()
+        {
+            var beatmap = createBeatmapWithTags("video hip game hop ost");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage);
+        }
+
+        [Test]
+        public void TestCaseInsensitive()
+        {
+            var beatmap = createBeatmapWithTags("ROCK JAPANESE");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestMixedCase()
+        {
+            var beatmap = createBeatmapWithTags("Rock Japanese");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestSingleWordGenre()
+        {
+            var beatmap = createBeatmapWithTags("electronic");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage);
+        }
+
+        [Test]
+        public void TestSingleWordLanguage()
+        {
+            var beatmap = createBeatmapWithTags("instrumental");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckMissingGenreLanguage.IssueTemplateMissingGenre);
+        }
+
+        [Test]
+        public void TestEmptyTags()
+        {
+            var beatmap = createBeatmapWithTags("");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingGenre));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage));
+        }
+
+        [Test]
+        public void TestPartialMultiWordMatch()
+        {
+            // Should not match if only one word is found
+            var beatmap = createBeatmapWithTags("hip music");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingGenre));
+            Assert.That(issues.Any(issue => issue.Template is CheckMissingGenreLanguage.IssueTemplateMissingLanguage));
+        }
+
+        [Test]
+        public void TestGenreAndLanguageWithExtraTags()
+        {
+            var beatmap = createBeatmapWithTags("tag1 rock tag2 english tag3");
+            var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        private IBeatmap createBeatmapWithTags(string tags)
+        {
+            return new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata { Tags = tags }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game.Tests/Editing/Checks/CheckPreviewTimeTest.cs b/osu.Game.Tests/Editing/Checks/CheckPreviewTimeTest.cs
index 37b01da6ee..7fbe822e8d 100644
--- a/osu.Game.Tests/Editing/Checks/CheckPreviewTimeTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckPreviewTimeTest.cs
@@ -1,7 +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 System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
@@ -16,8 +16,6 @@ namespace osu.Game.Tests.Editing.Checks
     {
         private CheckPreviewTime check = null!;
 
-        private IBeatmap beatmap = null!;
-
         [SetUp]
         public void Setup()
         {
@@ -27,62 +25,69 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestPreviewTimeNotSet()
         {
-            setNoPreviewTimeBeatmap();
-            var content = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+            // single difficulty with no preview time
+            var current = createBeatmapWithPreviewPoint(-1, "Current");
+            var context = createContext(current, Array.Empty<IBeatmap>());
 
-            var issues = check.Run(content).ToList();
+            var issues = check.Run(context).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(1));
             Assert.That(issues.Single().Template is CheckPreviewTime.IssueTemplateHasNoPreviewTime);
         }
 
         [Test]
-        public void TestPreviewTimeconflict()
+        public void TestPreviewTimeConflict()
         {
-            setPreviewTimeConflictBeatmap();
+            var beatmaps = createBeatmapSetWithPreviewPoint(
+                ("Current", 10),
+                ("Test1", 5),
+                ("Test2", 10)
+            );
 
-            var content = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+            var context = createContext(beatmaps[0], new[] { beatmaps[1], beatmaps[2] });
 
-            var issues = check.Run(content).ToList();
+            var issues = check.Run(context).ToList();
 
             Assert.That(issues, Has.Count.EqualTo(1));
             Assert.That(issues.Single().Template is CheckPreviewTime.IssueTemplatePreviewTimeConflict);
             Assert.That(issues.Single().Arguments.FirstOrDefault()?.ToString() == "Test1");
         }
 
-        private void setNoPreviewTimeBeatmap()
+        private IBeatmap[] createBeatmapSetWithPreviewPoint(params (string name, int preview)[] entries)
         {
-            beatmap = new Beatmap<HitObject>
+            var beatmapSet = new BeatmapSetInfo();
+            var beatmaps = new IBeatmap[entries.Length];
+
+            for (int i = 0; i < entries.Length; i++)
+            {
+                beatmaps[i] = createBeatmapWithPreviewPoint(entries[i].preview, entries[i].name);
+                beatmaps[i].BeatmapInfo.BeatmapSet = beatmapSet;
+            }
+
+            foreach (var b in beatmaps)
+                beatmapSet.Beatmaps.Add(b.BeatmapInfo);
+
+            return beatmaps;
+        }
+
+        private IBeatmap createBeatmapWithPreviewPoint(int previewTime, string difficultyName)
+        {
+            return new Beatmap<HitObject>
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    Metadata = new BeatmapMetadata { PreviewTime = -1 },
+                    DifficultyName = difficultyName,
+                    Metadata = new BeatmapMetadata { PreviewTime = previewTime }
                 }
             };
         }
 
-        private void setPreviewTimeConflictBeatmap()
+        private BeatmapVerifierContext createContext(IBeatmap currentBeatmap, IBeatmap[] otherDifficulties)
         {
-            beatmap = new Beatmap<HitObject>
-            {
-                BeatmapInfo = new BeatmapInfo
-                {
-                    Metadata = new BeatmapMetadata { PreviewTime = 10 },
-                    BeatmapSet = new BeatmapSetInfo(new List<BeatmapInfo>
-                    {
-                        new BeatmapInfo
-                        {
-                            DifficultyName = "Test1",
-                            Metadata = new BeatmapMetadata { PreviewTime = 5 },
-                        },
-                        new BeatmapInfo
-                        {
-                            DifficultyName = "Test2",
-                            Metadata = new BeatmapMetadata { PreviewTime = 10 },
-                        },
-                    })
-                }
-            };
+            var verifiedCurrentBeatmap = new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(currentBeatmap), currentBeatmap);
+            var verifiedOtherBeatmaps = otherDifficulties.Select(b => new BeatmapVerifierContext.VerifiedBeatmap(new TestWorkingBeatmap(b), b)).ToList();
+
+            return new BeatmapVerifierContext(verifiedCurrentBeatmap, verifiedOtherBeatmaps, DifficultyRating.ExpertPlus);
         }
     }
 }
diff --git a/osu.Game.Tests/Editing/Checks/CheckVideoUsageTest.cs b/osu.Game.Tests/Editing/Checks/CheckVideoUsageTest.cs
new file mode 100644
index 0000000000..8e332fb405
--- /dev/null
+++ b/osu.Game.Tests/Editing/Checks/CheckVideoUsageTest.cs
@@ -0,0 +1,179 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckVideoUsageTest
+    {
+        private CheckVideoUsage check = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckVideoUsage();
+        }
+
+        [Test]
+        public void TestConsistentVideoUsage()
+        {
+            var beatmap1 = createBeatmapWithVideo("Diff 1", "video.mp4", 1000);
+            var beatmap2 = createBeatmapWithVideo("Diff 2", "video.mp4", 1000);
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestDifferentVideoFile()
+        {
+            var beatmap1 = createBeatmapWithVideo("Diff 1", "videoA.mp4", 0);
+            var beatmap2 = createBeatmapWithVideo("Diff 2", "videoB.mp4", 500);
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckVideoUsage.IssueTemplateDifferentVideo);
+        }
+
+        [Test]
+        public void TestDifferentStartTime()
+        {
+            var beatmap1 = createBeatmapWithVideo("Diff 1", "video.mp4", 0);
+            var beatmap2 = createBeatmapWithVideo("Diff 2", "video.mp4", 500);
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckVideoUsage.IssueTemplateDifferentStartTime);
+        }
+
+        [Test]
+        public void TestOtherDifficultyMissingVideo()
+        {
+            var beatmap1 = createBeatmapWithVideo("Diff 1", "video.mp4", 0);
+            var beatmap2 = createBeatmapWithoutVideo("Diff 2");
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckVideoUsage.IssueTemplateMissingVideo);
+        }
+
+        [Test]
+        public void TestCurrentDifficultyMissingVideo()
+        {
+            var beatmap1 = createBeatmapWithoutVideo("Diff 1");
+            var beatmap2 = createBeatmapWithVideo("Diff 2", "video.mp4", 0);
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckVideoUsage.IssueTemplateMissingVideo);
+        }
+
+        [Test]
+        public void TestBothDifficultiesMissingVideo()
+        {
+            var beatmap1 = createBeatmapWithoutVideo("Diff 1");
+            var beatmap2 = createBeatmapWithoutVideo("Diff 2");
+
+            var context = createContext(beatmap1, [beatmap2]);
+
+            Assert.That(check.Run(context), Is.Empty);
+        }
+
+        [Test]
+        public void TestPairwiseStartTimeMismatchAcrossNonCurrentDifficulties()
+        {
+            var beatmapCurrent = createBeatmapWithVideo("Diff A", "A.mp4", 0);
+            var beatmapB = createBeatmapWithVideo("Diff B", "X.mp4", 1000);
+            var beatmapC = createBeatmapWithVideo("Diff C", "X.mp4", 2000);
+
+            var context = createContext(beatmapCurrent, [beatmapB, beatmapC]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(3));
+            Assert.That(issues.Count(i => i.Template is CheckVideoUsage.IssueTemplateDifferentVideo), Is.EqualTo(2));
+            Assert.That(issues.Count(i => i.Template is CheckVideoUsage.IssueTemplateDifferentStartTime), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestPairwiseStartTimeMismatchWhenCurrentMissingVideo()
+        {
+            var beatmapCurrent = createBeatmapWithoutVideo("Diff A");
+            var beatmapB = createBeatmapWithVideo("Diff B", "X.mp4", 1000);
+            var beatmapC = createBeatmapWithVideo("Diff C", "X.mp4", 2000);
+
+            var context = createContext(beatmapCurrent, [beatmapB, beatmapC]);
+
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(2));
+            Assert.That(issues.Count(i => i.Template is CheckVideoUsage.IssueTemplateMissingVideo), Is.EqualTo(1));
+            Assert.That(issues.Count(i => i.Template is CheckVideoUsage.IssueTemplateDifferentStartTime), Is.EqualTo(1));
+        }
+
+        private BeatmapVerifierContext.VerifiedBeatmap createBeatmapWithVideo(string difficultyName, string path, double startTime)
+        {
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName
+                }
+            };
+
+            var storyboard = new Storyboard();
+            storyboard.GetLayer("Video").Add(new StoryboardVideo(path, startTime));
+
+            var working = new TestWorkingBeatmap(beatmap, storyboard);
+            return new BeatmapVerifierContext.VerifiedBeatmap(working, beatmap);
+        }
+
+        private BeatmapVerifierContext.VerifiedBeatmap createBeatmapWithoutVideo(string difficultyName)
+        {
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    DifficultyName = difficultyName
+                }
+            };
+
+            var storyboard = new Storyboard();
+            // no video added
+            var working = new TestWorkingBeatmap(beatmap, storyboard);
+            return new BeatmapVerifierContext.VerifiedBeatmap(working, beatmap);
+        }
+
+        private BeatmapVerifierContext createContext(BeatmapVerifierContext.VerifiedBeatmap current, BeatmapVerifierContext.VerifiedBeatmap[] others)
+        {
+            return new BeatmapVerifierContext(
+                current,
+                others.ToList(),
+                DifficultyRating.ExpertPlus
+            );
+        }
+    }
+}
+
+
diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
index 1efcc8542d..db76782350 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
@@ -1,7 +1,9 @@
 // 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.Bindables;
 using osu.Game.Beatmaps;
@@ -40,6 +42,11 @@ namespace osu.Game.Tests.NonVisual.Filtering
                 Author = { Username = "The Author" },
                 Source = "unit tests",
                 Tags = "look for tags too",
+                UserTags =
+                {
+                    "song representation/simple",
+                    "style/clean",
+                }
             },
             DifficultyName = "version as well",
             Length = 2500,
@@ -292,6 +299,69 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
+        [TestCase("simple", false)]
+        [TestCase("\"style/clean\"", false)]
+        [TestCase("\"style/clean\"!", false)]
+        [TestCase("iNiS-style", true)]
+        [TestCase("\"reading/visually dense\"!", true)]
+        public void TestCriteriaMatchingUserTags(string query, bool filtered)
+        {
+            var beatmap = getExampleBeatmap();
+            var criteria = new FilterCriteria { UserTags = [new FilterCriteria.OptionalTextFilter { SearchTerm = query }] };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.Filter(criteria);
+
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        public void TestCriteriaMatchingMultipleTagsAtOnce()
+        {
+            var beatmap = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                UserTags =
+                [
+                    new FilterCriteria.OptionalTextFilter { SearchTerm = "\"song representation/simple\"!" },
+                    new FilterCriteria.OptionalTextFilter { SearchTerm = "\"style/clean\"!" }
+                ]
+            };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.Filter(criteria);
+
+            Assert.AreEqual(false, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        public void TestCriteriaAllTagFiltersMustMatch()
+        {
+            var beatmap = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                UserTags =
+                [
+                    new FilterCriteria.OptionalTextFilter { SearchTerm = "\"song representation/simple\"!" },
+                    new FilterCriteria.OptionalTextFilter { SearchTerm = "\"style/dirty\"!" }
+                ]
+            };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.Filter(criteria);
+
+            Assert.AreEqual(true, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        public void TestBeatmapMustHaveAtLeastOneTagIfUserTagFilterActive()
+        {
+            var beatmap = getExampleBeatmap();
+            var criteria = new FilterCriteria { UserTags = [new FilterCriteria.OptionalTextFilter { SearchTerm = "simple" }] };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.BeatmapInfo.Metadata.UserTags.Clear();
+            carouselItem.Filter(criteria);
+
+            Assert.True(carouselItem.Filtered.Value);
+        }
+
         [Test]
         public void TestCustomRulesetCriteria([Values(null, true, false)] bool? matchCustomCriteria)
         {
@@ -305,6 +375,167 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.AreEqual(matchCustomCriteria == false, carouselItem.Filtered.Value);
         }
 
+        [TestCase("title!=Title", new[] { 2, 4, 6 })]
+        [TestCase("title!=\"Title1\"", new[] { 2, 3, 4, 5, 6 })]
+        [TestCase("title!=\"Title1\"!", new[] { 2, 3, 4, 5, 6 })]
+        public void TestNotEqualSearchForTextFilters(string query, int[] expectedBeatmapIndexes)
+        {
+            string[] titles =
+            [
+                "Title1",
+                "Title1",
+                "My[Favourite]Song",
+                "Title",
+                "Another One",
+                "Diff in title",
+                "a",
+            ];
+
+            var carouselBeatmaps = titles.Select(title => new CarouselBeatmap(new BeatmapInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Title = title,
+                },
+            })).ToList();
+
+            var criteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(criteria, query);
+            carouselBeatmaps.ForEach(b => b.Filter(criteria));
+
+            int[] visibleBeatmaps = carouselBeatmaps
+                                    .Where(b => !b.Filtered.Value)
+                                    .Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
+            Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
+        }
+
+        [Test]
+        public void TestNotEqualSearchForNumberFilters()
+        {
+            double[] starRatings =
+            [
+                2.78,
+                1.78,
+                1.55,
+                3.78,
+                1.78,
+                1.55,
+                2.78
+            ];
+
+            var carouselBeatmaps = starRatings.Select(starRating => new CarouselBeatmap(new BeatmapInfo
+            {
+                StarRating = starRating,
+            })).ToList();
+
+            var criteria = new FilterCriteria();
+
+            FilterQueryParser.ApplyQueries(criteria, "star!=1.78");
+            carouselBeatmaps.ForEach(b => b.Filter(criteria));
+
+            int[] visibleBeatmaps = carouselBeatmaps
+                                    .Where(b => !b.Filtered.Value)
+                                    .Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
+
+            Assert.That(visibleBeatmaps, Is.EqualTo(new[] { 0, 2, 3, 5, 6 }));
+        }
+
+        [TestCase("status!=ranked", new[] { 1, 2, 4, 5 })]
+        [TestCase("status!=r", new[] { 1, 2, 4, 5 })]
+        [TestCase("status!=loved", new[] { 0, 1, 2, 3, 4, 6 })]
+        [TestCase("status!=l", new[] { 0, 1, 2, 3, 4, 6 })]
+        [TestCase("status!=r,l", new[] { 1, 2, 4 })]
+        public void TestNotEqualSearchForEnumFilter(string query, int[] expectedBeatmapIndexes)
+        {
+            var carouselBeatmaps = new[]
+            {
+                BeatmapOnlineStatus.Ranked,
+                BeatmapOnlineStatus.Qualified,
+                BeatmapOnlineStatus.Approved,
+                BeatmapOnlineStatus.Ranked,
+                BeatmapOnlineStatus.Approved,
+                BeatmapOnlineStatus.Loved,
+                BeatmapOnlineStatus.Ranked
+            }.Select(info => new CarouselBeatmap(new BeatmapInfo
+            {
+                Status = info
+            })).ToList();
+
+            var criteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(criteria, query);
+            carouselBeatmaps.ForEach(b => b.Filter(criteria));
+
+            int[] visibleBeatmaps = carouselBeatmaps
+                                    .Where(b => !b.Filtered.Value)
+                                    .Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
+
+            Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
+        }
+
+        [TestCase("played!=1", new[] { 1, 4, 5 })]
+        [TestCase("played!=0", new[] { 0, 2, 3, 6, 7 })]
+        public void TestNotEqualSearchForBooleanFilter(string query, int[] expectedBeatmapIndexes)
+        {
+            var carouselBeatmaps = (new DateTimeOffset?[]
+            {
+                new DateTimeOffset(2012, 10, 21, 12, 13, 24, TimeSpan.Zero),
+                null,
+                new DateTimeOffset(2012, 11, 12, 23, 10, 13, TimeSpan.Zero),
+                new DateTimeOffset(2013, 2, 13, 11, 43, 23, TimeSpan.Zero),
+                null,
+                null,
+                new DateTimeOffset(2014, 1, 15, 20, 13, 24, TimeSpan.Zero),
+                new DateTimeOffset(2014, 11, 16, 0, 13, 23, TimeSpan.Zero),
+            }).Select(lastPlayed => new CarouselBeatmap(new BeatmapInfo
+            {
+                LastPlayed = lastPlayed
+            })).ToList();
+
+            var criteria = new FilterCriteria();
+
+            FilterQueryParser.ApplyQueries(criteria, query);
+            carouselBeatmaps.ForEach(b => b.Filter(criteria));
+
+            int[] visibleBeatmaps = carouselBeatmaps
+                                    .Where(b => !b.Filtered.Value)
+                                    .Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
+
+            Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
+        }
+
+        [TestCase("ranked!=2012", new[] { 3, 4, 5, 6, 7 })]
+        [TestCase("ranked!=2012.11", new[] { 0, 1, 3, 4, 5, 6, 7 })]
+        [TestCase("ranked!=2012.10.21", new[] { 1, 2, 3, 4, 5, 6, 7 })]
+        public void TestNotEqualSearchForDateFilter(string query, int[] expectedBeatmapIndexes)
+        {
+            var carouselBeatmaps = new[]
+            {
+                new DateTimeOffset(2012, 10, 21, 13, 42, 13, TimeSpan.Zero),
+                new DateTimeOffset(2012, 10, 11, 2, 33, 43, TimeSpan.Zero),
+                new DateTimeOffset(2012, 11, 12, 10, 22, 32, TimeSpan.Zero),
+                new DateTimeOffset(2013, 2, 13, 5, 19, 0, TimeSpan.Zero),
+                new DateTimeOffset(2013, 2, 13, 11, 23, 35, TimeSpan.Zero),
+                new DateTimeOffset(2013, 3, 14, 9, 9, 1, TimeSpan.Zero),
+                new DateTimeOffset(2014, 1, 15, 10, 5, 0, TimeSpan.Zero),
+                new DateTimeOffset(2014, 11, 16, 23, 27, 0, TimeSpan.Zero),
+            }.Select(dateRanked => new CarouselBeatmap(new BeatmapInfo
+            {
+                BeatmapSet = new BeatmapSetInfo
+                {
+                    DateRanked = dateRanked,
+                }
+            })).ToList();
+            var criteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(criteria, query);
+            carouselBeatmaps.ForEach(b => b.Filter(criteria));
+
+            int[] visibleBeatmaps = carouselBeatmaps
+                                    .Where(b => !b.Filtered.Value)
+                                    .Select(b => carouselBeatmaps.IndexOf(b)).ToArray();
+
+            Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
+        }
+
         private class CustomCriteria : IRulesetFilterCriteria
         {
             private readonly bool match;
diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
index 578698b724..9968647cb2 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
@@ -294,6 +294,16 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.That(filterCriteria.OnlineStatus.Values, Is.Empty);
         }
 
+        [Test]
+        public void TestPartialStatusNotMatch()
+        {
+            const string query = "status!=r";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            Assert.That(filterCriteria.OnlineStatus.Values, Does.Not.Contain(BeatmapOnlineStatus.Ranked));
+        }
+
         [Test]
         public void TestApplyEqualStatusQueryWithMultipleValues()
         {
@@ -756,5 +766,17 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
             Assert.AreEqual(matched, filterCriteria.LastPlayed.IsInRange(reference));
         }
+
+        [Test]
+        public void TestMultipleTextFilters()
+        {
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, "tag=\"simple\" tag=\"clean\"!");
+            Assert.That(filterCriteria.UserTags, Has.Count.EqualTo(2));
+            Assert.That(filterCriteria.UserTags[0].SearchTerm, Is.EqualTo("simple"));
+            Assert.That(filterCriteria.UserTags[0].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
+            Assert.That(filterCriteria.UserTags[1].SearchTerm, Is.EqualTo("clean"));
+            Assert.That(filterCriteria.UserTags[1].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.FullPhrase));
+        }
     }
 }
diff --git a/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs b/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
index cfe523fdd5..69c98351ad 100644
--- a/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
+++ b/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
@@ -101,7 +101,6 @@ namespace osu.Game.Tests.NonVisual
             public override Container FrameStableComponents { get; }
             public override IFrameStableClock FrameStableClock { get; }
             internal override bool FrameStablePlayback { get; set; }
-            public override bool AllowBackwardsSeeks { get; set; }
             public override IReadOnlyList<Mod> Mods { get; }
 
             public override double GameplayStartTime { get; }
diff --git a/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
index bdb4dce354..e20fb50722 100644
--- a/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
+++ b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
@@ -48,6 +48,13 @@ namespace osu.Game.Tests.NonVisual
             AddUntilStep("no check pending", () => !manager.IsPending);
         }
 
+        [TearDownSteps]
+        public void TeardownSteps()
+        {
+            // Importantly, this immediately saves the config, which cancels any pending background save.
+            AddStep("dispose config manager", () => config.Dispose());
+        }
+
         /// <summary>
         /// Updates should be checked when the release stream is changed.
         /// </summary>
@@ -136,14 +143,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/Online/Chat/MessageNotifierTest.cs b/osu.Game.Tests/Online/Chat/MessageNotifierTest.cs
index e4118a23b4..a391ec4066 100644
--- a/osu.Game.Tests/Online/Chat/MessageNotifierTest.cs
+++ b/osu.Game.Tests/Online/Chat/MessageNotifierTest.cs
@@ -12,79 +12,79 @@ namespace osu.Game.Tests.Online.Chat
         [Test]
         public void TestContainsUsernameMidlinePositive()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("This is a test message", "Test"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("This is a test message", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameStartOfLinePositive()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("Test message", "Test"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("Test message", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameEndOfLinePositive()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("This is a test", "Test"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("This is a test", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameMidlineNegative()
         {
-            Assert.IsFalse(MessageNotifier.CheckContainsUsername("This is a testmessage for notifications", "Test"));
+            Assert.IsFalse(MessageNotifier.MatchUsername("This is a testmessage for notifications", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameStartOfLineNegative()
         {
-            Assert.IsFalse(MessageNotifier.CheckContainsUsername("Testmessage", "Test"));
+            Assert.IsFalse(MessageNotifier.MatchUsername("Testmessage", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameEndOfLineNegative()
         {
-            Assert.IsFalse(MessageNotifier.CheckContainsUsername("This is a notificationtest", "Test"));
+            Assert.IsFalse(MessageNotifier.MatchUsername("This is a notificationtest", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameBetweenPunctuation()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("Hello 'test'-message", "Test"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("Hello 'test'-message", "Test").Success);
         }
 
         [Test]
         public void TestContainsUsernameUnicode()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("Test \u0460\u0460 message", "\u0460\u0460"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("Test \u0460\u0460 message", "\u0460\u0460").Success);
         }
 
         [Test]
         public void TestContainsUsernameUnicodeNegative()
         {
-            Assert.IsFalse(MessageNotifier.CheckContainsUsername("Test ha\u0460\u0460o message", "\u0460\u0460"));
+            Assert.IsFalse(MessageNotifier.MatchUsername("Test ha\u0460\u0460o message", "\u0460\u0460").Success);
         }
 
         [Test]
         public void TestContainsUsernameSpecialCharactersPositive()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("Test [#^-^#] message", "[#^-^#]"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("Test [#^-^#] message", "[#^-^#]").Success);
         }
 
         [Test]
         public void TestContainsUsernameSpecialCharactersNegative()
         {
-            Assert.IsFalse(MessageNotifier.CheckContainsUsername("Test pad[#^-^#]oru message", "[#^-^#]"));
+            Assert.IsFalse(MessageNotifier.MatchUsername("Test pad[#^-^#]oru message", "[#^-^#]").Success);
         }
 
         [Test]
         public void TestContainsUsernameAtSign()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("@username hi", "username"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("@username hi", "username").Success);
         }
 
         [Test]
         public void TestContainsUsernameColon()
         {
-            Assert.IsTrue(MessageNotifier.CheckContainsUsername("username: hi", "username"));
+            Assert.IsTrue(MessageNotifier.MatchUsername("username: hi", "username").Success);
         }
     }
 }
diff --git a/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs b/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs
new file mode 100644
index 0000000000..c9219c871a
--- /dev/null
+++ b/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs
@@ -0,0 +1,153 @@
+// 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 NUnit.Framework;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Tests.Online.Matchmaking
+{
+    public class MatchmakingRoomStateTest
+    {
+        /// <summary>
+        /// The number of points awarded for each placement position (index 0 = #1, index 7 = #8).
+        /// </summary>
+        private static readonly int[] placement_points = [8, 7, 6, 5, 4, 3, 2, 1];
+
+        [Test]
+        public void Basic()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 -> 3 -> 2
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 2, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 750 },
+            ], placement_points);
+
+            Assert.AreEqual(8, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(1, state.Users[1].Rounds[1].Placement);
+
+            Assert.AreEqual(6, state.Users[2].Points);
+            Assert.AreEqual(3, state.Users[2].Placement);
+            Assert.AreEqual(3, state.Users[2].Rounds[1].Placement);
+
+            Assert.AreEqual(7, state.Users[3].Points);
+            Assert.AreEqual(2, state.Users[3].Placement);
+            Assert.AreEqual(2, state.Users[3].Rounds[1].Placement);
+
+            // 2 -> 1 -> 3
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 750 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 500 },
+            ], placement_points);
+
+            Assert.AreEqual(15, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[1].Rounds[2].Placement);
+
+            Assert.AreEqual(14, state.Users[2].Points);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(1, state.Users[2].Rounds[2].Placement);
+
+            Assert.AreEqual(13, state.Users[3].Points);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(3, state.Users[3].Rounds[2].Placement);
+        }
+
+        [Test]
+        public void MatchingScores()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 + 2 -> 3 + 4
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 4, TotalScore = 500 },
+            ], placement_points);
+
+            Assert.AreEqual(7, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[1].Rounds[1].Placement);
+
+            Assert.AreEqual(7, state.Users[2].Points);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(2, state.Users[2].Rounds[1].Placement);
+
+            Assert.AreEqual(5, state.Users[3].Points);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(4, state.Users[3].Rounds[1].Placement);
+
+            Assert.AreEqual(5, state.Users[4].Points);
+            Assert.AreEqual(4, state.Users[4].Placement);
+            Assert.AreEqual(4, state.Users[4].Rounds[1].Placement);
+        }
+
+        [Test]
+        public void RoundTieBreaker()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 -> 2
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 500 },
+            ], placement_points);
+
+            // 2 -> 1
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+            ], placement_points);
+
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[2].Placement);
+        }
+
+        [Test]
+        public void UserIdTieBreaker()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 + 2 + 3 + 4 + 5 + 6
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 4, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 6, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 5, TotalScore = 1000 },
+            ], placement_points);
+
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(4, state.Users[4].Placement);
+            Assert.AreEqual(5, state.Users[5].Placement);
+            Assert.AreEqual(6, state.Users[6].Placement);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk b/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk
new file mode 100644
index 0000000000..cbaacd3f4b
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk differ
diff --git a/osu.Game.Tests/Resources/Archives/modified-argon-20250809.osk b/osu.Game.Tests/Resources/Archives/modified-argon-20250809.osk
new file mode 100644
index 0000000000..bea78dcbef
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/modified-argon-20250809.osk differ
diff --git a/osu.Game.Tests/Skins/IO/ImportSkinTest.cs b/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
index 62e7a80435..f909638333 100644
--- a/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
+++ b/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
@@ -294,6 +294,46 @@ namespace osu.Game.Tests.Skins.IO
 
         #endregion
 
+        /// <remarks>
+        /// Note that this test passing / failing is platform / OS-specific (if it is to fail, it'll fail on windows).
+        /// </remarks>
+        [Test]
+        public async Task TestExternallyMountingImportWithInvalidFilename()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var zipStream = new MemoryStream();
+                    using var zip = ZipArchive.Create();
+                    zip.AddEntry("test?.png", new MemoryStream(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF }));
+                    zip.SaveTo(zipStream);
+
+                    var import = await loadSkinIntoOsu(osu, new ImportTask(zipStream, "test skin.osk"));
+
+                    var skinManager = osu.Dependencies.Get<SkinManager>();
+                    var externalEdit = await skinManager.BeginExternalEditing(import.PerformRead(s => s.Detach())); // should not fail
+
+                    Assert.That(Directory.Exists(externalEdit.MountedPath));
+                    Assert.That(new DirectoryInfo(externalEdit.MountedPath).GetFiles().Select(f => f.Name), Is.EquivalentTo(new[]
+                    {
+                        "skin.ini",
+                        "test.png"
+                    }));
+
+                    Task finishTask = Task.CompletedTask;
+                    host.UpdateThread.Scheduler.Add(() => finishTask = externalEdit.Finish());
+                    await finishTask;
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         private void assertCorrectMetadata(Live<SkinInfo> import1, string name, string creator, decimal version, OsuGameBase osu)
         {
             import1.PerformRead(i =>
diff --git a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
index 9ae572b0ec..a493f334fd 100644
--- a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
+++ b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
@@ -13,10 +13,10 @@ using osu.Game.Audio;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
 using osu.Game.Skinning;
 using osu.Game.Skinning.Components;
+using osu.Game.Skinning.Triangles;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Skins
@@ -77,6 +77,10 @@ namespace osu.Game.Tests.Skins
             "Archives/modified-argon-20250214.osk",
             // Covers skinnable leaderboard
             "Archives/modified-argon-20250424.osk",
+            // Covers "Argon" unstable rate counter
+            "Archives/modified-argon-20250809.osk",
+            // Covers "Argon" judgement counter
+            "Archives/modified-argon-20250308.osk",
         };
 
         /// <summary>
@@ -170,7 +174,7 @@ namespace osu.Game.Tests.Skins
             {
                 var skin = new TestSkin(new SkinInfo(), null, storage);
                 Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(8));
-                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(UnstableRateCounter)));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(TrianglesUnstableRateCounter)));
                 Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(ColourHitErrorMeter)));
                 Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(LegacySongProgress)));
             }
diff --git a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
index 58fb02c90c..3021589cdb 100644
--- a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
@@ -325,7 +325,7 @@ namespace osu.Game.Tests.Visual.Background
         private void setupUserSettings()
         {
             AddUntilStep("Song select is current", () => songSelect.IsCurrentScreen());
-            AddUntilStep("Song select has selection", () => songSelect.Carousel?.CurrentSelection != null);
+            AddUntilStep("Song select has selection", () => songSelect.Carousel?.CurrentGroupedBeatmap != null);
             AddStep("Set default user settings", () =>
             {
                 SelectedMods.Value = new[] { new OsuModNoFail() };
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs
new file mode 100644
index 0000000000..e08af79032
--- /dev/null
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs
@@ -0,0 +1,206 @@
+// 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.Diagnostics;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osu.Game.Skinning.Components;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public partial class TestSceneArgonJudgementCounter : OsuTestScene
+    {
+        private ScoreProcessor scoreProcessor = null!;
+        private JudgementCountController judgementCountController = null!;
+        private TestArgonJudgementCounterDisplay counterDisplay = null!;
+
+        private DependencyProvidingContainer content = null!;
+
+        protected override Container<Drawable> Content => content;
+
+        private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
+
+        private int iteration;
+
+        [SetUpSteps]
+        public void SetUpSteps() => AddStep("Create components", () =>
+        {
+            var ruleset = CreateRuleset();
+
+            Debug.Assert(ruleset != null);
+
+            scoreProcessor = new ScoreProcessor(ruleset);
+            base.Content.Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[] { (typeof(ScoreProcessor), scoreProcessor), (typeof(Ruleset), ruleset) },
+                Children = new Drawable[]
+                {
+                    judgementCountController = new JudgementCountController(),
+                    content = new DependencyProvidingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CachedDependencies = new (Type, object)[] { (typeof(JudgementCountController), judgementCountController) },
+                    }
+                },
+            };
+        });
+
+        protected override Ruleset CreateRuleset() => new OsuRuleset();
+
+        private void applyOneJudgement(HitResult result)
+        {
+            lastJudgementResult.Value = new OsuJudgementResult(new HitObject
+            {
+                StartTime = iteration * 10000
+            }, new OsuJudgement())
+            {
+                Type = result,
+            };
+            scoreProcessor.ApplyResult(lastJudgementResult.Value);
+
+            iteration++;
+        }
+
+        [Test]
+        public void TestAddJudgementsToCounters()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Great), 2);
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Miss), 2);
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Meh), 2);
+        }
+
+        [Test]
+        public void TestAddWhilstHidden()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.LargeTickHit), 2);
+            AddAssert("Check value added whilst hidden", () => hiddenCount() == 2);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+        }
+
+        [Test]
+        public void TestChangeFlowDirection()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Set direction vertical", () => counterDisplay.FlowDirection.Value = Direction.Vertical);
+            AddStep("Set direction horizontal", () => counterDisplay.FlowDirection.Value = Direction.Horizontal);
+
+            AddStep("add 100 ok judgements", () =>
+            {
+                for (int i = 0; i < 100; i++)
+                    applyOneJudgement(HitResult.Ok);
+            });
+            AddStep("add 1000 great judgements", () =>
+            {
+                for (int i = 0; i < 1000; i++)
+                    applyOneJudgement(HitResult.Great);
+            });
+
+            AddToggleStep("toggle max judgement display", t => counterDisplay.ShowMaxJudgement.Value = t);
+        }
+
+        [Test]
+        public void TestToggleJudgementNames()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Show label", () => counterDisplay.ShowLabel.Value = true);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert hidden", () => counterDisplay.CounterFlow.Children.First().Alpha == 1);
+            AddStep("Hide label", () => counterDisplay.ShowLabel.Value = false);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert shown", () => counterDisplay.CounterFlow.Children.First().Alpha == 1);
+        }
+
+        [Test]
+        public void TestHideMaxValue()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Hide max judgement", () => counterDisplay.ShowMaxJudgement.Value = false);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check max hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+            AddStep("Show max judgement", () => counterDisplay.ShowMaxJudgement.Value = true);
+        }
+
+        [Test]
+        public void TestMaxValueStartsHidden()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay
+            {
+                ShowMaxJudgement = { Value = false }
+            });
+            AddAssert("Check max hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+        }
+
+        [Test]
+        public void TestMaxValueHiddenOnModeChange()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Set max judgement to hide itself", () => counterDisplay.ShowMaxJudgement.Value = false);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert max judgement hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+        }
+
+        [Test]
+        public void TestNoDuplicates()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddAssert("Check no duplicates",
+                () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Count(),
+                () => Is.EqualTo(counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Select(c => c.Result.DisplayName).Distinct().Count()));
+        }
+
+        [Test]
+        public void TestCycleDisplayModes()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Show basic judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.Simple);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check only basic", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Last().Alpha == 0);
+            AddStep("Show normal judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.Normal);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check all visible", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Last().Alpha == 1);
+        }
+
+        private int hiddenCount()
+        {
+            var num = counterDisplay.CounterFlow.Children.First(child => child.Result.Types.Contains(HitResult.LargeTickHit));
+            return num.Result.ResultCount.Value;
+        }
+
+        private partial class TestArgonJudgementCounterDisplay : ArgonJudgementCounterDisplay
+        {
+            public new FillFlowContainer<ArgonJudgementCounter> CounterFlow => base.CounterFlow;
+
+            public TestArgonJudgementCounterDisplay()
+            {
+                Margin = new MarginPadding { Top = 100 };
+                Anchor = Anchor.TopCentre;
+                Origin = Anchor.TopCentre;
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
index 25b36a0f33..adbfebbfc6 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
@@ -4,12 +4,16 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -23,10 +27,19 @@ namespace osu.Game.Tests.Visual.Gameplay
     public partial class TestSceneBeatmapOffsetControl : OsuTestScene
     {
         private BeatmapOffsetControl offsetControl = null!;
+        private OsuConfigManager localConfig = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Dependencies.Cache(localConfig = new OsuConfigManager(LocalStorage));
+        }
 
         [SetUpSteps]
         public void SetUpSteps()
         {
+            AddStep("reset settings", () => localConfig.SetValue(OsuSetting.AutomaticallyAdjustBeatmapOffset, false));
+
             recreateControl();
         }
 
@@ -161,6 +174,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddAssert("Offset is still neutral", () => offsetControl.Current.Value == 0);
             AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
             AddAssert("Offset is adjusted", () => offsetControl.Current.Value == -average_error);
             AddUntilStep("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
@@ -192,6 +206,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddAssert("Offset still not adjusted", () => offsetControl.Current.Value == initial_offset);
             AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
             AddAssert("Offset is adjusted", () => offsetControl.Current.Value == initial_offset - average_error);
             AddUntilStep("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
@@ -244,6 +259,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddAssert("Offset still not adjusted", () => offsetControl.Current.Value == initial_offset);
             AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
             AddAssert("Offset is adjusted", () => offsetControl.Current.Value, () => Is.EqualTo(initial_offset - average_error));
             AddUntilStep("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
@@ -273,6 +289,89 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
         }
 
+        [Test]
+        public void TestAutomaticAdjustment()
+        {
+            const double average_error = -4.5;
+
+            AddStep("enable automatic adjust", () => localConfig.SetValue(OsuSetting.AutomaticallyAdjustBeatmapOffset, true));
+            AddAssert("offset zero", () => offsetControl.Current.Value == 0);
+
+            AddStep("set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddAssert("no calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any(b => b.IsPresent));
+            AddAssert("offset adjustment text displayed", () => offsetControl.ChildrenOfType<IHasText>().Any(t => t.Text.ToString().Contains("adjusted")));
+            AddAssert("offset adjusted", () => offsetControl.Current.Value == -average_error);
+
+            AddStep("set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddAssert("no calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any(b => b.IsPresent));
+            AddAssert("offset adjustment text not displayed", () => !offsetControl.ChildrenOfType<IHasText>().Any(t => t.Text.ToString().Contains("adjusted")));
+            AddAssert("offset still", () => offsetControl.Current.Value == -average_error);
+
+            AddStep("adjust offset manually", () => offsetControl.Current.Value = 0);
+            AddUntilStep("calibration button displayed", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+
+            AddStep("press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
+            AddAssert("offset adjusted", () => offsetControl.Current.Value == -average_error);
+            AddUntilStep("button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
+        }
+
+        [Test]
+        public void TestAutomaticAdjustmentWithUnstableRate()
+        {
+            const double average_error = -25;
+            const int spread = 25;
+            const double expected_offset = 12.9; // due to high UR (~147). see BeatmapOffsetControl.computeSuggestedOffset()
+
+            AddStep("enable automatic adjust", () => localConfig.SetValue(OsuSetting.AutomaticallyAdjustBeatmapOffset, true));
+            AddAssert("offset zero", () => offsetControl.Current.Value == 0);
+
+            AddStep("set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    // distribute the hit events such that it produces ~147 UR. setup taken from UnstableRateTest.
+                    HitEvents = Enumerable.Range((int)average_error - spread, spread * 2 + 1)
+                                          .Select(t => new HitEvent(t, 1.0, HitResult.Great, new HitObject(), null, null))
+                                          .ToList(),
+
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddAssert("no calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any(b => b.IsPresent));
+            AddAssert("offset adjustment text displayed", () => offsetControl.ChildrenOfType<IHasText>().Any(t => t.Text.ToString().Contains("adjusted")));
+            AddAssert("offset adjusted", () => offsetControl.Current.Value == expected_offset);
+
+            AddStep("adjust offset manually", () => offsetControl.Current.Value = 0);
+            AddUntilStep("calibration button displayed", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+
+            AddStep("press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
+            AddAssert("offset adjusted", () => offsetControl.Current.Value == expected_offset);
+            AddUntilStep("button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
+        }
+
+        [Test]
+        public void TestNegativeZero()
+        {
+            AddAssert("assert", () => BeatmapOffsetControl.GetOffsetExplanatoryText(-0.0001).ToString(), () => Is.EqualTo("0 ms"));
+        }
+
         private void recreateControl()
         {
             AddStep("Create control", () =>
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFrameStabilityContainer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFrameStabilityContainer.cs
index c2999e3f5a..dfaebccf32 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFrameStabilityContainer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFrameStabilityContainer.cs
@@ -131,10 +131,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void createStabilityContainer(double gameplayStartTime = double.MinValue) => AddStep("create container", () =>
         {
-            mainContainer.Child = new FrameStabilityContainer(gameplayStartTime)
-            {
-                AllowBackwardsSeeks = true,
-            }.WithChild(consumer = new ClockConsumingChild());
+            mainContainer.Child = new FrameStabilityContainer(gameplayStartTime).WithChild(consumer = new ClockConsumingChild());
         });
 
         private void seekManualTo(double time) => AddStep($"seek manual clock to {time}", () => manualClock.CurrentTime = time);
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
index d026afcd6d..a54c40014a 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.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.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -15,48 +16,166 @@ using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Select.Leaderboards;
-using osuTK;
+using osu.Game.Tests.Gameplay;
+using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    [TestFixture]
     public partial class TestSceneGameplayLeaderboard : OsuTestScene
     {
-        private TestDrawableGameplayLeaderboard leaderboard = null!;
+        private Box? blackBackground;
+        private DrawableGameplayLeaderboard leaderboard = null!;
 
-        [Cached(typeof(IGameplayLeaderboardProvider))]
-        private TestGameplayLeaderboardProvider leaderboardProvider = new TestGameplayLeaderboardProvider();
+        [Cached]
+        private readonly LeaderboardManager leaderboardManager = new LeaderboardManager();
 
-        private readonly BindableLong playerScore = new BindableLong();
+        [Cached]
+        private readonly GameplayState gameplayState;
 
         public TestSceneGameplayLeaderboard()
         {
-            AddStep("toggle expanded", () =>
+            var localScore = new ScoreInfo
+            {
+                User = new APIUser { Username = "You", Id = 3 }
+            };
+
+            gameplayState = TestGameplayState.Create(new OsuRuleset(), null, new Score { ScoreInfo = localScore }, new Bindable<LocalUserPlayingState>(LocalUserPlayingState.Playing));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LoadComponent(leaderboardManager);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("toggle collapsed", () =>
             {
                 if (leaderboard.IsNotNull())
                     leaderboard.CollapseDuringGameplay.Value = !leaderboard.CollapseDuringGameplay.Value;
             });
 
-            AddSliderStep("set player score", 50, 5000000, 1222333, v => playerScore.Value = v);
+            AddStep("toggle black background", () => blackBackground?.FadeTo(1 - blackBackground.Alpha, 300, Easing.OutQuint));
+
+            AddSliderStep("leaderboard width", 0, 800, 300, v =>
+            {
+                if (leaderboard.IsNotNull())
+                    leaderboard.Width = v;
+            });
+
+            AddSliderStep("leaderboard height", 0, 1000, 300, v =>
+            {
+                if (leaderboard.IsNotNull())
+                    leaderboard.Height = v;
+            });
+
+            AddSliderStep("set player score", 50, 1_000_000, 700_000, v => gameplayState.ScoreProcessor.TotalScore.Value = v);
+        }
+
+        [Test]
+        public void TestDisplay()
+        {
+            AddStep("set scores", () =>
+            {
+                var friend = new APIUser { Username = "Friend", Id = 1337 };
+
+                var api = (DummyAPIAccess)API;
+
+                api.Friends.Clear();
+                api.Friends.Add(new APIRelation
+                {
+                    Mutual = true,
+                    RelationType = RelationType.Friend,
+                    TargetID = friend.OnlineID,
+                    TargetUser = friend
+                });
+
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(new[]
+                {
+                    new ScoreInfo { User = new APIUser { Username = "Top", Id = 2 }, TotalScore = 900_000, Accuracy = 0.99, MaxCombo = 999 },
+                    new ScoreInfo { User = new APIUser { Username = "Second", Id = 14 }, TotalScore = 800_000, Accuracy = 0.9, MaxCombo = 888 },
+                    new ScoreInfo { User = friend, TotalScore = 700_000, Accuracy = 0.88, MaxCombo = 777 },
+                }, 3, null);
+            });
+
+            createLeaderboard();
+
+            AddStep("set score to 650k", () => gameplayState.ScoreProcessor.TotalScore.Value = 650_000);
+            AddUntilStep("wait for 4th spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(4));
+            AddStep("set score to 750k", () => gameplayState.ScoreProcessor.TotalScore.Value = 750_000);
+            AddUntilStep("wait for 3rd spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(3));
+            AddStep("set score to 850k", () => gameplayState.ScoreProcessor.TotalScore.Value = 850_000);
+            AddUntilStep("wait for 2nd spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(2));
+            AddStep("set score to 950k", () => gameplayState.ScoreProcessor.TotalScore.Value = 950_000);
+            AddUntilStep("wait for 1st spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestLongScores()
+        {
+            AddStep("set scores", () =>
+            {
+                var friend = new APIUser { Username = "Friend", Id = 1337 };
+
+                var api = (DummyAPIAccess)API;
+
+                api.Friends.Clear();
+                api.Friends.Add(new APIRelation
+                {
+                    Mutual = true,
+                    RelationType = RelationType.Friend,
+                    TargetID = friend.OnlineID,
+                    TargetUser = friend
+                });
+
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(new[]
+                {
+                    new ScoreInfo { User = new APIUser { Username = "Top", Id = 2 }, TotalScore = 900_000_000, Accuracy = 0.99, MaxCombo = 999999 },
+                    new ScoreInfo { User = new APIUser { Username = "Second", Id = 14 }, TotalScore = 800_000_000, Accuracy = 0.9, MaxCombo = 888888 },
+                    new ScoreInfo { User = friend, TotalScore = 700_000_000, Accuracy = 0.88, MaxCombo = 777777 },
+                }, 3, null);
+            });
+
+            createLeaderboard();
+
+            AddStep("set score to 650k", () => gameplayState.ScoreProcessor.TotalScore.Value = 650_000_000);
+            AddUntilStep("wait for 4th spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(4));
+            AddStep("set score to 750k", () => gameplayState.ScoreProcessor.TotalScore.Value = 750_000_000);
+            AddUntilStep("wait for 3rd spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(3));
+            AddStep("set score to 850k", () => gameplayState.ScoreProcessor.TotalScore.Value = 850_000_000);
+            AddUntilStep("wait for 2nd spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(2));
+            AddStep("set score to 950k", () => gameplayState.ScoreProcessor.TotalScore.Value = 950_000_000);
+            AddUntilStep("wait for 1st spot", () => leaderboard.TrackedScore!.ScorePosition.Value, () => Is.EqualTo(1));
         }
 
         [Test]
         public void TestLayoutWithManyScores()
         {
-            createLeaderboard();
-
-            AddStep("add many scores in one go", () =>
+            AddStep("set scores", () =>
             {
-                for (int i = 0; i < 32; i++)
-                    leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {i + 1}" });
+                var scores = new List<ScoreInfo>();
 
-                // Add player at end to force an animation down the whole list.
-                playerScore.Value = 0;
-                leaderboardProvider.CreateLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
+                for (int i = 0; i < 32; i++)
+                    scores.Add(new ScoreInfo { User = new APIUser { Username = $"Player {i + 1}" }, TotalScore = RNG.Next(700_000, 1_000_000) });
+
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(scores, scores.Count, null);
+                gameplayState.ScoreProcessor.TotalScore.Value = 0;
             });
 
+            createLeaderboard();
+
             // Gameplay leaderboard has custom scroll logic, which when coupled with LayoutDuration
             // has caused layout to not work in the past.
 
@@ -68,80 +187,51 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
 
-            AddStep("change score to middle", () => playerScore.Value = 1000000);
+            AddStep("change score to middle", () => gameplayState.ScoreProcessor.TotalScore.Value = 850_000);
             AddWaitStep("wait for movement", 5);
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
 
-            AddStep("change score to first", () => playerScore.Value = 5000000);
+            AddStep("change score to first", () => gameplayState.ScoreProcessor.TotalScore.Value = 1_000_000);
             AddWaitStep("wait for movement", 5);
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
         }
 
-        [Test]
-        public void TestRandomScores()
-        {
-            createLeaderboard();
-            addLocalPlayer();
-
-            int playerNumber = 1;
-            AddRepeatStep("add player with random score", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 10);
-        }
-
         [Test]
         public void TestExistingUsers()
         {
-            createLeaderboard();
-            addLocalPlayer();
+            AddStep("set scores", () =>
+            {
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(new[]
+                {
+                    new ScoreInfo { User = new APIUser { Username = "peppy", Id = 2 }, TotalScore = 900_000, Accuracy = 0.99, MaxCombo = 999 },
+                    new ScoreInfo { User = new APIUser { Username = "smoogipoo", Id = 1040328 }, TotalScore = 800_000, Accuracy = 0.9, MaxCombo = 888 },
+                    new ScoreInfo { User = new APIUser { Username = "flyte", Id = 3103765 }, TotalScore = 700_000, Accuracy = 0.9, MaxCombo = 888 },
+                    new ScoreInfo { User = new APIUser { Username = "frenzibyte", Id = 14210502 }, TotalScore = 600_000, Accuracy = 0.9, MaxCombo = 777 },
+                }, 4, null);
+            });
 
-            AddStep("add peppy", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "peppy", Id = 2 }));
-            AddStep("add smoogipoo", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "smoogipoo", Id = 1040328 }));
-            AddStep("add flyte", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "flyte", Id = 3103765 }));
-            AddStep("add frenzibyte", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = "frenzibyte", Id = 14210502 }));
+            createLeaderboard();
         }
 
         [Test]
-        public void TestFriendScore()
+        public void TestQuitScore()
         {
-            APIUser friend = new APIUser { Username = "my friend", Id = 10000 };
-
-            createLeaderboard();
-            addLocalPlayer();
-
-            AddStep("Add friend to API", () =>
+            AddStep("set scores", () =>
             {
-                var api = (DummyAPIAccess)API;
-
-                api.Friends.Clear();
-                api.Friends.Add(new APIRelation
+                // this is dodgy but anything less dodgy is a lot of work
+                ((Bindable<LeaderboardScores?>)leaderboardManager.Scores).Value = LeaderboardScores.Success(new[]
                 {
-                    Mutual = true,
-                    RelationType = RelationType.Friend,
-                    TargetID = friend.OnlineID,
-                    TargetUser = friend
-                });
+                    new ScoreInfo { User = new APIUser { Username = "Quit", Id = 3 }, TotalScore = 100_000, Accuracy = 0.99, MaxCombo = 999 },
+                }, 1, null);
             });
 
-            int playerNumber = 1;
+            createLeaderboard();
 
-            AddRepeatStep("add 3 other players", () => leaderboardProvider.CreateRandomScore(new APIUser { Username = $"Player {playerNumber++}" }), 3);
-            AddUntilStep("no pink color scores",
-                () => leaderboard.ChildrenOfType<Box>().Select(b => ((Colour4)b.Colour).ToHex()),
-                () => Does.Not.Contain("#FF549A"));
-
-            AddRepeatStep("add 3 friend score", () => leaderboardProvider.CreateRandomScore(friend), 3);
-            AddUntilStep("at least one friend score is pink",
-                () => leaderboard.GetAllScoresForUsername("my friend")
-                                 .SelectMany(score => score.ChildrenOfType<Box>())
-                                 .Select(b => ((Colour4)b.Colour).ToHex()),
-                () => Does.Contain("#FF549A"));
-        }
-
-        private void addLocalPlayer()
-        {
-            AddStep("add local player", () =>
+            AddStep("mark score as quit", () =>
             {
-                playerScore.Value = 1222333;
-                leaderboardProvider.CreateLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
+                var quitScore = this.ChildrenOfType<SoloGameplayLeaderboardProvider>().Single().Scores.Single(s => s.User.Username == "Quit");
+                quitScore.HasQuit.Value = true;
             });
         }
 
@@ -149,38 +239,33 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create leaderboard", () =>
             {
-                leaderboardProvider.Scores.Clear();
-                Child = leaderboard = new TestDrawableGameplayLeaderboard
+                SoloGameplayLeaderboardProvider soloGameplayLeaderboardProvider;
+
+                Child = new DependencyProvidingContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Scale = new Vector2(2),
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = new (Type, object)[]
+                    {
+                        (typeof(IGameplayLeaderboardProvider), soloGameplayLeaderboardProvider = new SoloGameplayLeaderboardProvider()),
+                    },
+                    Children = new Drawable[]
+                    {
+                        soloGameplayLeaderboardProvider,
+                        blackBackground = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black,
+                            Alpha = 0f,
+                        },
+                        leaderboard = new DrawableGameplayLeaderboard
+                        {
+                            CollapseDuringGameplay = { Value = false },
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        }
+                    }
                 };
             });
         }
-
-        private partial class TestDrawableGameplayLeaderboard : DrawableGameplayLeaderboard
-        {
-            public float Spacing => Flow.Spacing.Y;
-
-            public IEnumerable<DrawableGameplayLeaderboardScore> GetAllScoresForUsername(string username)
-                => Flow.Where(i => i.User?.Username == username);
-        }
-
-        public class TestGameplayLeaderboardProvider : IGameplayLeaderboardProvider
-        {
-            public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
-
-            public GameplayLeaderboardScore CreateRandomScore(APIUser user) => CreateLeaderboardScore(new BindableLong(RNG.Next(0, 5_000_000)), user);
-
-            public GameplayLeaderboardScore CreateLeaderboardScore(BindableLong totalScore, APIUser user, bool isTracked = false)
-            {
-                var score = new GameplayLeaderboardScore(user, isTracked, totalScore);
-                Scores.Add(score);
-                return score;
-            }
-
-            IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHitErrorMeter.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHitErrorMeter.cs
index 551116e818..24215ed925 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHitErrorMeter.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHitErrorMeter.cs
@@ -284,7 +284,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             public override Container FrameStableComponents { get; }
             public override IFrameStableClock FrameStableClock { get; }
             internal override bool FrameStablePlayback { get; set; }
-            public override bool AllowBackwardsSeeks { get; set; }
             public override IReadOnlyList<Mod> Mods { get; }
 
             public override double GameplayStartTime { get; }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
index 58fe6e8e56..08317c37cf 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
@@ -69,6 +69,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             pauseViaBackAction();
             pauseViaBackAction();
             confirmPausedWithNoOverlay();
+            AddAssert("pause recorded", () => Player.Score.ScoreInfo.Pauses, () => Has.Count.EqualTo(1));
         }
 
         [Test]
@@ -77,17 +78,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             pauseViaPauseGameplayAction();
             pauseViaPauseGameplayAction();
             confirmPausedWithNoOverlay();
-        }
-
-        [Test]
-        public void TestForwardPlaybackGuarantee()
-        {
-            hookForwardPlaybackCheck();
-
-            AddUntilStep("wait for forward playback", () => Player.GameplayClockContainer.CurrentTime > 1000);
-            AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
-
-            checkForwardPlayback();
+            AddAssert("pause recorded", () => Player.Score.ScoreInfo.Pauses, () => Has.Count.EqualTo(1));
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
index c8b7ccc3d0..6ac82005a7 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs
@@ -19,6 +19,10 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Mods;
@@ -64,6 +68,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(BatteryInfo))]
         private readonly LocalBatteryInfo batteryInfo = new LocalBatteryInfo();
 
+        [Cached]
+        private readonly LeaderboardManager leaderboardManager;
+
         private readonly ChangelogOverlay changelogOverlay;
 
         private double savedTrackVolume;
@@ -74,6 +81,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddRange(new Drawable[]
             {
+                leaderboardManager = new LeaderboardManager(),
                 notificationOverlay = new NotificationOverlay
                 {
                     Anchor = Anchor.TopRight,
@@ -364,6 +372,45 @@ namespace osu.Game.Tests.Visual.Gameplay
             }, () => !volumeOverlay.IsMuted.Value && audioManager.Volume.Value == 0.5 && audioManager.VolumeTrack.Value == 0.5);
         }
 
+        [Test]
+        public void TestLeaderboardForciblyRefetchedOnRestart([Values] bool quickRestart)
+        {
+            int leaderboardRequestsHandled = 0;
+            AddStep("set up request handling", () => ((DummyAPIAccess)API).HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case GetScoresRequest getScores:
+                        leaderboardRequestsHandled++;
+                        getScores.TriggerSuccess(new APIScoresCollection { Scores = [] });
+                        return true;
+
+                    default:
+                        return false;
+                }
+            });
+
+            AddStep("load player", () => resetPlayer(true));
+
+            AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddAssert("leaderboard fetched once", () => leaderboardRequestsHandled, () => Is.EqualTo(1));
+
+            AddStep("restart player", () =>
+            {
+                var lastPlayer = player;
+                player = null;
+                lastPlayer.Restart(quickRestart);
+            });
+
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+
+            if (quickRestart)
+                AddAssert("leaderboard not refetched", () => leaderboardRequestsHandled, () => Is.EqualTo(1));
+            else
+                AddAssert("leaderboard fetched twice", () => leaderboardRequestsHandled, () => Is.EqualTo(2));
+        }
+
         /// <remarks>
         /// Created for avoiding copy pasting code for the same steps.
         /// </remarks>
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
index 88effb4a7b..b567e8de8d 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
@@ -269,7 +269,6 @@ namespace osu.Game.Tests.Visual.Gameplay
 
                 drawableRuleset = (TestDrawablePoolingRuleset)ruleset.CreateDrawableRulesetWith(CreateWorkingBeatmap(beatmap).GetPlayableBeatmap(ruleset.RulesetInfo));
                 drawableRuleset.FrameStablePlayback = true;
-                drawableRuleset.AllowBackwardsSeeks = true;
                 drawableRuleset.PoolSize = poolSize;
 
                 Child = new Container
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
index b3ed4135a9..6be8f7d185 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
@@ -24,6 +24,14 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         protected TestReplayPlayer Player = null!;
 
+        [Test]
+        public void TestFailedBeatmapLoad()
+        {
+            loadPlayerWithBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo, withHitObjects: false));
+
+            AddUntilStep("wait for exit", () => Player.IsCurrentScreen());
+        }
+
         [Test]
         public void TestPauseViaSpace()
         {
@@ -189,8 +197,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("load player", () => LoadScreen(Player));
             AddUntilStep("wait for loaded", () => Player.IsCurrentScreen());
             AddStep("seek to 8000", () => Player.Seek(8000));
-            AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
-            AddAssert("player failed after 10000", () => Player.GameplayClockContainer.CurrentTime, () => Is.GreaterThanOrEqualTo(10000));
+            AddUntilStep("fail indicator visible", () => Player.ChildrenOfType<ReplayFailIndicator>().Any(indicator => indicator.IsAlive && indicator.IsPresent));
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
index 73ec6ea335..3c48470bbe 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
@@ -4,8 +4,10 @@
 #nullable disable
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Judgements;
@@ -14,43 +16,50 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
-using osuTK;
+using osu.Game.Skinning.Triangles;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public partial class TestSceneUnstableRateCounter : OsuTestScene
+    public partial class TestSceneUnstableRateCounter : SkinnableHUDComponentTestScene
     {
         [Cached(typeof(ScoreProcessor))]
         private TestScoreProcessor scoreProcessor = new TestScoreProcessor();
 
         private readonly OsuHitWindows hitWindows;
 
-        private UnstableRateCounter counter;
-
         private double prev;
 
+        protected override Drawable CreateDefaultImplementation() => new TrianglesUnstableRateCounter();
+        protected override Drawable CreateArgonImplementation() => new ArgonUnstableRateCounter();
+        protected override Drawable CreateLegacyImplementation() => Empty();
+
         public TestSceneUnstableRateCounter()
         {
             hitWindows = new OsuHitWindows();
             hitWindows.SetDifficulty(5);
         }
 
-        [SetUpSteps]
-        public void SetUp()
+        public override void SetUpSteps()
         {
             AddStep("Reset Score Processor", () => scoreProcessor.Reset());
+            base.SetUpSteps();
+        }
+
+        [Test]
+        public void TestDisplay()
+        {
+            AddSliderStep("UR", 0, 2000, 0, v => this.ChildrenOfType<UnstableRateCounter>().ForEach(c => c.Current.Value = v));
+            AddToggleStep("toggle validity", v => this.ChildrenOfType<UnstableRateCounter>().ForEach(c => c.IsValid.Value = v));
         }
 
         [Test]
         public void TestBasic()
         {
-            AddStep("Create Display", recreateDisplay);
-
             // Needs multiples 2 by the nature of UR, and went for 4 to be safe.
             // Creates a 250 UR by placing a +25ms then a -25ms judgement, which then results in a 250 UR
             AddRepeatStep("Set UR to 250", () => applyJudgement(25, true), 4);
 
-            AddUntilStep("UR = 250", () => counter.Current.Value == 250.0);
+            AddUntilStep("UR = 250", () => this.ChildrenOfType<UnstableRateCounter>().All(c => c.Current.Value == 250));
 
             AddRepeatStep("Revert UR", () =>
             {
@@ -63,8 +72,8 @@ namespace osu.Game.Tests.Visual.Gameplay
                     });
             }, 4);
 
-            AddUntilStep("UR is 0", () => counter.Current.Value == 0.0);
-            AddUntilStep("Counter is invalid", () => counter.Child.Alpha == 0.3f);
+            AddUntilStep("UR is 0", () => this.ChildrenOfType<UnstableRateCounter>().All(c => c.Current.Value == 0));
+            AddUntilStep("Counter is invalid", () => this.ChildrenOfType<UnstableRateCounter>().All(c => !c.IsValid.Value));
 
             //Sets a UR of 0 by creating 10 10ms offset judgements. Since average = offset, UR = 0
             AddRepeatStep("Set UR to 0", () => applyJudgement(10, false), 10);
@@ -77,42 +86,24 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddRepeatStep("Set UR to 250", () => applyJudgement(25, true), 4);
 
-            AddStep("Create Display", recreateDisplay);
-
-            AddUntilStep("UR = 250", () => counter.Current.Value == 250.0);
+            AddUntilStep("UR = 250", () => this.ChildrenOfType<UnstableRateCounter>().All(c => c.Current.Value == 250));
         }
 
         [Test]
         public void TestStaticRateChange()
         {
-            AddStep("Create Display", recreateDisplay);
-
             AddRepeatStep("Set UR to 250 at 1.5x", () => applyJudgement(25, true, 1.5), 4);
 
-            AddUntilStep("UR = 250/1.5", () => counter.Current.Value == Math.Round(250.0 / 1.5));
+            AddUntilStep("UR = 250/1.5", () => this.ChildrenOfType<UnstableRateCounter>().All(c => c.Current.Value == (int)Math.Round(250.0 / 1.5)));
         }
 
         [Test]
         public void TestDynamicRateChange()
         {
-            AddStep("Create Display", recreateDisplay);
-
             AddRepeatStep("Set UR to 100 at 1.0x", () => applyJudgement(10, true, 1.0), 4);
             AddRepeatStep("Bring UR to 100 at 1.5x", () => applyJudgement(15, true, 1.5), 4);
 
-            AddUntilStep("UR = 100", () => counter.Current.Value == 100.0);
-        }
-
-        private void recreateDisplay()
-        {
-            Clear();
-
-            Add(counter = new UnstableRateCounter
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Scale = new Vector2(5),
-            });
+            AddUntilStep("UR = 100", () => this.ChildrenOfType<UnstableRateCounter>().All(c => c.Current.Value == 100));
         }
 
         private void applyJudgement(double offsetMs, bool alt, double gameplayRate = 1.0)
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/TestSceneMultiSpectatorScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
index faf8f35a8e..0a042d189d 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
@@ -20,6 +20,7 @@ using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
@@ -28,6 +29,7 @@ using osu.Game.Storyboards;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -302,9 +304,69 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddWaitStep("wait a bit", 10);
         }
 
+        [Test]
+        [Explicit("Test relies on timing of arriving frames to exercise assertions which doesn't work headless.")]
+        public void TestMaximisedUserIsAudioSource()
+        {
+            start(new[] { PLAYER_1_ID, PLAYER_2_ID });
+            loadSpectateScreen();
+
+            // With no frames, the synchronisation state will be TooFarAhead.
+            // In this state, all players should be muted.
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, true);
+
+            // Send frames for both players.
+            sendFrames(PLAYER_1_ID, 20);
+            sendFrames(PLAYER_2_ID, 40);
+
+            waitUntilRunning(PLAYER_1_ID);
+            AddStep("maximise player 1", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_1_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+
+            waitUntilPaused(PLAYER_1_ID);
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+
+            AddStep("minimise player 1", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_1_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            AddStep("maximise player 2", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_2_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            waitUntilPaused(PLAYER_2_ID);
+            sendFrames(PLAYER_1_ID, 60);
+
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            AddStep("minimise player 2", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_2_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+        }
+
         [Test]
         [FlakyTest]
-        public void TestMostInSyncUserIsAudioSource()
+        public void TestMostInSyncUserIsAudioSourceIfNoneMaximised()
         {
             start(new[] { PLAYER_1_ID, PLAYER_2_ID });
             loadSpectateScreen();
@@ -436,6 +498,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             b.Storyboard.GetLayer("Background").Add(sprite);
         });
 
+        [Test]
+        public void TestFRankDisplay()
+        {
+            int[] userIds = getPlayerIds(1);
+
+            start(userIds);
+            loadSpectateScreen();
+
+            sendFrames(userIds, 1000);
+            AddUntilStep("player has F rank", () => this.ChildrenOfType<MultiSpectatorPlayer>().All(msp => msp.GameplayState.ScoreProcessor.Rank.Value == ScoreRank.F));
+        }
+
         private void testLeadIn(Action<WorkingBeatmap>? applyToBeatmap = null)
         {
             start(PLAYER_1_ID);
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/Multiplayer/TestSceneMultiplayerPositionDisplay.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPositionDisplay.cs
index 228ae4eb1a..9123f63f56 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPositionDisplay.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPositionDisplay.cs
@@ -5,6 +5,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
@@ -13,7 +14,6 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Tests.Gameplay;
-using osu.Game.Tests.Visual.Gameplay;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -26,7 +26,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private readonly Bindable<int?> position = new Bindable<int?>(8);
 
-        private TestSceneGameplayLeaderboard.TestGameplayLeaderboardProvider leaderboardProvider = null!;
+        private TestGameplayLeaderboardProvider leaderboardProvider = null!;
         private MultiplayerPositionDisplay display = null!;
         private GameplayState gameplayState = null!;
 
@@ -44,7 +44,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         RelativeSizeAxes = Axes.Both,
                         CachedDependencies =
                         [
-                            (typeof(IGameplayLeaderboardProvider), leaderboardProvider = new TestSceneGameplayLeaderboard.TestGameplayLeaderboardProvider()),
+                            (typeof(IGameplayLeaderboardProvider), leaderboardProvider = new TestGameplayLeaderboardProvider()),
                             (typeof(GameplayState), gameplayState = TestGameplayState.Create(new OsuRuleset()))
                         ],
                         Child = display = new MultiplayerPositionDisplay
@@ -99,7 +99,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         RelativeSizeAxes = Axes.Both,
                         CachedDependencies =
                         [
-                            (typeof(IGameplayLeaderboardProvider), leaderboardProvider = new TestSceneGameplayLeaderboard.TestGameplayLeaderboardProvider()),
+                            (typeof(IGameplayLeaderboardProvider), leaderboardProvider = new TestGameplayLeaderboardProvider()),
                             (typeof(GameplayState), gameplayState = TestGameplayState.Create(new OsuRuleset()))
                         ],
                         Child = display = new MultiplayerPositionDisplay
@@ -120,5 +120,21 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("first place", () => position.Value = 1);
             AddStep("second place", () => position.Value = 2);
         }
+
+        public class TestGameplayLeaderboardProvider : IGameplayLeaderboardProvider
+        {
+            public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
+
+            public GameplayLeaderboardScore CreateRandomScore(APIUser user) => CreateLeaderboardScore(new BindableLong(RNG.Next(0, 5_000_000)), user);
+
+            public GameplayLeaderboardScore CreateLeaderboardScore(BindableLong totalScore, APIUser user, bool isTracked = false)
+            {
+                var score = new GameplayLeaderboardScore(user, isTracked, totalScore);
+                Scores.Add(score);
+                return score;
+            }
+
+            IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
index 58473f5fa2..7f6fb97e0c 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
@@ -52,25 +52,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestBasicListChanges()
         {
-            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(5, withSpotlightRooms: true)));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(5, withPinnedRooms: true)));
 
             AddAssert("has 5 rooms", () => container.DrawableRooms.Count == 5);
 
-            AddAssert("all spotlights at top", () => container.DrawableRooms
-                                                              .SkipWhile(r => r.Room.Category == RoomCategory.Spotlight)
-                                                              .All(r => r.Room.Category == RoomCategory.Normal));
+            AddAssert("all pinned at top", () => container.DrawableRooms
+                                                          .SkipWhile(r => r.Room.Pinned)
+                                                          .All(r => !r.Room.Pinned));
 
             AddStep("remove first room", () => rooms.RemoveAt(0));
             AddAssert("has 4 rooms", () => container.DrawableRooms.Count == 4);
             AddAssert("first room removed", () => container.DrawableRooms.All(r => r.Room.RoomID != 0));
 
             AddStep("select first room", () => container.DrawableRooms.First().TriggerClick());
-            AddAssert("first spotlight selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddAssert("first pinned room selected", () => checkRoomSelected(rooms.First(r => r.Pinned)));
 
             AddStep("remove last room", () => rooms.RemoveAt(rooms.Count - 1));
-            AddAssert("first spotlight still selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddAssert("first pinned room selected", () => checkRoomSelected(rooms.First(r => r.Pinned)));
 
-            AddStep("remove spotlight room", () => rooms.RemoveAll(r => r.Category == RoomCategory.Spotlight));
+            AddStep("remove pinned rooms", () => rooms.RemoveAll(r => r.Pinned));
             AddAssert("selection vacated", () => checkRoomSelected(null));
         }
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
index 037c5faae3..aa9dddae4d 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
@@ -19,6 +19,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
+using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
@@ -38,10 +39,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create rooms", () =>
             {
-                PlaylistItem item1 = new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo)
+                PlaylistItem item1 = new PlaylistItem(new APIBeatmap
                 {
-                    BeatmapInfo = { StarRating = 2.5 }
-                }.BeatmapInfo);
+                    OnlineBeatmapSetID = 173612,
+                    OnlineID = 502132,
+                });
 
                 PlaylistItem item2 = new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo)
                 {
@@ -72,6 +74,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     Spacing = new Vector2(10),
                     Children = new Drawable[]
                     {
+                        createMultiplayerPanel(new Room
+                        {
+                            Name = "Multiplayer room",
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Type = MatchType.HeadToHead,
+                            Playlist = [item1],
+                            CurrentPlaylistItem = item1
+                        }),
                         createLoungeRoom(new Room
                         {
                             Name = "Multiplayer room",
@@ -81,6 +91,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             CurrentPlaylistItem = item1
                         }),
                         createLoungeRoom(new Room
+                        {
+                            Name = "Pinned room",
+                            Pinned = true,
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Type = MatchType.HeadToHead,
+                            Playlist = [item1],
+                            CurrentPlaylistItem = item1
+                        }),
+                        createLoungeRoom(new Room
                         {
                             Name = "Private room",
                             Password = "*",
@@ -89,6 +108,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             Playlist = [item3],
                             CurrentPlaylistItem = item3
                         }),
+                        createPlaylistRoomPanel(new Room
+                        {
+                            Name = "Playlist room with multiple beatmaps",
+                            Status = RoomStatus.Playing,
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Playlist = [item1, item2],
+                            CurrentPlaylistItem = item1
+                        }),
                         createLoungeRoom(new Room
                         {
                             Name = "Playlist room with multiple beatmaps",
@@ -121,9 +148,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 };
             });
 
-            AddUntilStep("wait for panel load", () => rooms.Count == 7);
-            AddUntilStep("correct status text", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Currently playing", StringComparison.Ordinal)) == 2);
-            AddUntilStep("correct status text", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Ready to play", StringComparison.Ordinal)) == 5);
+            AddUntilStep("wait for panel load", () => rooms.Count, () => Is.EqualTo(10));
+            AddUntilStep("\"currently playing\" room count correct",
+                () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Currently playing", StringComparison.Ordinal)), () => Is.EqualTo(4));
+            AddUntilStep("\"ready to play\" room count correct", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Ready to play", StringComparison.Ordinal)),
+                () => Is.EqualTo(5));
         }
 
         [Test]
@@ -140,13 +169,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for panel load", () => panel.ChildrenOfType<DrawableRoomParticipantsList>().Any());
 
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
 
             AddStep("set password", () => room.Password = "password");
-            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
 
             AddStep("unset password", () => room.Password = string.Empty);
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
         }
 
         [Test]
@@ -198,7 +227,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     new MultiplayerRoomPanel(new Room
                     {
-                        Name = "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
+                        Name =
+                            "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
                         RoomID = 1337,
@@ -222,7 +252,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     new MultiplayerRoomPanel(room = new Room
                     {
-                        Name = "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
+                        Name =
+                            "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
                     }),
@@ -234,6 +265,41 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("clear room ID", () => room.RoomID = null);
         }
 
+        private RoomPanel createPlaylistRoomPanel(Room room)
+        {
+            room.Host ??= new APIUser { Username = "peppy", Id = 2 };
+
+            if (room.RecentParticipants.Count == 0)
+            {
+                room.RecentParticipants = Enumerable.Range(0, 20).Select(i => new APIUser
+                {
+                    Id = i,
+                    Username = $"User {i}"
+                }).ToArray();
+            }
+
+            return new PlaylistsRoomPanel(room)
+            {
+                SelectedItem = new Bindable<PlaylistItem?>(room.CurrentPlaylistItem),
+            };
+        }
+
+        private RoomPanel createMultiplayerPanel(Room room)
+        {
+            room.Host ??= new APIUser { Username = "peppy", Id = 2 };
+
+            if (room.RecentParticipants.Count == 0)
+            {
+                room.RecentParticipants = Enumerable.Range(0, 20).Select(i => new APIUser
+                {
+                    Id = i,
+                    Username = $"User {i}"
+                }).ToArray();
+            }
+
+            return new MultiplayerRoomPanel(room);
+        }
+
         private RoomPanel createLoungeRoom(Room room)
         {
             room.Host ??= new APIUser { Username = "peppy", Id = 2 };
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneStarRatingRangeDisplay.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneStarRatingRangeDisplay.cs
index ecdbfc411a..3a941e0ed3 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneStarRatingRangeDisplay.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneStarRatingRangeDisplay.cs
@@ -1,10 +1,13 @@
 // 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 NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Tests.Resources;
@@ -82,5 +85,45 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 ];
             });
         }
+
+        [Test]
+        public void TestRangeUsesNonExpiredItemsIfThereAreAny()
+        {
+            AddStep("set up room", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(new BeatmapInfo { StarRating = 1 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 2 }) { ID = TestResources.GetNextTestID(), Expired = false },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 3 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 4 }) { ID = TestResources.GetNextTestID(), Expired = false },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 5 }) { ID = TestResources.GetNextTestID(), Expired = false },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 6 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 7 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                ];
+            });
+            AddAssert("minimum is 2.00*", () => this.ChildrenOfType<StarRatingDisplay>().ElementAt(0).Current.Value.Stars, () => Is.EqualTo(2));
+            AddAssert("maximum is 5.00*", () => this.ChildrenOfType<StarRatingDisplay>().ElementAt(1).Current.Value.Stars, () => Is.EqualTo(5));
+        }
+
+        [Test]
+        public void TestRangeUsesAllItemsIfAllAreExpired()
+        {
+            AddStep("set up room", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(new BeatmapInfo { StarRating = 1 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 2 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 3 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 4 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 5 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 6 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                    new PlaylistItem(new BeatmapInfo { StarRating = 7 }) { ID = TestResources.GetNextTestID(), Expired = true },
+                ];
+            });
+            AddAssert("minimum is 1.00*", () => this.ChildrenOfType<StarRatingDisplay>().ElementAt(0).Current.Value.Stars, () => Is.EqualTo(1));
+            AddAssert("maximum is 7.00*", () => this.ChildrenOfType<StarRatingDisplay>().ElementAt(1).Current.Value.Stars, () => Is.EqualTo(7));
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
index e7172cacbf..1dd39e5bf9 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
@@ -181,7 +181,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("beatmap in song select", () =>
             {
                 var songSelect = (SoloSongSelect)Game.ScreenStack.CurrentScreen;
-                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().GetCarouselItems()!.Any(i => i.Model is BeatmapSetInfo bsi && bsi.MatchesOnlineID(getImport()));
+                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().GetCarouselItems()!.Any(i => i.Model is GroupedBeatmapSet gbs && gbs.BeatmapSet.MatchesOnlineID(getImport()));
             });
         }
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index d50fc69823..8a0c9f561c 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -75,6 +75,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for dialog overlay", () => Game.ChildrenOfType<DialogOverlay>().SingleOrDefault() != null);
 
             PushAndConfirm(() => playlistScreen = new Screens.OnlinePlay.Playlists.Playlists());
+            AddUntilStep("wait for lounge", () => (playlistScreen.CurrentSubScreen as LoungeSubScreen)?.IsLoaded == true);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
@@ -679,7 +680,6 @@ namespace osu.Game.Tests.Visual.Navigation
             {
                 var dropdownItem = Game
                                    .ChildrenOfType<BeatmapLeaderboardWedge>().First()
-                                   .ChildrenOfType<OsuContextMenu>().First()
                                    .ChildrenOfType<DrawableOsuMenuItem>().First(i => i.Item.Text.ToString() == "Delete");
 
                 InputManager.MoveMouseTo(dropdownItem);
@@ -696,44 +696,6 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for score panel removal", () => scorePanel.Parent == null);
         }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestSongContinuesAfterExitPlayer(bool withUserPause)
-        {
-            Player player = null;
-
-            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
-
-            Screens.SelectV2.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new SoloSongSelect());
-            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
-
-            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
-
-            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
-
-            if (withUserPause)
-                AddStep("pause", () => Game.Dependencies.Get<MusicController>().Stop(true));
-
-            AddStep("press enter", () => InputManager.Key(Key.Enter));
-
-            AddUntilStep("wait for player", () =>
-            {
-                DismissAnyNotifications();
-                return (player = Game.ScreenStack.CurrentScreen as Player) != null;
-            });
-
-            AddUntilStep("wait for fail", () => player.GameplayState.HasFailed);
-
-            AddUntilStep("wait for track stop", () => !Game.MusicController.IsPlaying);
-            AddAssert("Ensure time before preview point", () => Game.MusicController.CurrentTrack.CurrentTime < beatmap().BeatmapInfo.Metadata.PreviewTime);
-
-            pushEscape();
-
-            AddUntilStep("wait for track playing", () => Game.MusicController.IsPlaying);
-            AddAssert("Ensure time wasn't reset to preview point", () => Game.MusicController.CurrentTrack.CurrentTime < beatmap().BeatmapInfo.Metadata.PreviewTime);
-        }
-
         [Test]
         public void TestMenuMakesMusic()
         {
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
index fe76b74bcb..02b2db6e31 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
@@ -126,12 +126,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for accuracy counter", () => Game.ChildrenOfType<ArgonAccuracyCounter>().Any(counter => counter.Position != new Vector2()));
             AddStep("dump state of accuracy meter", () => state = JsonConvert.SerializeObject(Game.ChildrenOfType<ArgonAccuracyCounter>().First().CreateSerialisedInfo()));
             AddStep("add any component", () => Game.ChildrenOfType<SkinComponentToolbox.ToolboxComponentButton>().First().TriggerClick());
-            AddStep("undo", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Z);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
+            AddStep("undo", () => InputManager.Keys(PlatformAction.Undo));
             AddUntilStep("only one accuracy meter left",
                 () => Game.ChildrenOfType<Player>().Single().ChildrenOfType<ArgonAccuracyCounter>().Count(),
                 () => Is.EqualTo(1));
@@ -163,12 +158,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for accuracy counter", () => Game.ChildrenOfType<ArgonAccuracyCounter>().Any(counter => counter.Position != new Vector2()));
             AddStep("dump state of accuracy meter", () => state = JsonConvert.SerializeObject(Game.ChildrenOfType<ArgonAccuracyCounter>().First().CreateSerialisedInfo()));
             AddStep("add any component", () => Game.ChildrenOfType<SkinComponentToolbox.ToolboxComponentButton>().First().TriggerClick());
-            AddStep("undo", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Z);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
+            AddStep("undo", () => InputManager.Keys(PlatformAction.Undo));
             AddUntilStep("only one accuracy meter left",
                 () => Game.ChildrenOfType<Player>().Single().ChildrenOfType<ArgonAccuracyCounter>().Count(),
                 () => Is.EqualTo(1));
@@ -190,12 +180,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddUntilStep("wait for components", () => skinEditor.ChildrenOfType<SkinBlueprint>().Any());
 
-            AddStep("select all components", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.A);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
+            AddStep("select all components", () => InputManager.Keys(PlatformAction.SelectAll));
 
             AddUntilStep("components selected", () => skinEditor.SelectedComponents.Count > 0);
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
index 676be8fccf..9a1f1dc515 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
@@ -92,6 +92,30 @@ namespace osu.Game.Tests.Visual.Navigation
             waitForScreen<SoloSongSelect>();
         }
 
+        [Test]
+        public void TestPresentBeatmapFromMainMenuUsesPreviewPoint()
+        {
+            BeatmapSetInfo beatmapInfo = null!;
+
+            AddStep("import beatmap", () =>
+            {
+                var task = BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true);
+                task.WaitSafely();
+                beatmapInfo = task.GetResultSafely();
+            });
+
+            AddStep("present beatmap", () => Game.PresentBeatmap(beatmapInfo));
+
+            AddUntilStep("wait for track playing", () => Game.MusicController.IsPlaying);
+
+            AddAssert("ensure time is reset to preview point",
+                () =>
+                {
+                    double timeFromPreviewPoint = Math.Abs(Game.MusicController.CurrentTrack.CurrentTime - beatmapInfo.Metadata.PreviewTime);
+                    return timeFromPreviewPoint < 5000;
+                });
+        }
+
         [TestCase(true)]
         [TestCase(false)]
         public void TestSongContinuesAfterExitPlayer(bool withUserPause)
diff --git a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
index f36ef7a8e8..b164c530cb 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
@@ -10,14 +10,16 @@ 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;
+using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.BeatmapSet.Scores;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Select.Details;
@@ -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);
         }
 
@@ -271,7 +274,7 @@ namespace osu.Game.Tests.Visual.Online
         public void TestSelectedModsDontAffectStatistics()
         {
             AddStep("show map", () => overlay.ShowBeatmapSet(getBeatmapSet()));
-            AddAssert("AR displayed as 0", () => overlay.ChildrenOfType<AdvancedStats.StatisticRow>().Single(s => s.Title == BeatmapsetsStrings.ShowStatsAr).Value, () => Is.EqualTo((0, 0)));
+            AddAssert("AR displayed as 0", () => overlay.ChildrenOfType<AdvancedStats.StatisticRow>().Single(s => s.Title == SongSelectStrings.ApproachRate).Value, () => Is.EqualTo((0, 0)));
             AddStep("set AR10 diff adjust", () => SelectedMods.Value = new[]
             {
                 new OsuModDifficultyAdjust
@@ -279,7 +282,7 @@ namespace osu.Game.Tests.Visual.Online
                     ApproachRate = { Value = 10 }
                 }
             });
-            AddAssert("AR still displayed as 0", () => overlay.ChildrenOfType<AdvancedStats.StatisticRow>().Single(s => s.Title == BeatmapsetsStrings.ShowStatsAr).Value, () => Is.EqualTo((0, 0)));
+            AddAssert("AR still displayed as 0", () => overlay.ChildrenOfType<AdvancedStats.StatisticRow>().Single(s => s.Title == SongSelectStrings.ApproachRate).Value, () => Is.EqualTo((0, 0)));
         }
 
         [Test]
@@ -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/Online/TestSceneMessageNotifier.cs b/osu.Game.Tests/Visual/Online/TestSceneMessageNotifier.cs
index ba2b160fd1..274d7f0c51 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneMessageNotifier.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneMessageNotifier.cs
@@ -40,8 +40,8 @@ namespace osu.Game.Tests.Visual.Online
                 daa.HandleRequest = dummyAPIHandleRequest;
             }
 
-            friend = new APIUser { Id = 0, Username = "Friend" };
-            publicChannel = new Channel { Id = 1, Name = "osu" };
+            friend = new APIUser { Id = 0, Username = "SomeFriend" };
+            publicChannel = new Channel { Id = 1, Name = "#osu" };
             privateMessageChannel = new Channel(friend) { Id = 2, Name = friend.Username, Type = ChannelType.PM };
 
             Schedule(() =>
@@ -93,6 +93,17 @@ namespace osu.Game.Tests.Visual.Online
             }
         }
 
+        [Test]
+        public void TestLongMessages()
+        {
+            AddStep("close overlay", () => testContainer.ChatOverlay.Hide());
+
+            AddStep("long public", () => receiveMessage(friend, publicChannel, $"For some reason there were no tests testing very long messages, even though there should have been. Why {API.LocalUser.Value.Username} why?"));
+
+            AddStep("long private",
+                () => receiveMessage(friend, privateMessageChannel, "For no good reason, we were not testing very long messages and how the notifications display when the message can't fit"));
+        }
+
         [Test]
         public void TestPublicChannelMention()
         {
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/Ranking/TestSceneStatisticsPanel.cs b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
index f92dc0313e..b682ec7265 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
@@ -256,6 +256,7 @@ namespace osu.Game.Tests.Visual.Ranking
             var score = TestResources.CreateTestScoreInfo();
             score.Rank = ScoreRank.D;
 
+            setUpTaggingRequests(() => score.BeatmapInfo);
             AddStep("load panel", () =>
             {
                 Child = new PopoverContainer
@@ -278,6 +279,7 @@ namespace osu.Game.Tests.Visual.Ranking
             var score = TestResources.CreateTestScoreInfo();
             score.Ruleset = new ManiaRuleset().RulesetInfo;
 
+            setUpTaggingRequests(() => score.BeatmapInfo);
             AddStep("load panel", () =>
             {
                 Child = new PopoverContainer
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
index b63f8ca31c..b7836b6e44 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
@@ -28,11 +28,16 @@ namespace osu.Game.Tests.Visual.Ranking
 
         private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
+        private int writeRequestCount;
+
         [SetUpSteps]
         public void SetUpSteps()
         {
+            AddStep("reset mouse position", () => InputManager.MoveMouseTo(Vector2.Zero));
+
             AddStep("set up network requests", () =>
             {
+                writeRequestCount = 0;
                 dummyAPI.HandleRequest = request =>
                 {
                     switch (request)
@@ -77,6 +82,7 @@ namespace osu.Game.Tests.Visual.Ranking
                         case AddBeatmapTagRequest:
                         case RemoveBeatmapTagRequest:
                         {
+                            writeRequestCount++;
                             Scheduler.AddDelayed(request.TriggerSuccess, 500);
                             return true;
                         }
@@ -107,6 +113,31 @@ namespace osu.Game.Tests.Visual.Ranking
             });
         }
 
+        [Test]
+        public void TestNotWritable()
+        {
+            AddStep("show", () =>
+            {
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.BeatmapInfo.OnlineID = 42;
+                Beatmap.Value = working;
+                recreateControl(writable: false);
+            });
+
+            AddUntilStep("click tag", () =>
+            {
+                var tag = this.ChildrenOfType<UserTagControl.DrawableUserTag>().FirstOrDefault(t => t.UserTag.Id == 2);
+                if (tag == null)
+                    return false;
+
+                InputManager.MoveMouseTo(tag);
+                InputManager.Click(MouseButton.Left);
+                return true;
+            });
+
+            AddAssert("no vote requests send", () => writeRequestCount, () => Is.Zero);
+        }
+
         [Test]
         public void TestTagsDoNotMoveUntilMouseMovesAway()
         {
@@ -148,13 +179,14 @@ namespace osu.Game.Tests.Visual.Ranking
             UserTagControl.DrawableUserTag getDrawableTagById(long id) => getTagFlow().Single(t => t.UserTag.Id == id);
         }
 
-        private void recreateControl()
+        private void recreateControl(bool writable = true)
         {
             Child = new PopoverContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 Child = new UserTagControl(Beatmap.Value.BeatmapInfo)
                 {
+                    Writable = writable,
                     Width = 700,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
index 9f0dc75f84..e9f70180e1 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
@@ -133,6 +133,8 @@ namespace osu.Game.Tests.Visual.Settings
         {
             public Bindable<Vector2> AreaOffset { get; } = new Bindable<Vector2>();
             public Bindable<Vector2> AreaSize { get; } = new Bindable<Vector2>();
+            public Bindable<Vector2> OutputAreaOffset { get; } = new Bindable<Vector2>();
+            public Bindable<Vector2> OutputAreaSize { get; } = new Bindable<Vector2>();
 
             public Bindable<float> Rotation { get; } = new Bindable<float>();
 
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
index 5cf503f21e..3afc8cd1a4 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
@@ -8,11 +8,10 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
-using osu.Game.Resources.Localisation.Web;
+using osu.Game.Localisation;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mods;
@@ -42,7 +41,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private BeatmapInfo exampleBeatmapInfo => new BeatmapInfo
         {
-            Ruleset = rulesets.AvailableRulesets.First(),
+            Ruleset = rulesets.GetRuleset(0)!,
             Difficulty = new BeatmapDifficulty
             {
                 CircleSize = 7.2f,
@@ -56,30 +55,39 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestNoMod()
         {
-            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
+            AddStep("set beatmap and ruleset", () =>
+            {
+                advancedStats.BeatmapInfo = exampleBeatmapInfo;
+                advancedStats.Ruleset.Value = exampleBeatmapInfo.Ruleset;
+            });
 
             AddStep("no mods selected", () => SelectedMods.Value = Array.Empty<Mod>());
 
-            AddAssert("first bar text is correct", () => advancedStats.ChildrenOfType<SpriteText>().First().Text == BeatmapsetsStrings.ShowStatsCs);
-            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
-            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.HpDrain));
-            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
-            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.ApproachRate));
+            AddAssert("first bar text is correct", () => advancedStats.GetStatistic(SongSelectStrings.CircleSize), () => Is.Not.Null);
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.CircleSize)));
+            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.HPDrain)));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.Accuracy)));
+            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.ApproachRate)));
         }
 
         [Test]
         public void TestFirstBarText()
         {
+            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
             AddStep("set ruleset to mania", () => advancedStats.Ruleset.Value = new ManiaRuleset().RulesetInfo);
-            AddAssert("first bar text is correct", () => advancedStats.ChildrenOfType<SpriteText>().First().Text == BeatmapsetsStrings.ShowStatsCsMania);
+            AddAssert("first bar text is correct", () => advancedStats.GetStatistic(SongSelectStrings.KeyCount), () => Is.Not.Null);
             AddStep("set ruleset to osu", () => advancedStats.Ruleset.Value = new OsuRuleset().RulesetInfo);
-            AddAssert("first bar text is correct", () => advancedStats.ChildrenOfType<SpriteText>().First().Text == BeatmapsetsStrings.ShowStatsCs);
+            AddAssert("first bar text is correct", () => advancedStats.GetStatistic(SongSelectStrings.CircleSize), () => Is.Not.Null);
         }
 
         [Test]
         public void TestEasyMod()
         {
-            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
+            AddStep("set beatmap and ruleset", () =>
+            {
+                advancedStats.BeatmapInfo = exampleBeatmapInfo;
+                advancedStats.Ruleset.Value = exampleBeatmapInfo.Ruleset;
+            });
 
             AddStep("select EZ mod", () =>
             {
@@ -87,16 +95,20 @@ namespace osu.Game.Tests.Visual.SongSelect
                 advancedStats.Mods.Value = new[] { ruleset.CreateMod<ModEasy>() };
             });
 
-            AddAssert("circle size bar is blue", () => barIsBlue(advancedStats.FirstValue));
-            AddAssert("HP drain bar is blue", () => barIsBlue(advancedStats.HpDrain));
-            AddAssert("accuracy bar is blue", () => barIsBlue(advancedStats.Accuracy));
-            AddAssert("approach rate bar is blue", () => barIsBlue(advancedStats.ApproachRate));
+            AddAssert("circle size bar is blue", () => barIsBlue(advancedStats.GetStatistic(SongSelectStrings.CircleSize)));
+            AddAssert("HP drain bar is blue", () => barIsBlue(advancedStats.GetStatistic(SongSelectStrings.HPDrain)));
+            AddAssert("accuracy bar is blue", () => barIsBlue(advancedStats.GetStatistic(SongSelectStrings.Accuracy)));
+            AddAssert("approach rate bar is blue", () => barIsBlue(advancedStats.GetStatistic(SongSelectStrings.ApproachRate)));
         }
 
         [Test]
         public void TestHardRockMod()
         {
-            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
+            AddStep("set beatmap and ruleset", () =>
+            {
+                advancedStats.BeatmapInfo = exampleBeatmapInfo;
+                advancedStats.Ruleset.Value = exampleBeatmapInfo.Ruleset;
+            });
 
             AddStep("select HR mod", () =>
             {
@@ -104,16 +116,20 @@ namespace osu.Game.Tests.Visual.SongSelect
                 advancedStats.Mods.Value = new[] { ruleset.CreateMod<ModHardRock>() };
             });
 
-            AddAssert("circle size bar is red", () => barIsRed(advancedStats.FirstValue));
-            AddAssert("HP drain bar is red", () => barIsRed(advancedStats.HpDrain));
-            AddAssert("accuracy bar is red", () => barIsRed(advancedStats.Accuracy));
-            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.ApproachRate));
+            AddAssert("circle size bar is red", () => barIsRed(advancedStats.GetStatistic(SongSelectStrings.CircleSize)));
+            AddAssert("HP drain bar is red", () => barIsRed(advancedStats.GetStatistic(SongSelectStrings.HPDrain)));
+            AddAssert("accuracy bar is red", () => barIsRed(advancedStats.GetStatistic(SongSelectStrings.Accuracy)));
+            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.GetStatistic(SongSelectStrings.ApproachRate)));
         }
 
         [Test]
         public void TestUnchangedDifficultyAdjustMod()
         {
-            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
+            AddStep("set beatmap and ruleset", () =>
+            {
+                advancedStats.BeatmapInfo = exampleBeatmapInfo;
+                advancedStats.Ruleset.Value = exampleBeatmapInfo.Ruleset;
+            });
 
             AddStep("select unchanged Difficulty Adjust mod", () =>
             {
@@ -122,16 +138,20 @@ namespace osu.Game.Tests.Visual.SongSelect
                 advancedStats.Mods.Value = new[] { difficultyAdjustMod };
             });
 
-            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
-            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.HpDrain));
-            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
-            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.ApproachRate));
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.CircleSize)));
+            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.HPDrain)));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.Accuracy)));
+            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.ApproachRate)));
         }
 
         [Test]
         public void TestChangedDifficultyAdjustMod()
         {
-            AddStep("set beatmap", () => advancedStats.BeatmapInfo = exampleBeatmapInfo);
+            AddStep("set beatmap and ruleset", () =>
+            {
+                advancedStats.BeatmapInfo = exampleBeatmapInfo;
+                advancedStats.Ruleset.Value = exampleBeatmapInfo.Ruleset;
+            });
 
             AddStep("select changed Difficulty Adjust mod", () =>
             {
@@ -144,10 +164,10 @@ namespace osu.Game.Tests.Visual.SongSelect
                 advancedStats.Mods.Value = new[] { difficultyAdjustMod };
             });
 
-            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
-            AddAssert("drain rate bar is blue", () => barIsBlue(advancedStats.HpDrain));
-            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
-            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.ApproachRate));
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.CircleSize)));
+            AddAssert("drain rate bar is blue", () => barIsBlue(advancedStats.GetStatistic(SongSelectStrings.HPDrain)));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.GetStatistic(SongSelectStrings.Accuracy)));
+            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.GetStatistic(SongSelectStrings.ApproachRate)));
         }
 
         private bool barIsWhite(AdvancedStats.StatisticRow row) => row.ModBar.AccentColour == Color4.White;
@@ -156,10 +176,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private partial class TestAdvancedStats : AdvancedStats
         {
-            public new StatisticRow FirstValue => base.FirstValue;
-            public new StatisticRow HpDrain => base.HpDrain;
-            public new StatisticRow Accuracy => base.Accuracy;
-            public new StatisticRow ApproachRate => base.ApproachRate;
+            public StatisticRow GetStatistic(LocalisableString title) => Flow.OfType<StatisticRow>().SingleOrDefault(row => row.Title == title);
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
index fe2bf6ff5d..db004b1d0d 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
@@ -11,11 +11,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Collections;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Tests.Resources;
@@ -64,8 +66,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestEmptyCollectionFilterContainsAllBeatmaps()
         {
-            assertCollectionDropdownContains("All beatmaps");
-            assertCollectionHeaderDisplays("All beatmaps");
+            assertCollectionDropdownContains(CollectionsStrings.AllBeatmaps);
+            assertCollectionHeaderDisplays(CollectionsStrings.AllBeatmaps);
         }
 
         [Test]
@@ -235,13 +237,13 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private BeatmapCollection getFirstCollection() => Realm.Run(r => r.All<BeatmapCollection>().First());
 
-        private void assertCollectionHeaderDisplays(string collectionName, bool shouldDisplay = true)
+        private void assertCollectionHeaderDisplays(LocalisableString collectionName, bool shouldDisplay = true)
             => AddUntilStep($"collection dropdown header displays '{collectionName}'",
                 () => shouldDisplay == dropdown.ChildrenOfType<CollectionDropdown.OsuDropdownHeader>().Any(h => h.ChildrenOfType<SpriteText>().Any(t => t.Text == collectionName)));
 
         private void assertFirstButtonIs(IconUsage icon) => AddUntilStep($"button is {icon.Icon.ToString()}", () => getAddOrRemoveButton(1).Icon.Equals(icon));
 
-        private void assertCollectionDropdownContains(string collectionName, bool shouldContain = true) =>
+        private void assertCollectionDropdownContains(LocalisableString collectionName, bool shouldContain = true) =>
             AddUntilStep($"collection dropdown {(shouldContain ? "contains" : "does not contain")} '{collectionName}'",
                 // A bit of a roundabout way of going about this, see: https://github.com/ppy/osu-framework/issues/3871 + https://github.com/ppy/osu-framework/issues/3872
                 () => shouldContain == dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Any(i => i.ChildrenOfType<CompositeDrawable>().OfType<IHasText>().First().Text == collectionName));
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
index 79baae53e8..93b9efed6a 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
@@ -10,6 +10,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Screens.Select.Carousel;
@@ -161,5 +163,53 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("SS rank displayed", () => topLocalRank.DisplayedRank == ScoreRank.X);
         }
+
+        [Test]
+        public void TestGuestScore()
+        {
+            AddStep("Add score for guest user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new GuestUser();
+                testScoreInfo.Rank = ScoreRank.B;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("B rank displayed", () => topLocalRank.DisplayedRank, () => Is.EqualTo(ScoreRank.B));
+        }
+
+        [Test]
+        public void TestUnknownUserScore()
+        {
+            AddStep("Add score for unknown user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new APIUser { Username = "AAA", };
+                testScoreInfo.Rank = ScoreRank.S;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("S rank displayed", () => topLocalRank.DisplayedRank, () => Is.EqualTo(ScoreRank.S));
+        }
+
+        [Test]
+        public void TestAnotherUserScore()
+        {
+            AddStep("Add score for not-current user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new APIUser { Username = "notme", Id = 43, };
+                testScoreInfo.Rank = ScoreRank.S;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("No rank displayed", () => topLocalRank.DisplayedRank, () => Is.Null);
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
index 2874384c4d..5f3cd26d55 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
@@ -9,7 +9,9 @@ using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 using osu.Game.Graphics.Carousel;
+using osu.Game.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -40,8 +42,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ];
 
             var results = await runGrouping(GroupMode.None, beatmapSets);
-            Assert.That(results.Select(r => r.Model).OfType<BeatmapSetInfo>(), Is.EquivalentTo(beatmapSets));
-            Assert.That(results.Select(r => r.Model).OfType<BeatmapInfo>(), Is.EquivalentTo(allBeatmaps));
+            Assert.That(results.Select(r => r.Model).OfType<GroupedBeatmapSet>().Select(groupedSet => groupedSet.BeatmapSet), Is.EquivalentTo(beatmapSets));
+            Assert.That(results.Select(r => r.Model).OfType<GroupedBeatmap>().Select(groupedBeatmap => groupedBeatmap.Beatmap), Is.EquivalentTo(allBeatmaps));
             assertTotal(results, beatmapSets.Count + allBeatmaps.Length);
         }
 
@@ -72,11 +74,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyBeatmap('_'), beatmapSets, out var underscoreBeatmap);
 
             var results = await runGrouping(mode, beatmapSets);
-            assertGroup(results, 0, "0-9", new[] { fiveBeatmap, fourBeatmap }, ref total);
-            assertGroup(results, 1, "A", new[] { aBeatmap }, ref total);
-            assertGroup(results, 2, "F", new[] { fBeatmap }, ref total);
-            assertGroup(results, 3, "Z", new[] { zBeatmap }, ref total);
-            assertGroup(results, 4, "Other", new[] { dashBeatmap, underscoreBeatmap }, ref total);
+            assertGroup(results, 0, "0-9", fiveBeatmap.Beatmaps.Concat(fourBeatmap.Beatmaps), ref total);
+            assertGroup(results, 1, "A", aBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "F", fBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Z", zBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "Other", dashBeatmap.Beatmaps.Concat(underscoreBeatmap.Beatmaps), ref total);
             assertTotal(results, total);
         }
 
@@ -108,15 +110,17 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddHours(-5), beatmapSets, out var todayBeatmap);
             addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddDays(-1), beatmapSets, out var yesterdayBeatmap);
             addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddDays(-4), beatmapSets, out var lastWeekBeatmap);
-            addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddDays(-21), beatmapSets, out var oneMonthBeatmap);
-            addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddMonths(-2).AddDays(-3), beatmapSets, out var threeMonthBeatmap);
+            addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddDays(-21), beatmapSets, out var lastMonthBeatmap);
+            addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddMonths(-1).AddDays(-21), beatmapSets, out var oneMonthAgoBeatmap);
+            addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddMonths(-2).AddDays(-3), beatmapSets, out var twoMonthsAgoBeatmap);
 
             var results = await runGrouping(GroupMode.DateAdded, beatmapSets);
-            assertGroup(results, 0, "Today", new[] { todayBeatmap }, ref total);
-            assertGroup(results, 1, "Yesterday", new[] { yesterdayBeatmap }, ref total);
-            assertGroup(results, 2, "Last week", new[] { lastWeekBeatmap }, ref total);
-            assertGroup(results, 3, "1 month ago", new[] { oneMonthBeatmap }, ref total);
-            assertGroup(results, 4, "3 months ago", new[] { threeMonthBeatmap }, ref total);
+            assertGroup(results, 0, "Today", todayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Yesterday", yesterdayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "Last week", lastWeekBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Last month", lastMonthBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "1 month ago", oneMonthAgoBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "2 months ago", twoMonthsAgoBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -129,17 +133,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddHours(-5)), beatmapSets, out var todayBeatmap);
             addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddDays(-1)), beatmapSets, out var yesterdayBeatmap);
             addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddDays(-4)), beatmapSets, out var lastWeekBeatmap);
-            addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddDays(-21)), beatmapSets, out var oneMonthBeatmap);
-            addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddMonths(-2).AddDays(-3)), beatmapSets, out var threeMonthBeatmap);
+            addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddDays(-21)), beatmapSets, out var lastMonthBeatmap);
+            addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddMonths(-1).AddDays(-21)), beatmapSets, out var oneMonthAgoBeatmap);
+            addBeatmapSet(applyLastPlayed(DateTimeOffset.Now.AddMonths(-2).AddDays(-3)), beatmapSets, out var twoMonthsBeatmap);
             addBeatmapSet(applyLastPlayed(null), beatmapSets, out var neverBeatmap);
 
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
-            assertGroup(results, 0, "Today", new[] { todayBeatmap }, ref total);
-            assertGroup(results, 1, "Yesterday", new[] { yesterdayBeatmap }, ref total);
-            assertGroup(results, 2, "Last week", new[] { lastWeekBeatmap }, ref total);
-            assertGroup(results, 3, "1 month ago", new[] { oneMonthBeatmap }, ref total);
-            assertGroup(results, 4, "3 months ago", new[] { threeMonthBeatmap }, ref total);
-            assertGroup(results, 5, "Never", new[] { neverBeatmap }, ref total);
+            assertGroup(results, 0, "Today", todayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Yesterday", yesterdayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "Last week", lastWeekBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Last month", lastMonthBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "1 month ago", oneMonthAgoBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "2 months ago", twoMonthsBeatmap.Beatmaps, ref total);
+            assertGroup(results, 6, "Never", neverBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -156,7 +162,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
             int total = 0;
 
-            assertGroup(results, 0, "Today", new[] { set }, ref total);
+            assertGroup(results, 0, "Today", [set.Beatmaps[2]], ref total);
+            assertGroup(results, 1, "Never", [set.Beatmaps[0], set.Beatmaps[1]], ref total);
             assertTotal(results, total);
         }
 
@@ -170,8 +177,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
             int total = 0;
 
-            assertGroup(results, 0, "Over 5 months ago", new[] { overFiveMonthsBeatmap }, ref total);
-            assertGroup(results, 1, "Never", new[] { neverBeatmap }, ref total);
+            assertGroup(results, 0, "Over 5 months ago", overFiveMonthsBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Never", neverBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -201,14 +208,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.Status = BeatmapOnlineStatus.LocallyModified, beatmapSets, out var localBeatmap);
 
             var results = await runGrouping(GroupMode.RankedStatus, beatmapSets);
-            assertGroup(results, 0, "Ranked", new[] { rankedBeatmap, approvedBeatmap }, ref total);
-            assertGroup(results, 1, "Qualified", new[] { qualifiedBeatmap }, ref total);
-            assertGroup(results, 2, "WIP", new[] { wipBeatmap }, ref total);
-            assertGroup(results, 3, "Pending", new[] { pendingBeatmap }, ref total);
-            assertGroup(results, 4, "Graveyard", new[] { graveyardBeatmap }, ref total);
-            assertGroup(results, 5, "Local", new[] { localBeatmap }, ref total);
-            assertGroup(results, 6, "Unknown", new[] { noneBeatmap }, ref total);
-            assertGroup(results, 7, "Loved", new[] { lovedBeatmap }, ref total);
+            assertGroup(results, 0, "Ranked", rankedBeatmap.Beatmaps.Concat(approvedBeatmap.Beatmaps), ref total);
+            assertGroup(results, 1, "Qualified", qualifiedBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "WIP", wipBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Pending", pendingBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "Graveyard", graveyardBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "Local", localBeatmap.Beatmaps, ref total);
+            assertGroup(results, 6, "Unknown", noneBeatmap.Beatmaps, ref total);
+            assertGroup(results, 7, "Loved", lovedBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -223,19 +230,23 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             var beatmapSets = new List<BeatmapSetInfo>();
             addBeatmapSet(applyBPM(30), beatmapSets, out var beatmap30);
+            addBeatmapSet(applyBPM(59.5), beatmapSets, out var beatmap59);
             addBeatmapSet(applyBPM(60), beatmapSets, out var beatmap60);
             addBeatmapSet(applyBPM(90), beatmapSets, out var beatmap90);
-            addBeatmapSet(applyBPM(120), beatmapSets, out var beatmap120);
+            addBeatmapSet(applyBPM(95), beatmapSets, out var beatmap95);
+            addBeatmapSet(applyBPM(269.5), beatmapSets, out var beatmap269);
             addBeatmapSet(applyBPM(270), beatmapSets, out var beatmap270);
+            addBeatmapSet(applyBPM(299), beatmapSets, out var beatmap299);
             addBeatmapSet(applyBPM(300), beatmapSets, out var beatmap300);
             addBeatmapSet(applyBPM(330), beatmapSets, out var beatmap330);
 
             var results = await runGrouping(GroupMode.BPM, beatmapSets);
-            assertGroup(results, 0, "Under 60 BPM", new[] { beatmap30 }, ref total);
-            assertGroup(results, 1, "Under 120 BPM", new[] { beatmap60, beatmap90 }, ref total);
-            assertGroup(results, 2, "Under 180 BPM", new[] { beatmap120 }, ref total);
-            assertGroup(results, 3, "Under 300 BPM", new[] { beatmap270 }, ref total);
-            assertGroup(results, 4, "Over 300 BPM", new[] { beatmap300, beatmap330 }, ref total);
+            assertGroup(results, 0, "Under 60 BPM", beatmap30.Beatmaps, ref total);
+            assertGroup(results, 1, "60 - 70 BPM", (beatmap59.Beatmaps.Concat(beatmap60.Beatmaps)), ref total);
+            assertGroup(results, 2, "90 - 100 BPM", (beatmap90.Beatmaps.Concat(beatmap95.Beatmaps)), ref total);
+            assertGroup(results, 3, "270 - 280 BPM", (beatmap269.Beatmaps.Concat(beatmap270.Beatmaps)), ref total);
+            assertGroup(results, 4, "290 - 300 BPM", beatmap299.Beatmaps, ref total);
+            assertGroup(results, 5, "Over 300 BPM", (beatmap300.Beatmaps.Concat(beatmap330.Beatmaps)), ref total);
             assertTotal(results, total);
         }
 
@@ -262,10 +273,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyStars(7), beatmapSets, out var beatmap7);
 
             var results = await runGrouping(GroupMode.Difficulty, beatmapSets);
-            assertGroup(results, 0, "Below 1 Star", new[] { beatmapBelow1 }, ref total);
-            assertGroup(results, 1, "1 Star", new[] { beatmapAbove1, beatmapAlmost2 }, ref total);
-            assertGroup(results, 2, "2 Stars", new[] { beatmap2, beatmapAbove2 }, ref total);
-            assertGroup(results, 3, "7 Stars", new[] { beatmap7 }, ref total);
+            assertGroup(results, 0, "Below 1 Star", beatmapBelow1.Beatmaps, ref total);
+            assertGroup(results, 1, "1 Star", (beatmapAbove1.Beatmaps.Concat(beatmapAlmost2.Beatmaps)), ref total);
+            assertGroup(results, 2, "2 Stars", (beatmap2.Beatmaps.Concat(beatmapAbove2.Beatmaps)), ref total);
+            assertGroup(results, 3, "7 Stars", beatmap7.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -294,11 +305,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyLength(630_000), beatmapSets, out var beatmap10Min30Sec);
 
             var results = await runGrouping(GroupMode.Length, beatmapSets);
-            assertGroup(results, 0, "1 minute or less", new[] { beatmap30Sec, beatmap1Min }, ref total);
-            assertGroup(results, 1, "2 minutes or less", new[] { beatmap1Min30Sec, beatmap2Min }, ref total);
-            assertGroup(results, 2, "5 minutes or less", new[] { beatmap5Min }, ref total);
-            assertGroup(results, 3, "10 minutes or less", new[] { beatmap6Min, beatmap10Min }, ref total);
-            assertGroup(results, 4, "Over 10 minutes", new[] { beatmap10Min30Sec }, ref total);
+            assertGroup(results, 0, "1 minute or less", (beatmap30Sec.Beatmaps.Concat(beatmap1Min.Beatmaps)), ref total);
+            assertGroup(results, 1, "2 minutes or less", (beatmap1Min30Sec.Beatmaps.Concat(beatmap2Min.Beatmaps)), ref total);
+            assertGroup(results, 2, "5 minutes or less", beatmap5Min.Beatmaps, ref total);
+            assertGroup(results, 3, "10 minutes or less", (beatmap6Min.Beatmaps.Concat(beatmap10Min.Beatmaps)), ref total);
+            assertGroup(results, 4, "Over 10 minutes", beatmap10Min30Sec.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -324,10 +335,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.DateRanked = null, beatmapSets, out var beatmapUnranked);
 
             var results = await runGrouping(GroupMode.DateRanked, beatmapSets);
-            assertGroup(results, 0, "2025", new[] { beatmap2025 }, ref total);
-            assertGroup(results, 1, "2010", new[] { beatmap2010 }, ref total);
-            assertGroup(results, 2, "2007", new[] { beatmapOct2007, beatmapDec2007 }, ref total);
-            assertGroup(results, 3, "Unranked", new[] { beatmapUnranked }, ref total);
+            assertGroup(results, 0, "2025", beatmap2025.Beatmaps, ref total);
+            assertGroup(results, 1, "2010", beatmap2010.Beatmaps, ref total);
+            assertGroup(results, 2, "2007", (beatmapOct2007.Beatmaps.Concat(beatmapDec2007.Beatmaps)), ref total);
+            assertGroup(results, 3, "Unranked", beatmapUnranked.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -347,9 +358,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             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);
+            assertGroup(results, 0, "Cool Game", (beatmapCoolGame.Beatmaps.Concat(beatmapCoolGameB.Beatmaps)), ref total);
+            assertGroup(results, 1, "Nice Movie", beatmapNiceMovie.Beatmaps, ref total);
+            assertGroup(results, 2, "Unsourced", beatmapUnsourced.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -357,11 +368,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private static async Task<List<CarouselItem>> runGrouping(GroupMode group, List<BeatmapSetInfo> beatmapSets)
         {
-            var groupingFilter = new BeatmapCarouselFilterGrouping(() => new FilterCriteria { Group = group });
+            var groupingFilter = new BeatmapCarouselFilterGrouping(
+                () => new FilterCriteria { Group = group },
+                () => new List<BeatmapCollection>(),
+                _ => new Dictionary<Guid, ScoreRank>());
+
             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)
+        private static void assertGroup(List<CarouselItem> items, int index, string expectedTitle, IEnumerable<BeatmapInfo> expectedBeatmaps, ref int totalItems)
         {
             var groupItem = items.Where(i => i.Model is GroupDefinition).ElementAtOrDefault(index);
 
@@ -376,7 +391,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             var groupModel = (GroupDefinition)groupItem.Model;
 
             Assert.That(groupModel.Title, Is.EqualTo(expectedTitle));
-            Assert.That(itemsInGroup.Select(i => i.Model).OfType<BeatmapInfo>(), Is.EquivalentTo(expectedBeatmapSets.SelectMany(bs => bs.Beatmaps)));
+            Assert.That(itemsInGroup.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap), Is.EquivalentTo(expectedBeatmaps));
 
             totalItems += itemsInGroup.Count() + 1;
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
index bc507fbffa..a180097863 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
@@ -16,11 +16,13 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
 using osu.Game.Overlays;
+using osu.Game.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -115,13 +117,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                                     NewItemsPresented = _ => NewItemsPresentedInvocationCount++,
                                     RequestSelection = b =>
                                     {
-                                        BeatmapRequestedSelections.Push(b);
-                                        Carousel.CurrentSelection = b;
+                                        BeatmapRequestedSelections.Push(b.Beatmap);
+                                        Carousel.CurrentGroupedBeatmap = b;
                                     },
-                                    RequestRecommendedSelection = beatmaps =>
+                                    RequestRecommendedSelection = groupedBeatmaps =>
                                     {
-                                        BeatmapSetRequestedSelections.Push(beatmaps.First().BeatmapSet!);
-                                        Carousel.CurrentSelection = BeatmapRecommendationFunction?.Invoke(beatmaps) ?? beatmaps.First();
+                                        var recommendedBeatmap = BeatmapRecommendationFunction?.Invoke(groupedBeatmaps.Select(gb => gb.Beatmap)) ?? groupedBeatmaps.First().Beatmap;
+                                        var recommendedGroupedBeatmap = groupedBeatmaps.First(gb => gb.Beatmap.Equals(recommendedBeatmap));
+                                        BeatmapSetRequestedSelections.Push(recommendedBeatmap.BeatmapSet!);
+                                        Carousel.CurrentGroupedBeatmap = recommendedGroupedBeatmap;
                                     },
                                     BleedTop = 50,
                                     BleedBottom = 50,
@@ -215,8 +219,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         protected void Select() => AddStep("select", () => InputManager.Key(Key.Enter));
 
-        protected void CheckNoSelection() => AddAssert("has no selection", () => Carousel.CurrentSelection, () => Is.Null);
-        protected void CheckHasSelection() => AddAssert("has selection", () => Carousel.CurrentSelection, () => Is.Not.Null);
+        protected void CheckNoSelection() => AddAssert("has no selection", () => Carousel.CurrentGroupedBeatmap, () => Is.Null);
+        protected void CheckHasSelection() => AddAssert("has selection", () => Carousel.CurrentGroupedBeatmap, () => Is.Not.Null);
 
         protected void CheckRequestPresentCount(int expected) =>
             AddAssert($"check present count is {expected}", () => Carousel.RequestPresentBeatmapCount, () => Is.EqualTo(expected));
@@ -237,7 +241,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 // Using groupingFilter.SetItems.Count alone doesn't work.
                 // When sorting by difficulty, there can be more than one set panel for the same set displayed.
-                return groupingFilter.SetItems.Sum(s => s.Value.Count(i => i.Model is BeatmapSetInfo));
+                return groupingFilter.SetItems.Sum(s => s.Value.Count(i => i.Model is GroupedBeatmapSet));
             }, () => Is.EqualTo(expected));
         }
 
@@ -281,8 +285,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 // offset by one because the group itself is included in the items list.
                 CarouselItem item = groupingFilter.GroupItems[groupDefinition].ElementAt(panel + 1);
 
-                return (Carousel.CurrentSelection as BeatmapInfo)?
-                    .Equals(item.Model as BeatmapInfo) == true;
+                return Carousel.CurrentGroupedBeatmap?.Equals(item.Model as GroupedBeatmap) == true;
             });
         }
 
@@ -291,12 +294,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             if (diff != null)
             {
                 AddUntilStep($"selected is set{set} diff{diff.Value}",
-                    () => (Carousel.CurrentSelection as BeatmapInfo),
+                    () => Carousel.CurrentBeatmap,
                     () => Is.EqualTo(BeatmapSets[set].Beatmaps[diff.Value]));
             }
             else
             {
-                AddUntilStep($"selected is set{set}", () => BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentSelection));
+                AddUntilStep($"selected is set{set}", () => BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentBeatmap!));
             }
         }
 
@@ -415,7 +418,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                                 tracked: {Carousel.ItemsTracked}
                                 displayable: {Carousel.DisplayableItems}
                                 displayed: {Carousel.VisibleItems}
-                                selected: {Carousel.CurrentSelection}
+                                selected: {Carousel.CurrentGroupedBeatmap}
                                 """);
 
             void createHeader(string text)
@@ -437,12 +440,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             public IEnumerable<BeatmapInfo> PostFilterBeatmaps = null!;
 
-            public BeatmapInfo? SelectedBeatmapInfo => CurrentSelection as BeatmapInfo;
+            public BeatmapInfo? SelectedBeatmapInfo => (CurrentSelection as GroupedBeatmap)?.Beatmap;
             public BeatmapSetInfo? SelectedBeatmapSet => SelectedBeatmapInfo?.BeatmapSet;
 
-            public new BeatmapSetInfo? ExpandedBeatmapSet => base.ExpandedBeatmapSet;
+            public new GroupedBeatmapSet? ExpandedBeatmapSet => base.ExpandedBeatmapSet;
             public new GroupDefinition? ExpandedGroup => base.ExpandedGroup;
 
+            public Func<List<BeatmapCollection>> AllCollections { get; set; } = () => [];
+            public Func<FilterCriteria, Dictionary<Guid, ScoreRank>> BeatmapInfoGuidToTopRankMapping { get; set; } = _ => new Dictionary<Guid, ScoreRank>();
+
             public TestBeatmapCarousel()
             {
                 RequestPresentBeatmap = _ => RequestPresentBeatmapCount++;
@@ -461,9 +467,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 if (FilterDelay != 0)
                     await Task.Delay(FilterDelay).ConfigureAwait(true);
 
-                PostFilterBeatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+                PostFilterBeatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>().Select(i => i.Beatmap);
                 return items;
             }
+
+            protected override List<BeatmapCollection> GetAllCollections() => AllCollections.Invoke();
+            protected override Dictionary<Guid, ScoreRank> GetBeatmapInfoGuidToTopRankMapping(FilterCriteria criteria) => BeatmapInfoGuidToTopRankMapping.Invoke(criteria);
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
index c704f21fa4..e3b02e5905 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;
@@ -21,8 +22,6 @@ using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Screens;
-using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -42,9 +41,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         protected Screens.SelectV2.SongSelect SongSelect { get; private set; } = null!;
         protected BeatmapCarousel Carousel => SongSelect.ChildrenOfType<BeatmapCarousel>().Single();
 
-        [Cached]
-        protected readonly ScreenFooter Footer;
-
         [Cached]
         private readonly OsuLogo logo;
 
@@ -71,10 +67,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                         {
                             State = { Value = Visibility.Visible },
                         },
-                        Footer = new ScreenFooter
-                        {
-                            BackButtonPressed = () => Stack.CurrentScreen.Exit(),
-                        },
                         logo = new OsuLogo
                         {
                             Alpha = 0f,
@@ -110,14 +102,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             Add(beatmapStore);
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Stack.ScreenPushed += updateFooter;
-            Stack.ScreenExited += updateFooter;
-        }
-
         public override void SetUpSteps()
         {
             base.SetUpSteps();
@@ -145,14 +129,34 @@ 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 WaitForFiltering() => AddUntilStep("wait for filtering", () => !SongSelect.IsFiltering);
+
+        protected void ImportBeatmapForRuleset(params int[] rulesetIds) => ImportBeatmapForRuleset(_ => { }, 3, rulesetIds);
+
+        protected void ImportBeatmapForRuleset(Action<BeatmapSetInfo> applyToBeatmap, int difficultyCount, 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()));
+
+                var beatmapSet = TestResources.CreateTestBeatmapSetInfo(difficultyCount, Rulesets.AvailableRulesets.Where(r => rulesetIds.Contains(r.OnlineID)).ToArray());
+                applyToBeatmap(beatmapSet);
+                Beatmaps.Import(beatmapSet);
             });
 
             // This is specifically for cases where the add is happening post song select load.
@@ -186,38 +190,5 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         protected void WaitForSuspension() => AddUntilStep("wait for not current", () => !SongSelect.AsNonNull().IsCurrentScreen());
-
-        private void updateFooter(IScreen? _, IScreen? newScreen)
-        {
-            if (newScreen is OsuScreen osuScreen && osuScreen.ShowFooter)
-            {
-                Footer.Show();
-
-                if (osuScreen.IsLoaded)
-                    updateFooterButtons();
-                else
-                {
-                    // ensure the current buttons are immediately disabled on screen change (so they can't be pressed).
-                    Footer.SetButtons(Array.Empty<ScreenFooterButton>());
-
-                    osuScreen.OnLoadComplete += _ => updateFooterButtons();
-                }
-
-                void updateFooterButtons()
-                {
-                    var buttons = osuScreen.CreateFooterButtons();
-
-                    osuScreen.LoadComponentsAgainstScreenDependencies(buttons);
-
-                    Footer.SetButtons(buttons);
-                    Footer.Show();
-                }
-            }
-            else
-            {
-                Footer.Hide();
-                Footer.SetButtons(Array.Empty<ScreenFooterButton>());
-            }
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
index 521221f0c7..c34077889d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -81,7 +80,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -92,9 +91,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
 
@@ -132,7 +131,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForBeatmapSelection(0, 1);
             // Expanding a group will move keyboard selection to the selected beatmap if contained.
             AddAssert("keyboard selected panel is expanded", () => groupPanel?.Expanded.Value, () => Is.True);
-            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<BeatmapInfo>);
+            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<GroupedBeatmap>);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs
new file mode 100644
index 0000000000..e410d66ce8
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs
@@ -0,0 +1,66 @@
+// 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 NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Collections;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    [TestFixture]
+    public partial class TestSceneBeatmapCarouselCollectionGrouping : BeatmapCarouselTestScene
+    {
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            RemoveAllBeatmaps();
+            CreateCarousel();
+
+            AddBeatmaps(10, 3);
+
+            AddStep("set up collections", () =>
+            {
+                List<BeatmapCollection> collections =
+                [
+                    new BeatmapCollection("collection one", [
+                        ..BeatmapSets[0].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[5].Beatmaps[1].MD5Hash,
+                        BeatmapSets[8].Beatmaps[0].MD5Hash,
+                    ]),
+                    new BeatmapCollection("collection two", [
+                        BeatmapSets[0].Beatmaps[0].MD5Hash,
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[6].Beatmaps[2].MD5Hash,
+                        BeatmapSets[8].Beatmaps[2].MD5Hash,
+                    ]),
+                    new BeatmapCollection("collection one copy", [
+                        ..BeatmapSets[0].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[5].Beatmaps[1].MD5Hash,
+                        BeatmapSets[8].Beatmaps[0].MD5Hash,
+                    ]),
+                ];
+                Carousel.AllCollections = () => collections;
+            });
+
+            SortAndGroupBy(SortMode.Title, GroupMode.Collections);
+            WaitForDrawablePanels();
+        }
+
+        [Test]
+        public void TestMultipleCopiesOfBeatmapsPresent()
+        {
+            CheckDisplayedGroupsCount(4); // one for each collection, plus no collections
+            // all three collections have beatmaps from 5 beatmap sets
+            // 7 beatmap sets have beatmaps which belong to no collection
+            CheckDisplayedBeatmapSetsCount(5 + 5 + 5 + 7);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
index 2ab0eda172..58ecfcbf3b 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -71,7 +70,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -82,9 +81,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
 
@@ -121,7 +120,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForBeatmapSelection(0, 0);
             // Expanding a group will move keyboard selection to the selected beatmap if contained.
             AddAssert("keyboard selected panel is expanded", () => groupPanel?.Expanded.Value, () => Is.True);
-            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<BeatmapInfo>);
+            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<GroupedBeatmap>);
         }
 
         [Test]
@@ -199,7 +198,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         private void checkBeatmapIsKeyboardSelected() =>
-            AddUntilStep("check keyboard selected group is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddUntilStep("check keyboard selected group is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
         private void checkGroupKeyboardSelected(int index) => AddUntilStep($"check keyboard selected group is {index}", () => GetKeyboardSelectedPanel()?.Item?.Model, () =>
         {
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
index 78c12e2730..b1bd9fd3ed 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
@@ -130,14 +130,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextPanel();
             Select();
 
-            AddStep("record selection", () => selectedID = ((BeatmapInfo)Carousel.CurrentSelection!).ID);
+            AddStep("record selection", () => selectedID = Carousel.CurrentBeatmap!.ID);
 
             for (int i = 0; i < 5; i++)
             {
                 ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
                 ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
             }
         }
 
@@ -177,14 +177,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SelectNextSet();
 
-            AddStep("record selection", () => selectedID = ((BeatmapInfo)Carousel.CurrentSelection!).ID);
+            AddStep("record selection", () => selectedID = Carousel.CurrentBeatmap!.ID);
 
             for (int i = 0; i < 5; i++)
             {
                 ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
                 ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
             }
         }
 
@@ -200,14 +200,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             {
                 int diff = i;
 
-                AddStep($"select diff {diff}", () => Carousel.CurrentSelection = chosenBeatmap = BeatmapSets[20].Beatmaps[diff]);
-                AddUntilStep("selection changed", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddStep($"select diff {diff}", () => Carousel.CurrentBeatmap = chosenBeatmap = BeatmapSets[20].Beatmaps[diff]);
+                AddUntilStep("selection changed", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
 
                 SortBy(SortMode.Difficulty);
-                AddAssert("selection retained", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddAssert("selection retained", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
 
                 SortBy(SortMode.Title);
-                AddAssert("selection retained", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddAssert("selection retained", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
             }
         }
 
@@ -239,7 +239,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1;
             });
 
             ApplyToFilterAndWaitForFilter("filter to taiko", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(1));
@@ -249,8 +249,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 2
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 1) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 1) == 1;
             });
 
             ApplyToFilterAndWaitForFilter("filter to catch", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(2));
@@ -260,8 +260,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 2
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 2) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 2) == 1;
             });
         }
 
@@ -396,7 +396,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectNextPanel();
-            AddAssert("keyboard selected is first set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.First()));
+            AddAssert("keyboard selected is first set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.First()));
         }
 
         [Test]
@@ -413,7 +415,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectPrevPanel();
-            AddAssert("keyboard selected is last set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.Last()));
+            AddAssert("keyboard selected is last set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.Last()));
         }
 
         [Test]
@@ -428,7 +432,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter last set away", c => c.SearchText = BeatmapSets.First().Metadata.Title);
 
             SelectPrevPanel();
-            AddAssert("keyboard selected is first set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.First()));
+            AddAssert("keyboard selected is first set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.First()));
         }
 
         [Test]
@@ -444,7 +450,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             // Single result is automatically selected for us, so we iterate once backwards to the set header.
             SelectPrevPanel();
-            AddAssert("keyboard selected is second set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.Last()));
+            AddAssert("keyboard selected is second set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.Last()));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
index 648f531a6e..c839a28055 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
 using osuTK;
@@ -90,7 +89,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -101,9 +100,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
         }
@@ -390,15 +389,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private void checkSelectionIterating(bool isIterating)
         {
-            object? selection = null;
+            GroupedBeatmap? selection = null;
 
             for (int i = 0; i < 3; i++)
             {
-                AddStep("store selection", () => selection = Carousel.CurrentSelection);
+                AddStep("store selection", () => selection = Carousel.CurrentGroupedBeatmap);
                 if (isIterating)
-                    AddUntilStep("selection changed", () => Carousel.CurrentSelection != selection);
+                    AddUntilStep("selection changed", () => Carousel.CurrentGroupedBeatmap != selection);
                 else
-                    AddUntilStep("selection not changed", () => Carousel.CurrentSelection == selection);
+                    AddUntilStep("selection not changed", () => Carousel.CurrentGroupedBeatmap == selection);
             }
         }
     }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
index ed694c9e3d..ce68d587c8 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
@@ -50,12 +50,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             nextRandom();
             ensureRandomDidNotRepeat();
 
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentBeatmap!);
 
             SortAndGroupBy(SortMode.Artist, GroupMode.Difficulty);
             WaitForFiltering();
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+            AddAssert("selection not changed", () => Carousel.CurrentBeatmap, () => Is.EqualTo(originalSelected));
 
             storeExpandedGroup();
 
@@ -247,18 +247,42 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             }
         }
 
+        [Test]
+        public void TestRewindOverGroupingModeChange()
+        {
+            const int local_set_count = 3;
+
+            SortAndGroupBy(SortMode.Artist, GroupMode.Artist);
+            AddBeatmaps(local_set_count, 3);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+
+            for (int i = 0; i < local_set_count; i++)
+                nextRandom();
+
+            SortAndGroupBy(SortMode.Title, GroupMode.LastPlayed);
+            WaitForDrawablePanels();
+
+            for (int i = 0; i < local_set_count; i++)
+            {
+                prevRandomSet();
+                checkRewindCorrectSet();
+            }
+        }
+
         [Test]
         public void TestRandomThenRewindSameFrame()
         {
             AddBeatmaps(10, 3, true);
             WaitForDrawablePanels();
 
-            BeatmapInfo? originalSelected = null;
+            GroupedBeatmap? originalSelected = null;
 
             nextRandom();
 
             CheckHasSelection();
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentGroupedBeatmap!);
 
             AddStep("random then rewind", () =>
             {
@@ -266,7 +290,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 Carousel.PreviousRandom();
             });
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(originalSelected));
         }
 
         [Test]
@@ -275,26 +299,26 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(10, 3, true);
             WaitForDrawablePanels();
 
-            BeatmapInfo? originalSelected = null;
-            BeatmapInfo? postRandomSelection = null;
+            GroupedBeatmap? originalSelected = null;
+            GroupedBeatmap? postRandomSelection = null;
 
             nextRandom();
 
             CheckHasSelection();
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentGroupedBeatmap!);
 
             nextRandom();
-            AddStep("store selection", () => postRandomSelection = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => postRandomSelection = Carousel.CurrentGroupedBeatmap!);
 
             AddAssert("selection changed", () => originalSelected, () => Is.Not.SameAs(postRandomSelection));
 
-            AddStep("delete previous selection beatmaps", () => BeatmapSets.Remove(originalSelected!.BeatmapSet!));
+            AddStep("delete previous selection beatmaps", () => BeatmapSets.Remove(originalSelected!.Beatmap.BeatmapSet!));
             WaitForFiltering();
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(postRandomSelection));
 
             prevRandomSet();
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(postRandomSelection));
         }
 
         private void nextRandom() =>
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
index 29aa976fe3..c1cee4e398 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select middle beatmap", () => Carousel.CurrentSelection = BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First());
+            AddStep("select middle beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First()));
 
             WaitForScrolling();
 
@@ -45,7 +45,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select middle beatmap", () => Carousel.CurrentSelection = BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First());
+            AddStep("select middle beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First()));
             WaitForScrolling();
 
             AddStep("override scroll with user scroll", () =>
@@ -71,7 +71,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("scroll to end", () => Scroll.ScrollToEnd(false));
 
-            AddStep("select last beatmap", () => Carousel.CurrentSelection = BeatmapSets.Last().Beatmaps.Last());
+            AddStep("select last beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.Last().Beatmaps.Last()));
 
             WaitForScrolling();
 
@@ -88,7 +88,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select first beatmap", () => Carousel.CurrentSelection = BeatmapSets.First().Beatmaps.First());
+            AddStep("select first beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.First().Beatmaps.First()));
 
             WaitForScrolling();
 
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select first beatmap", () => Carousel.CurrentSelection = BeatmapSets.First().Beatmaps.First());
+            AddStep("select first beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.First().Beatmaps.First()));
             WaitForScrolling();
 
             AddStep("override scroll with user scroll", () =>
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.cs
new file mode 100644
index 0000000000..fa635f9bde
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.cs
@@ -0,0 +1,120 @@
+// 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 NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    [TestFixture]
+    public partial class TestSceneBeatmapCarouselSetsSplitApart : BeatmapCarouselTestScene
+    {
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            RemoveAllBeatmaps();
+            CreateCarousel();
+
+            SortAndGroupBy(SortMode.Title, GroupMode.Length);
+        }
+
+        [Test]
+        public void TestSetTraversal()
+        {
+            AddBeatmaps(3, splitApart: true);
+            AddBeatmaps(3, splitApart: false);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectNextSet();
+            WaitForSetSelection(set: 1, diff: 0);
+
+            SelectPrevSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectPrevSet();
+            WaitForSetSelection(set: 5, diff: 0);
+
+            SelectPrevSet();
+            SelectPrevSet();
+            SelectPrevSet();
+            WaitForSetSelection(set: 2, diff: 4);
+            AddAssert("only two beatmap panels visible", () => GetVisiblePanels<PanelBeatmap>().Count(), () => Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestBeatmapTraversal()
+        {
+            AddBeatmaps(3, splitApart: true);
+            AddBeatmaps(3, splitApart: false);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectNextPanel();
+            WaitForSetSelection(set: 0, diff: 1);
+
+            SelectNextPanel(); // header of set 1 in group 0
+            Select();
+            WaitForSetSelection(set: 1, diff: 0);
+
+            SelectPrevPanel(); // header of set 1 in group 0
+            SelectPrevPanel(); // header of set 0 in group 0
+            Select();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectPrevPanel(); // header of set 0 in group 0
+            SelectPrevPanel(); // header of group 0
+            SelectPrevPanel(); // header of group 2
+            Select();
+            SelectNextPanel(); // header of set 0 in group 2
+            Select();
+            WaitForSetSelection(set: 0, diff: 4);
+        }
+
+        [Test]
+        public void TestRandomStaysInGroup()
+        {
+            AddBeatmaps(2, splitApart: false);
+            AddBeatmaps(1, splitApart: true);
+            WaitForDrawablePanels();
+
+            SelectPrevSet();
+            SelectPrevSet();
+            WaitForSetSelection(set: 1);
+            WaitForExpandedGroup(2);
+
+            AddStep("select next random", () => Carousel.NextRandom());
+            WaitForExpandedGroup(2);
+            AddStep("select next random", () => Carousel.NextRandom());
+            WaitForExpandedGroup(2);
+        }
+
+        protected void AddBeatmaps(int count, bool splitApart) => AddStep($"add {count} beatmaps ({(splitApart ? "" : "not ")}split apart)", () =>
+        {
+            var beatmapSets = new List<BeatmapSetInfo>();
+
+            for (int i = 0; i < count; i++)
+            {
+                var beatmapSet = CreateTestBeatmapSetInfo(6, false);
+
+                for (int j = 0; j < beatmapSet.Beatmaps.Count; j++)
+                {
+                    beatmapSet.Beatmaps[j].Length = splitApart ? 30_000 * (j + 1) : 180_000;
+                }
+
+                beatmapSets.Add(beatmapSet);
+            }
+
+            BeatmapSets.AddRange(beatmapSets);
+        });
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
index fdc9cc93a5..86ef2cffba 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
@@ -6,8 +6,11 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Extensions;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -20,12 +23,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
     {
         private BeatmapSetInfo baseTestBeatmap = null!;
 
+        private const int initial_filter_count = 3;
+
         [SetUpSteps]
         public void SetUpSteps()
         {
             RemoveAllBeatmaps();
             CreateCarousel();
-            AddBeatmaps(1, 3);
+            WaitForFiltering();
+            AddStep("add beatmap", () =>
+            {
+                var beatmap = CreateTestBeatmapSetInfo(3, false);
+                Realm.Write(r => r.Add(beatmap, update: true));
+                BeatmapSets.Add(beatmap.Detach());
+            });
+            WaitForFiltering();
             AddStep("generate and add test beatmap", () =>
             {
                 baseTestBeatmap = TestResources.CreateTestBeatmapSetInfo(3);
@@ -38,10 +50,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 foreach (var b in baseTestBeatmap.Beatmaps)
                     b.Metadata = metadata;
-                BeatmapSets.Add(baseTestBeatmap);
-            });
 
+                Realm.Write(r => r.Add(baseTestBeatmap, update: true));
+                BeatmapSets.Add(baseTestBeatmap.Detach());
+            });
             WaitForFiltering();
+
+            AddAssert("filter count correct", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count));
         }
 
         [Test]
@@ -61,6 +76,41 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
         }
 
+        [Test]
+        public void TestScrollPositionMaintainedWhenSetUpdated()
+        {
+            PanelBeatmapSet panel = null!;
+
+            AddStep("find panel", () => panel = Carousel.ChildrenOfType<PanelBeatmapSet>().Single(p => p.ChildrenOfType<OsuSpriteText>().Any(t => t.Text.ToString() == "beatmap")));
+
+            AddStep("select panel", () => panel.TriggerClick());
+
+            AddStep("scroll to end", () =>
+            {
+                // must trigger a user scroll so that carousel doesn't follow the selection.
+                InputManager.MoveMouseTo(Carousel);
+                InputManager.ScrollVerticalBy(-1000);
+            });
+
+            AddUntilStep("is scrolled to end", () => Carousel.ChildrenOfType<UserTrackingScrollContainer>().Single().IsScrolledToEnd());
+
+            updateBeatmap(b =>
+            {
+                // hash will be updated when important metadata changes, such as title, difficulty, author etc.
+                b.Hash = "new hash";
+                b.Metadata = new BeatmapMetadata
+                {
+                    Artist = "updated test",
+                    Title = $"beatmap {RNG.Next().ToString()}"
+                };
+            });
+
+            assertDidFilter();
+            WaitForFiltering();
+
+            AddAssert("scroll is still at end", () => Carousel.ChildrenOfType<UserTrackingScrollContainer>().Single().IsScrolledToEnd());
+        }
+
         [Test]
         public void TestBeatmapSetMetadataUpdated()
         {
@@ -82,8 +132,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("find panel", () => panel = Carousel.ChildrenOfType<PanelBeatmapSet>().Single(p => p.ChildrenOfType<OsuSpriteText>().Any(t => t.Text.ToString() == "beatmap")));
 
-            updateBeatmap(b => b.Metadata = metadata);
+            updateBeatmap(b =>
+            {
+                b.Metadata = metadata;
+                // hash will be updated when important metadata changes, such as title, difficulty, author etc.
+                b.Hash = "new hash";
+            });
 
+            assertDidFilter();
             WaitForFiltering();
 
             AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
@@ -92,19 +148,63 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         [Test]
-        public void TestSelectionHeld()
+        public void TestOnlineStatusUpdated()
+        {
+            List<Panel> originalDrawables = new List<Panel>();
+
+            AddStep("store drawable references", () =>
+            {
+                originalDrawables.Clear();
+                originalDrawables.AddRange(Carousel.ChildrenOfType<Panel>().ToList());
+            });
+
+            updateBeatmap(b => b.Status = BeatmapOnlineStatus.Graveyard);
+
+            assertDidFilter();
+            WaitForFiltering();
+
+            AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
+        }
+
+        [Test]
+        public void TestNoUpdateTriggeredOnUserTagsChange()
+        {
+            var metadata = new BeatmapMetadata
+            {
+                Artist = "updated test",
+                Title = "new beatmap title",
+                UserTags = { "hi" }
+            };
+
+            updateBeatmap(b => b.Metadata = metadata);
+            assertDidNotFilter();
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSelectionHeld(bool hashChanged)
         {
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+
+            updateBeatmap(b =>
+            {
+                if (hashChanged)
+                    b.Hash = "new hash";
+            });
+
+            if (hashChanged)
+                assertDidFilter();
+            else
+                assertDidNotFilter();
 
-            updateBeatmap();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we keep selection based on online ID where possible.
@@ -113,14 +213,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             updateBeatmap(b => b.DifficultyName = "new name");
+            assertDidFilter();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we fallback to keeping selection based on difficulty name.
@@ -129,14 +230,73 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             updateBeatmap(b => b.OnlineID = b.OnlineID + 1);
+            assertDidFilter();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+        }
+
+        [Test] // Checks that we don't crash if there exists a difficulty with the same online ID as the selected difficulty.
+        public void TestDifferentDifficultiesWithSameOnlineID()
+        {
+            SelectNextSet();
+
+            WaitForSetSelection(1, 0);
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+
+            // Add another difficulty with same online ID.
+            updateBeatmap(null, bs =>
+            {
+                var newBeatmap = createBeatmap(bs);
+                newBeatmap.OnlineID = baseTestBeatmap.Beatmaps[0].OnlineID;
+                bs.Beatmaps.Add(newBeatmap);
+            });
+
+            WaitForFiltering();
+
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+        }
+
+        [Test] // Checks that we don't crash if there exists a difficulty with the same name as the selected difficulty.
+        public void TestDifferentDifficultiesWithSameName()
+        {
+            SelectNextSet();
+
+            WaitForSetSelection(1, 0);
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+
+            // Remove original selected difficulty, and add two difficulties with same name as selection.
+            updateBeatmap(null, bs =>
+            {
+                string selectedName = bs.Beatmaps[0].DifficultyName;
+                Realm.Write(r => r.Remove(r.Find<BeatmapInfo>(bs.Beatmaps[0].ID)!));
+                bs.Beatmaps.RemoveAt(0);
+
+                var newBeatmap = createBeatmap(bs);
+                newBeatmap.ID = Guid.NewGuid();
+                newBeatmap.DifficultyName = selectedName;
+                newBeatmap.OnlineID = -1;
+                bs.Beatmaps.Add(newBeatmap);
+
+                newBeatmap = createBeatmap(bs);
+                newBeatmap.ID = Guid.NewGuid();
+                newBeatmap.DifficultyName = selectedName;
+                newBeatmap.OnlineID = -1;
+                bs.Beatmaps.Add(newBeatmap);
+            });
+
+            WaitForFiltering();
+
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(BeatmapSets[1].Beatmaps[2]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(BeatmapSets[1].Beatmaps[2]));
         }
 
         /// <summary>
@@ -253,6 +413,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
         }
 
+        private void assertDidFilter() => AddAssert("did filter", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count + 1));
+
+        private void assertDidNotFilter() => AddAssert("did not filter", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count));
+
         private void updateBeatmap(Action<BeatmapInfo>? updateBeatmap = null, Action<BeatmapSetInfo>? updateSet = null)
         {
             AddStep("update beatmap with different reference", () =>
@@ -271,26 +435,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     Protected = baseTestBeatmap.Protected,
                 };
 
-                updateSet?.Invoke(updatedSet);
-
                 var updatedBeatmaps = baseTestBeatmap.Beatmaps.Select(b =>
                 {
-                    var updatedBeatmap = new BeatmapInfo
-                    {
-                        ID = b.ID,
-                        Metadata = b.Metadata,
-                        Ruleset = b.Ruleset,
-                        DifficultyName = b.DifficultyName,
-                        BeatmapSet = updatedSet,
-                        Status = b.Status,
-                        OnlineID = b.OnlineID,
-                        Length = b.Length,
-                        BPM = b.BPM,
-                        Hash = b.Hash,
-                        StarRating = b.StarRating,
-                        MD5Hash = b.MD5Hash,
-                        OnlineMD5Hash = b.OnlineMD5Hash,
-                    };
+                    var updatedBeatmap = createBeatmap(updatedSet, b);
 
                     updateBeatmap?.Invoke(updatedBeatmap);
 
@@ -299,10 +446,37 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 updatedSet.Beatmaps.AddRange(updatedBeatmaps);
 
+                updateSet?.Invoke(updatedSet);
+
                 int originalIndex = BeatmapSets.IndexOf(baseTestBeatmap);
 
-                BeatmapSets.ReplaceRange(originalIndex, 1, [updatedSet]);
+                Realm.Write(r => r.Add(updatedSet, update: true));
+                BeatmapSets.ReplaceRange(originalIndex, 1, [updatedSet.Detach()]);
             });
         }
+
+        private BeatmapInfo createBeatmap(BeatmapSetInfo set, BeatmapInfo? reference = null)
+        {
+            reference ??= baseTestBeatmap.Beatmaps.First();
+
+            var updatedBeatmap = new BeatmapInfo
+            {
+                ID = reference.ID,
+                Metadata = reference.Metadata,
+                Ruleset = reference.Ruleset,
+                DifficultyName = reference.DifficultyName,
+                BeatmapSet = set,
+                Status = reference.Status,
+                OnlineID = reference.OnlineID,
+                Length = reference.Length,
+                BPM = reference.BPM,
+                Hash = reference.Hash,
+                StarRating = reference.StarRating,
+                MD5Hash = reference.MD5Hash,
+                OnlineMD5Hash = reference.OnlineMD5Hash,
+            };
+
+            return updatedBeatmap;
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardSorting.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardSorting.cs
new file mode 100644
index 0000000000..6e3fafdd6a
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardSorting.cs
@@ -0,0 +1,155 @@
+// 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.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Resources;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    public partial class TestSceneBeatmapLeaderboardSorting : SongSelectComponentsTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        private BeatmapDetailsArea beatmapDetailsArea = null!;
+        private ScoreManager scoreManager = null!;
+        private RulesetStore rulesetStore = null!;
+        private BeatmapManager beatmapManager = null!;
+        private OsuContextMenuContainer contentContainer = null!;
+        private DialogOverlay dialogOverlay = null!;
+
+        private LeaderboardManager leaderboardManager = null!;
+
+        private readonly IBindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?> onlineLookupResult = new Bindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?>();
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+            dependencies.Cache(rulesetStore = new RealmRulesetStore(Realm));
+            dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, dependencies.Get<AudioManager>(), Resources, dependencies.Get<GameHost>(), Beatmap.Default));
+            dependencies.Cache(scoreManager = new ScoreManager(rulesetStore, () => beatmapManager, LocalStorage, Realm, API));
+            dependencies.Cache(leaderboardManager = new LeaderboardManager());
+            dependencies.CacheAs(onlineLookupResult);
+
+            Dependencies.Cache(Realm);
+
+            return dependencies;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LoadComponent(dialogOverlay = new DialogOverlay
+            {
+                Depth = -1
+            });
+
+            LoadComponent(leaderboardManager);
+
+            Child = contentContainer = new OsuContextMenuContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = 500,
+                Shear = OsuGame.SHEAR,
+                Children = new Drawable[]
+                {
+                    dialogOverlay,
+                }
+            };
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            if (beatmapDetailsArea.IsNotNull())
+                contentContainer.Remove(beatmapDetailsArea, false);
+
+            contentContainer.Add(beatmapDetailsArea = new BeatmapDetailsArea
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding { Left = 50 },
+                State = { Value = Visibility.Visible },
+            });
+        });
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+        }
+
+        [Test]
+        public void TestLocalScoresSorting()
+        {
+            BeatmapInfo beatmapInfo = null!;
+
+            AddStep(@"Set beatmap", () =>
+            {
+                beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
+
+                Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapInfo);
+            });
+
+            AddStep(@"Import random scores", () =>
+            {
+                for (int i = 0; i < 10; ++i)
+                    importRandomScore(beatmapInfo);
+            });
+
+            AddStep("Clear all scores", () => scoreManager.Delete());
+        }
+
+        private void importRandomScore(BeatmapInfo beatmapInfo)
+        {
+            scoreManager.Import(new ScoreInfo
+            {
+                Rank = ScoreRank.XH,
+                Accuracy = RNG.NextDouble(0, 1),
+                MaxCombo = RNG.Next(0, 1500),
+                TotalScore = RNG.Next(500000, 1200000),
+                Date = DateTime.Now.AddMinutes(RNG.Next(0, 1000) * -1),
+                Statistics = new Dictionary<HitResult, int>
+                {
+                    { HitResult.Miss, RNG.Next(0, 25) },
+                },
+                Ruleset = new OsuRuleset().RulesetInfo,
+                BeatmapInfo = beatmapInfo,
+                BeatmapHash = beatmapInfo.Hash,
+                User = new APIUser
+                {
+                    Id = 2,
+                    Username = @"peppy",
+                    CountryCode = CountryCode.JP,
+                },
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapMetadataWedge.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapMetadataWedge.cs
index f18250402e..d4fab55c62 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapMetadataWedge.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapMetadataWedge.cs
@@ -4,12 +4,12 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Models;
-using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.SelectV2;
 
@@ -17,10 +17,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 {
     public partial class TestSceneBeatmapMetadataWedge : SongSelectComponentsTestScene
     {
-        private APIBeatmapSet? currentOnlineSet;
-
         private BeatmapMetadataWedge wedge = null!;
 
+        [Cached(typeof(IBindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?>))]
+        private Bindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?> onlineLookupResult = new Bindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?>();
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -31,40 +32,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             };
         }
 
-        [SetUpSteps]
-        public override void SetUpSteps()
-        {
-            AddStep("register request handling", () =>
-            {
-                ((DummyAPIAccess)API).HandleRequest = request =>
-                {
-                    switch (request)
-                    {
-                        case GetBeatmapSetRequest set:
-                            if (set.ID == currentOnlineSet?.OnlineID)
-                            {
-                                set.TriggerSuccess(currentOnlineSet);
-                                return true;
-                            }
-
-                            return false;
-
-                        default:
-                            return false;
-                    }
-                };
-            });
-        }
-
         [Test]
         public void TestShowHide()
         {
-            AddStep("all metrics", () =>
-            {
-                var (working, onlineSet) = createTestBeatmap();
-                currentOnlineSet = onlineSet;
-                Beatmap.Value = working;
-            });
+            AddStep("all metrics", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
 
             AddStep("hide wedge", () => wedge.Hide());
             AddStep("show wedge", () => wedge.Show());
@@ -73,67 +44,63 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestVariousMetrics()
         {
-            AddStep("all metrics", () =>
-            {
-                var (working, onlineSet) = createTestBeatmap();
-                currentOnlineSet = onlineSet;
-                Beatmap.Value = working;
-            });
+            AddStep("all metrics", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
+
             AddStep("null beatmap", () => Beatmap.SetDefault());
             AddStep("no source", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
                 working.Metadata.Source = string.Empty;
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
             AddStep("no success rate", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Beatmaps.Single().PlayCount = 0;
-                onlineSet.Beatmaps.Single().PassCount = 0;
+                online.Result!.Beatmaps.Single().PlayCount = 0;
+                online.Result!.Beatmaps.Single().PassCount = 0;
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
             AddStep("no user ratings", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Ratings = Array.Empty<int>();
+                online.Result!.Ratings = Array.Empty<int>();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
             AddStep("no fail times", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Beatmaps.Single().FailTimes = null;
+                online.Result!.Beatmaps.Single().FailTimes = null;
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
             AddStep("no metrics", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Ratings = Array.Empty<int>();
-                onlineSet.Beatmaps.Single().FailTimes = null;
+                online.Result!.Ratings = Array.Empty<int>();
+                online.Result!.Beatmaps.Single().FailTimes = null;
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
             AddStep("local beatmap", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, _) = createTestBeatmap();
 
                 working.BeatmapInfo.OnlineID = 0;
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = null;
                 Beatmap.Value = working;
             });
         }
@@ -143,16 +110,16 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddStep("long text", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
                 working.BeatmapInfo.Metadata.Author = new RealmUser { Username = "Verrrrryyyy llooonngggggg author" };
                 working.BeatmapInfo.Metadata.Source = "Verrrrryyyy llooonngggggg source";
                 working.BeatmapInfo.Metadata.Tags = string.Join(' ', Enumerable.Repeat(working.BeatmapInfo.Metadata.Tags, 3));
-                onlineSet.Genre = new BeatmapSetOnlineGenre { Id = 12, Name = "Verrrrryyyy llooonngggggg genre" };
-                onlineSet.Language = new BeatmapSetOnlineLanguage { Id = 12, Name = "Verrrrryyyy llooonngggggg language" };
-                onlineSet.Beatmaps.Single().TopTags = Enumerable.Repeat(onlineSet.Beatmaps.Single().TopTags, 3).SelectMany(t => t!).ToArray();
+                online.Result!.Genre = new BeatmapSetOnlineGenre { Id = 12, Name = "Verrrrryyyy llooonngggggg genre" };
+                online.Result!.Language = new BeatmapSetOnlineLanguage { Id = 12, Name = "Verrrrryyyy llooonngggggg language" };
+                online.Result!.Beatmaps.Single().TopTags = Enumerable.Repeat(online.Result!.Beatmaps.Single().TopTags, 3).SelectMany(t => t!).ToArray();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
         }
@@ -160,22 +127,17 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestOnlineAvailability()
         {
-            AddStep("online beatmapset", () =>
-            {
-                var (working, onlineSet) = createTestBeatmap();
+            AddStep("online beatmapset", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
 
-                currentOnlineSet = onlineSet;
-                Beatmap.Value = working;
-            });
             AddUntilStep("rating wedge visible", () => wedge.RatingsVisible);
             AddUntilStep("fail time wedge visible", () => wedge.FailRetryVisible);
             AddStep("online beatmapset with local diff", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, lookupResult) = createTestBeatmap();
 
                 working.BeatmapInfo.ResetOnlineInfo();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = lookupResult;
                 Beatmap.Value = working;
             });
             AddUntilStep("rating wedge hidden", () => !wedge.RatingsVisible);
@@ -184,7 +146,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             {
                 var (working, _) = createTestBeatmap();
 
-                currentOnlineSet = null;
+                onlineLookupResult.Value = null;
                 Beatmap.Value = working;
             });
             AddAssert("rating wedge still hidden", () => !wedge.RatingsVisible);
@@ -194,21 +156,17 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestUserTags()
         {
-            AddStep("user tags", () =>
-            {
-                var (working, onlineSet) = createTestBeatmap();
+            AddStep("user tags", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
 
-                currentOnlineSet = onlineSet;
-                Beatmap.Value = working;
-            });
             AddStep("no user tags", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Beatmaps.Single().TopTags = null;
-                onlineSet.RelatedTags = null;
+                online.Result!.Beatmaps.Single().TopTags = null;
+                online.Result!.RelatedTags = null;
+                working.BeatmapSetInfo.Beatmaps.Single().Metadata.UserTags.Clear();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = online;
                 Beatmap.Value = working;
             });
         }
@@ -216,72 +174,60 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestLoading()
         {
-            AddStep("override request handling", () =>
-            {
-                currentOnlineSet = null;
-
-                ((DummyAPIAccess)API).HandleRequest = request =>
-                {
-                    switch (request)
-                    {
-                        case GetBeatmapSetRequest set:
-                            Scheduler.AddDelayed(() => set.TriggerSuccess(currentOnlineSet!), 500);
-                            return true;
-
-                        default:
-                            return false;
-                    }
-                };
-            });
-
             AddStep("set beatmap", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = Screens.SelectV2.SongSelect.BeatmapSetLookupResult.InProgress();
+                Scheduler.AddDelayed(() => onlineLookupResult.Value = online, 500);
                 Beatmap.Value = working;
             });
             AddWaitStep("wait", 5);
 
             AddStep("set beatmap", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.RelatedTags![0].Name = "other/tag";
-                onlineSet.RelatedTags[1].Name = "another/tag";
-                onlineSet.RelatedTags[2].Name = "some/tag";
+                online.Result!.RelatedTags![0].Name = "other/tag";
+                online.Result!.RelatedTags[1].Name = "another/tag";
+                online.Result!.RelatedTags[2].Name = "some/tag";
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = Screens.SelectV2.SongSelect.BeatmapSetLookupResult.InProgress();
+                Scheduler.AddDelayed(() => onlineLookupResult.Value = online, 500);
                 Beatmap.Value = working;
             });
             AddWaitStep("wait", 5);
 
             AddStep("no user tags", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Beatmaps.Single().TopTags = null;
-                onlineSet.RelatedTags = null;
+                online.Result!.Beatmaps.Single().TopTags = null;
+                online.Result!.RelatedTags = null;
+                working.BeatmapSetInfo.Beatmaps.Single().Metadata.UserTags.Clear();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = Screens.SelectV2.SongSelect.BeatmapSetLookupResult.InProgress();
+                Scheduler.AddDelayed(() => onlineLookupResult.Value = online, 500);
                 Beatmap.Value = working;
             });
             AddWaitStep("wait", 5);
 
             AddStep("no user tags", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, online) = createTestBeatmap();
 
-                onlineSet.Beatmaps.Single().TopTags = null;
-                onlineSet.RelatedTags = null;
+                online.Result!.Beatmaps.Single().TopTags = null;
+                online.Result!.RelatedTags = null;
+                working.BeatmapSetInfo.Beatmaps.Single().Metadata.UserTags.Clear();
 
-                currentOnlineSet = onlineSet;
+                onlineLookupResult.Value = Screens.SelectV2.SongSelect.BeatmapSetLookupResult.InProgress();
+                Scheduler.AddDelayed(() => onlineLookupResult.Value = online, 500);
                 Beatmap.Value = working;
             });
             AddWaitStep("wait", 5);
         }
 
-        private (WorkingBeatmap, APIBeatmapSet) createTestBeatmap()
+        private (WorkingBeatmap, Screens.SelectV2.SongSelect.BeatmapSetLookupResult) createTestBeatmap()
         {
             var working = CreateWorkingBeatmap(Ruleset.Value);
             var onlineSet = new APIBeatmapSet
@@ -335,7 +281,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             working.BeatmapSetInfo.DateSubmitted = DateTimeOffset.Now;
             working.BeatmapSetInfo.DateRanked = DateTimeOffset.Now;
-            return (working, onlineSet);
+            working.Metadata.UserTags.AddRange(onlineSet.RelatedTags.Select(t => t.Name));
+            return (working, Screens.SelectV2.SongSelect.BeatmapSetLookupResult.Completed(onlineSet));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapTitleWedge.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapTitleWedge.cs
index 85d82e536d..cbcf16ec51 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapTitleWedge.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapTitleWedge.cs
@@ -5,10 +5,13 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
@@ -16,6 +19,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Drawables;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
@@ -38,7 +42,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         private BeatmapTitleWedge titleWedge = null!;
         private BeatmapTitleWedge.DifficultyDisplay difficultyDisplay => titleWedge.ChildrenOfType<BeatmapTitleWedge.DifficultyDisplay>().Single();
 
-        private APIBeatmapSet? currentOnlineSet;
+        [Cached(typeof(IBindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?>))]
+        private Bindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?> onlineLookupResult = new Bindable<Screens.SelectV2.SongSelect.BeatmapSetLookupResult?>();
 
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
@@ -50,24 +55,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             base.LoadComplete();
 
-            ((DummyAPIAccess)API).HandleRequest = request =>
-            {
-                switch (request)
-                {
-                    case GetBeatmapSetRequest set:
-                        if (set.ID == currentOnlineSet?.OnlineID)
-                        {
-                            set.TriggerSuccess(currentOnlineSet);
-                            return true;
-                        }
-
-                        return false;
-
-                    default:
-                        return false;
-                }
-            };
-
             AddRange(new Drawable[]
             {
                 new Container
@@ -112,7 +99,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             selectBeatmap(null);
             AddAssert("check default title", () => titleWedge.DisplayedTitle == Beatmap.Default.BeatmapInfo.Metadata.Title);
             AddAssert("check default artist", () => titleWedge.DisplayedArtist == Beatmap.Default.BeatmapInfo.Metadata.Artist);
-            AddAssert("check no statistics", () => difficultyDisplay.ChildrenOfType<BeatmapTitleWedge.DifficultyStatisticsDisplay>().All(d => !d.Statistics.Any()));
+            AddAssert("statistics not visible",
+                () => difficultyDisplay.ChildrenOfType<BeatmapTitleWedge.DifficultyStatisticsDisplay>()
+                                       .All(d => d.Alpha == 0 || d.ChildrenOfType<BeatmapTitleWedge.StatisticDifficulty>().All(s => s.Alpha == 0)));
         }
 
         [Test]
@@ -151,35 +140,112 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestOnlineAvailability()
         {
-            AddStep("online beatmapset", () =>
-            {
-                var (working, onlineSet) = createTestBeatmap();
+            AddStep("online beatmapset", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
 
-                currentOnlineSet = onlineSet;
-                Beatmap.Value = working;
-            });
-            AddAssert("play count = 10000", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString() == "10,000");
-            AddAssert("favourites count = 2345", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(1).Text.ToString() == "2,345");
+            AddUntilStep("play count is 10000", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString(), () => Is.EqualTo("10,000"));
+            AddUntilStep("favourites count is 2345", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("2,345"));
             AddStep("online beatmapset with local diff", () =>
             {
-                var (working, onlineSet) = createTestBeatmap();
+                var (working, lookupResult) = createTestBeatmap();
 
                 working.BeatmapInfo.ResetOnlineInfo();
 
-                currentOnlineSet = onlineSet;
                 Beatmap.Value = working;
+                onlineLookupResult.Value = lookupResult;
             });
-            AddAssert("play count = -", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString() == "-");
-            AddAssert("favourites count = 2345", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(1).Text.ToString() == "2,345");
+            AddUntilStep("play count is -", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString(), () => Is.EqualTo("-"));
+            AddUntilStep("favourites count is 2345", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("2,345"));
             AddStep("local beatmapset", () =>
             {
                 var (working, _) = createTestBeatmap();
 
-                currentOnlineSet = null;
                 Beatmap.Value = working;
+                onlineLookupResult.Value = Screens.SelectV2.SongSelect.BeatmapSetLookupResult.Completed(null);
             });
-            AddAssert("play count = -", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString() == "-");
-            AddAssert("favourites count = -", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(1).Text.ToString() == "-");
+            AddUntilStep("play count is -", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString(), () => Is.EqualTo("-"));
+            AddUntilStep("favourites count is -", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("-"));
+        }
+
+        [Test]
+        public void TestFavouriting()
+        {
+            var resetEvent = new ManualResetEventSlim(false);
+
+            AddStep("set up request handler", () =>
+            {
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case PostBeatmapFavouriteRequest favourite:
+                            Task.Run(() =>
+                            {
+                                resetEvent.Wait(10000);
+                                favourite.TriggerSuccess();
+                            });
+                            return true;
+
+                        default:
+                            return false;
+                    }
+                };
+            });
+
+            AddStep("online beatmapset", () => (Beatmap.Value, onlineLookupResult.Value) = createTestBeatmap());
+
+            AddUntilStep("play count is 10000", () => this.ChildrenOfType<BeatmapTitleWedge.Statistic>().ElementAt(0).Text.ToString(), () => Is.EqualTo("10,000"));
+            AddUntilStep("favourites count is 2345", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("2,345"));
+
+            AddStep("click favourite button", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().TriggerClick());
+            AddStep("allow request to complete", () => resetEvent.Set());
+            AddUntilStep("favourites count is 2346", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("2,346"));
+
+            AddStep("reset event", () => resetEvent.Reset());
+            AddStep("click favourite button", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().TriggerClick());
+            AddStep("allow request to complete", () => resetEvent.Set());
+            AddUntilStep("favourites count is 2345", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("2,345"));
+
+            AddStep("reset event", () => resetEvent.Reset());
+            AddStep("click favourite button", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().TriggerClick());
+            AddStep("change to another beatmap", () =>
+            {
+                var (working, online) = createTestBeatmap();
+                online.Result!.FavouriteCount = 9999;
+                online.Result!.HasFavourited = true;
+                working.BeatmapSetInfo.OnlineID = online.Result!.OnlineID = 99999;
+
+                Beatmap.Value = working;
+                onlineLookupResult.Value = online;
+            });
+            AddStep("allow request to complete", () => resetEvent.Set());
+            AddUntilStep("favourites count is 9999", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().Text.ToString(), () => Is.EqualTo("9,999"));
+
+            AddStep("set up request handler to fail", () =>
+            {
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case PostBeatmapFavouriteRequest favourite:
+                            Task.Run(() =>
+                            {
+                                resetEvent.Wait(10000);
+                                favourite.TriggerFailure(new APIException("You have too many favourited beatmaps! Please unfavourite some before trying again.", null));
+                            });
+                            return true;
+
+                        default:
+                            return false;
+                    }
+                };
+            });
+            AddStep("reset event", () => resetEvent.Reset());
+            AddStep("click favourite button", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single().TriggerClick());
+            AddAssert("spinner visible", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single()
+                                                   .ChildrenOfType<LoadingSpinner>().Single().State.Value, () => Is.EqualTo(Visibility.Visible));
+            AddStep("allow request to complete", () => resetEvent.Set());
+            AddAssert("spinner hidden", () => this.ChildrenOfType<BeatmapTitleWedge.FavouriteButton>().Single()
+                                                  .ChildrenOfType<LoadingSpinner>().Single().State.Value, () => Is.EqualTo(Visibility.Hidden));
         }
 
         [TestCase(120, 125, null, "120-125 (mostly 120)")]
@@ -233,7 +299,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
         }
 
-        private (WorkingBeatmap, APIBeatmapSet) createTestBeatmap()
+        private (WorkingBeatmap, Screens.SelectV2.SongSelect.BeatmapSetLookupResult) createTestBeatmap()
         {
             var working = CreateWorkingBeatmap(Ruleset.Value);
             var onlineSet = new APIBeatmapSet
@@ -254,7 +320,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             working.BeatmapSetInfo.DateSubmitted = DateTimeOffset.Now;
             working.BeatmapSetInfo.DateRanked = DateTimeOffset.Now;
-            return (working, onlineSet);
+            return (working, Screens.SelectV2.SongSelect.BeatmapSetLookupResult.Completed(onlineSet));
         }
 
         private class TestHitObject : ConvertHitObject;
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
index f3c96861ed..5c4969f9ad 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
@@ -11,11 +11,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Collections;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Tests.Resources;
@@ -65,8 +67,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestEmptyCollectionFilterContainsAllBeatmaps()
         {
-            assertCollectionDropdownContains("All beatmaps");
-            assertCollectionHeaderDisplays("All beatmaps");
+            assertCollectionDropdownContains(CollectionsStrings.AllBeatmaps);
+            assertCollectionHeaderDisplays(CollectionsStrings.AllBeatmaps);
         }
 
         [Test]
@@ -195,8 +197,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestManageCollectionsFilterIsNotSelected()
         {
-            bool received = false;
-
             addExpandHeaderStep();
 
             AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1", new List<string> { "abc" }))));
@@ -210,12 +210,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             addExpandHeaderStep();
 
-            AddStep("watch for filter requests", () =>
-            {
-                received = false;
-                dropdown.ChildrenOfType<CollectionDropdown>().First().RequestFilter = () => received = true;
-            });
-
             AddStep("click manage collections filter", () =>
             {
                 int lastItemIndex = dropdown.ChildrenOfType<CollectionDropdown>().Single().Items.Count() - 1;
@@ -224,8 +218,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
 
             AddAssert("collection filter still selected", () => dropdown.Current.Value.CollectionName == "1");
-
-            AddAssert("filter request not fired", () => !received);
         }
 
         private void writeAndRefresh(Action<Realm> action) => Realm.Write(r =>
@@ -236,13 +228,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private BeatmapCollection getFirstCollection() => Realm.Run(r => r.All<BeatmapCollection>().First());
 
-        private void assertCollectionHeaderDisplays(string collectionName, bool shouldDisplay = true)
+        private void assertCollectionHeaderDisplays(LocalisableString collectionName, bool shouldDisplay = true)
             => AddUntilStep($"collection dropdown header displays '{collectionName}'",
                 () => shouldDisplay == dropdown.ChildrenOfType<CollectionDropdown.ShearedDropdownHeader>().Any(h => h.ChildrenOfType<SpriteText>().Any(t => t.Text == collectionName)));
 
         private void assertFirstButtonIs(IconUsage icon) => AddUntilStep($"button is {icon.Icon.ToString()}", () => getAddOrRemoveButton(1).Icon.Equals(icon));
 
-        private void assertCollectionDropdownContains(string collectionName, bool shouldContain = true) =>
+        private void assertCollectionDropdownContains(LocalisableString collectionName, bool shouldContain = true) =>
             AddUntilStep($"collection dropdown {(shouldContain ? "contains" : "does not contain")} '{collectionName}'",
                 // A bit of a roundabout way of going about this, see: https://github.com/ppy/osu-framework/issues/3871 + https://github.com/ppy/osu-framework/issues/3872
                 () => shouldContain == dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Any(i => i.ChildrenOfType<CompositeDrawable>().OfType<IHasText>().First().Text == collectionName));
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
index 09f8c68951..618b9e0d48 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
@@ -104,21 +104,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap)
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap))
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             Selected = { Value = true }
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true },
                             Selected = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
index e9361b3d7f..67a9f54f1a 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
@@ -104,21 +104,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap)
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap))
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             Selected = { Value = true }
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true },
                             Selected = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
index 1723185b1f..b574262d55 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
@@ -75,21 +75,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet)
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet))
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             Expanded = { Value = true }
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             KeyboardSelected = { Value = true },
                             Expanded = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
index 69bdb97617..553205d400 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
@@ -23,7 +23,9 @@ using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Resources;
 using osuTK.Input;
+using BeatmapCarousel = osu.Game.Screens.SelectV2.BeatmapCarousel;
 using FooterButtonMods = osu.Game.Screens.SelectV2.FooterButtonMods;
 using FooterButtonOptions = osu.Game.Screens.SelectV2.FooterButtonOptions;
 using FooterButtonRandom = osu.Game.Screens.SelectV2.FooterButtonRandom;
@@ -302,6 +304,28 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
         }
 
+        /// <summary>
+        /// Last played and rank achieved may have changed, so we want to make sure filtering runs on resume to song select.
+        /// </summary>
+        [Test]
+        public void TestFilteringRunsAfterReturningFromGameplay()
+        {
+            AddStep("import actual beatmap", () => Beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()));
+            LoadSongSelect();
+
+            AddUntilStep("wait for filtered", () => SongSelect.ChildrenOfType<BeatmapCarousel>().Single().FilterCount, () => Is.EqualTo(1));
+
+            AddStep("enter gameplay", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+            AddUntilStep("wait for fail", () => ((Player)Stack.CurrentScreen).GameplayState.HasFailed);
+
+            AddStep("exit gameplay", () => Stack.CurrentScreen.Exit());
+
+            AddUntilStep("wait for song select", () => Stack.CurrentScreen is Screens.SelectV2.SongSelect);
+            AddUntilStep("wait for filtered", () => SongSelect.ChildrenOfType<BeatmapCarousel>().Single().FilterCount, () => Is.EqualTo(2));
+        }
+
         [Test]
         public void TestAutoplayShortcut()
         {
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
new file mode 100644
index 0000000000..7c604eb37b
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
@@ -0,0 +1,291 @@
+// 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;
+using osuTK.Input;
+
+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 => Carousel.CurrentBeatmap;
+        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);
+        }
+
+        [Test]
+        [Explicit]
+        public void TestDebounceNotBypassedOnUpdate()
+        {
+            BeatmapInfo? selectedBefore = null;
+            BeatmapInfo? selectedBeatmapDuringDebounce = null;
+
+            // we're testing the song select side debounce, so let's make filtering immediate
+            AddStep("set filter debounce delay to zero", () => Carousel.DebounceDelay = 0);
+
+            WaitForFiltering();
+
+            AddUntilStep("wait for global beatmap selection", () => !Beatmap.IsDefault);
+
+            AddStep("store selection", () => selectedBefore = Beatmap.Value.BeatmapInfo);
+
+            AddStep("traverse to next panel and update simultaneously", () =>
+            {
+                InputManager.Key(Key.Right);
+
+                Beatmaps.Delete(Beatmaps.GetAllUsableBeatmapSets().Last());
+
+                // check selection during debounce
+                Scheduler.AddDelayed(() => selectedBeatmapDuringDebounce = Beatmap.Value.BeatmapInfo, Screens.SelectV2.SongSelect.SELECTION_DEBOUNCE / 2f);
+            });
+
+            WaitForFiltering();
+
+            AddUntilStep("wait for pre-debounce selection", () => selectedBeatmapDuringDebounce, () => Is.Not.Null);
+
+            AddAssert("selection during debounce didn't change", () => selectedBeatmapDuringDebounce, () => Is.EqualTo(selectedBefore));
+
+            // Due to nunit runs having limited precision this tends to fail when headless, even though you'd expect the previous step to fail.
+            // Interactively, things fail as expected.
+            AddUntilStep("selection has changed after debounce", () => selectedBeatmapDuringDebounce, () => Is.Not.EqualTo(Beatmap.Value.BeatmapInfo));
+        }
+
+        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.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs
new file mode 100644
index 0000000000..aa80321033
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs
@@ -0,0 +1,341 @@
+// 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 System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Extensions;
+using osu.Game.Models;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Scoring;
+using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    /// <summary>
+    /// Test suite for grouping modes which require the presence of API / realm.
+    /// All other grouping modes are tested separately in <see cref="BeatmapCarouselFilterGroupingTest"/>.
+    /// </summary>
+    public partial class TestSceneSongSelectGrouping : SongSelectTestScene
+    {
+        private BeatmapCarouselFilterGrouping grouping => Carousel.Filters.OfType<BeatmapCarouselFilterGrouping>().Single();
+
+        [SetUp]
+        public void SetUp() => Schedule(() => API.Logout());
+
+        #region Collection grouping
+
+        [Test]
+        public void TestCollectionGrouping()
+        {
+            ImportBeatmapForRuleset(0);
+            ImportBeatmapForRuleset(0);
+            ImportBeatmapForRuleset(0);
+
+            BeatmapSetInfo[] beatmapSets = null!;
+
+            AddStep("add collections", () =>
+            {
+                beatmapSets = Beatmaps.GetAllUsableBeatmapSets().OrderBy(b => b.OnlineID).ToArray();
+
+                Realm.Write(r =>
+                {
+                    r.RemoveAll<BeatmapCollection>();
+                    r.Add(new BeatmapCollection("My Collection #1", beatmapSets[0].Beatmaps.Select(b => b.MD5Hash).ToList()));
+                    r.Add(new BeatmapCollection("My Collection #2", beatmapSets[1].Beatmaps.Select(b => b.MD5Hash).ToList()));
+                    r.Add(new BeatmapCollection("My Collection #3"));
+                });
+            });
+
+            LoadSongSelect();
+            GroupBy(GroupMode.Collections);
+            WaitForFiltering();
+
+            assertGroupPresent("My Collection #1", () => new[] { beatmapSets[0] });
+            assertGroupPresent("My Collection #2", () => new[] { beatmapSets[1] });
+            assertGroupPresent("Not in collection", () => new[] { beatmapSets[2] });
+            assertGroupsCount(3);
+        }
+
+        [Test]
+        public void TestCollectionGroupingUpdatesOnChange()
+        {
+            ImportBeatmapForRuleset(0);
+
+            BeatmapSetInfo beatmapSet = null!;
+
+            AddStep("add collections", () =>
+            {
+                beatmapSet = Beatmaps.GetAllUsableBeatmapSets().Single();
+
+                Realm.Write(r =>
+                {
+                    r.RemoveAll<BeatmapCollection>();
+                    r.Add(new BeatmapCollection("My Collection #4"));
+                });
+            });
+
+            LoadSongSelect();
+            GroupBy(GroupMode.Collections);
+            WaitForFiltering();
+
+            AddAssert("collection not present", () => grouping.GroupItems.All(g => g.Key.Title != "My Collection #4"));
+
+            AddAssert("no-collection group present", () =>
+            {
+                var group = grouping.GroupItems.Single(g => g.Key.Title == "Not in collection");
+                return group.Value.Select(i => i.Model).OfType<GroupedBeatmapSet>().Single().BeatmapSet.Equals(beatmapSet);
+            });
+
+            AddStep("add beatmap to collection", () =>
+            {
+                Realm.Write(r =>
+                {
+                    var collection = r.All<BeatmapCollection>().Single();
+                    collection.BeatmapMD5Hashes.AddRange(beatmapSet.Beatmaps.Select(b => b.MD5Hash));
+                });
+            });
+
+            WaitForFiltering();
+
+            assertGroupPresent("My Collection #4", () => new[] { beatmapSet });
+            assertGroupsCount(1);
+        }
+
+        #endregion
+
+        #region My Maps grouping
+
+        [Test]
+        public void TestMyMapsGrouping()
+        {
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user1", 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user2", 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user3", 3, 0);
+
+            BeatmapSetInfo[] beatmapSets = null!;
+
+            AddStep("get beatmaps", () => beatmapSets = Beatmaps.GetAllUsableBeatmapSets().OrderBy(b => b.OnlineID).ToArray());
+
+            AddStep("log in", () =>
+            {
+                API.Login("user1", string.Empty);
+                API.AuthenticateSecondFactor("abcdefgh");
+            });
+
+            LoadSongSelect();
+            GroupBy(GroupMode.MyMaps);
+            WaitForFiltering();
+
+            assertGroupPresent("My maps", () => new[] { beatmapSets[0] });
+            assertGroupsCount(1);
+        }
+
+        [Test]
+        public void TestMyMapsGroupingRenamedUsername()
+        {
+            ImportBeatmapForRuleset(s =>
+            {
+                ((RealmUser)s.Metadata.Author).Username = "user1_old";
+                ((RealmUser)s.Metadata.Author).OnlineID = DummyAPIAccess.DUMMY_USER_ID;
+            }, 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user2", 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user3", 3, 0);
+
+            BeatmapSetInfo[] beatmapSets = null!;
+
+            AddStep("get beatmaps", () => beatmapSets = Beatmaps.GetAllUsableBeatmapSets().OrderBy(b => b.OnlineID).ToArray());
+
+            AddStep("log in", () =>
+            {
+                API.Login("user1", string.Empty);
+                API.AuthenticateSecondFactor("abcdefgh");
+            });
+
+            LoadSongSelect();
+            GroupBy(GroupMode.MyMaps);
+            WaitForFiltering();
+
+            assertGroupPresent("My maps", () => new[] { beatmapSets[0] });
+            assertGroupsCount(1);
+        }
+
+        [Test]
+        public void TestMyMapsGroupingUpdatesOnUserChange()
+        {
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user1", 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = "user2", 3, 0);
+            ImportBeatmapForRuleset(s => ((RealmUser)s.Metadata.Author).Username = new GuestUser().Username, 3, 0);
+
+            BeatmapSetInfo[] beatmapSets = null!;
+
+            AddStep("get beatmaps", () => beatmapSets = Beatmaps.GetAllUsableBeatmapSets().OrderBy(b => b.OnlineID).ToArray());
+
+            // stay logged out
+
+            LoadSongSelect();
+            GroupBy(GroupMode.MyMaps);
+            WaitForFiltering();
+
+            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
+            checkMatchedBeatmaps(0);
+
+            AddStep("log in", () =>
+            {
+                API.Login("user2", string.Empty);
+                API.AuthenticateSecondFactor("abcdefgh");
+            });
+
+            WaitForFiltering();
+
+            assertGroupPresent("My maps", () => new[] { beatmapSets[1] });
+            assertGroupsCount(1);
+        }
+
+        #endregion
+
+        #region Rank Achieved grouping
+
+        [Test]
+        public void TestRankAchievedGrouping()
+        {
+            ImportBeatmapForRuleset(_ => { }, 1, 0);
+            ImportBeatmapForRuleset(_ => { }, 1, 0);
+            ImportBeatmapForRuleset(_ => { }, 1, 0);
+            ImportBeatmapForRuleset(_ => { }, 1, 0);
+            ImportBeatmapForRuleset(_ => { }, 1, 0);
+
+            AddStep("log in", () =>
+            {
+                API.Login("user1", string.Empty); // match username in test scores.
+                API.AuthenticateSecondFactor("abcdefgh");
+            });
+
+            BeatmapSetInfo[] beatmapSets = null!;
+
+            AddStep("add scores", () =>
+            {
+                beatmapSets = Beatmaps.GetAllUsableBeatmapSets().OrderBy(b => b.OnlineID).ToArray();
+
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[0].Beatmaps[0], ScoreRank.SH));
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[1].Beatmaps[0], ScoreRank.A));
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[2].Beatmaps[0], ScoreRank.C));
+
+                // score belonging to another user on an unplayed beatmap.
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[3].Beatmaps[0], ScoreRank.XH, s => s.User = new APIUser { Id = 1337, Username = "user2" }));
+
+                // score belonging to another user on a played beatmap.
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[0].Beatmaps[0], ScoreRank.XH, s => s.User = new APIUser { Id = 1337, Username = "user2" }));
+
+                // score belonging to local user but with less rank.
+                ScoreManager.Import(createTestScoreInfo(beatmapSets[0].Beatmaps[0], ScoreRank.D));
+            });
+
+            LoadSongSelect();
+            GroupBy(GroupMode.RankAchieved);
+            WaitForFiltering();
+
+            assertGroupPresent("S+", () => new[] { beatmapSets[0] });
+            assertGroupPresent("A", () => new[] { beatmapSets[1] });
+            assertGroupPresent("C", () => new[] { beatmapSets[2] });
+            assertGroupPresent("Unplayed", () => new[] { beatmapSets[3], beatmapSets[4] });
+            assertGroupsCount(4);
+        }
+
+        #endregion
+
+        #region Benchmarks
+
+        [Test]
+        [Explicit("Manual benchmark")]
+        public void TestPerformance()
+        {
+            const int sets_count = 100;
+            const int diffs_count = 100;
+
+            AddStep("log in", () =>
+            {
+                API.Login("user1", string.Empty); // match username in test scores.
+                API.AuthenticateSecondFactor("abcdefgh");
+            });
+
+            int count = 0;
+
+            AddStep("populate database", () =>
+            {
+                count = 0;
+
+                Task.Factory.StartNew(() =>
+                {
+                    for (int i = 0; i < sets_count; i++)
+                    {
+                        var liveSet = Beatmaps.Import(TestResources.CreateTestBeatmapSetInfo(diffs_count, Rulesets.AvailableRulesets.ToArray()))!;
+
+                        liveSet.PerformRead(s =>
+                        {
+                            foreach (var beatmap in s.Beatmaps
+                                                     .GroupBy(b => b.Ruleset.OnlineID)
+                                                     .Select(g => g.OrderBy(_ => RNG.Next()).Take(4)) // take 4 difficulties from each ruleset randomly
+                                                     .SelectMany(g => g))
+                            {
+                                for (int k = 0; k < 3; k++) // create 3 scores per difficulty
+                                    ScoreManager.Import(createTestScoreInfo(beatmap));
+                            }
+                        });
+
+                        count++;
+                    }
+                }, TaskCreationOptions.LongRunning);
+            });
+
+            AddUntilStep("wait for population", () => count, () => Is.GreaterThan(sets_count / 3));
+            AddUntilStep("this takes a while", () => count, () => Is.GreaterThan(sets_count / 3 * 2));
+            AddUntilStep("maybe they are done now", () => count, () => Is.EqualTo(sets_count));
+
+            LoadSongSelect();
+        }
+
+        #endregion
+
+        private void assertGroupsCount(int expected)
+        {
+            AddAssert($"groups = {expected}", () => grouping.GroupItems, () => Has.Count.EqualTo(expected));
+        }
+
+        private void assertGroupPresent(string name, Func<IEnumerable<BeatmapSetInfo>> getBeatmaps)
+        {
+            AddAssert($"\"{name}\" present", () =>
+            {
+                var group = grouping.GroupItems.Single(g => g.Key.Title == name);
+                var actualBeatmaps = group.Value.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap).OrderBy(b => b.ID);
+                var expectedBeatmaps = getBeatmaps().SelectMany(s => s.Beatmaps).OrderBy(b => b.ID);
+                return actualBeatmaps.SequenceEqual(expectedBeatmaps);
+            });
+        }
+
+        private NoResultsPlaceholder? getPlaceholder() => SongSelect.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
+
+        private void checkMatchedBeatmaps(int expected) => AddUntilStep($"{expected} matching shown", () => Carousel.MatchedBeatmapsCount, () => Is.EqualTo(expected));
+
+        private ScoreInfo createTestScoreInfo(BeatmapInfo beatmap, ScoreRank? rank = null, Action<ScoreInfo>? applyToScore = null)
+        {
+            var score = TestResources.CreateTestScoreInfo(beatmap);
+            score.User = API.LocalUser.Value;
+            score.Rank = rank ?? Enum.GetValues<ScoreRank>().MinBy(_ => RNG.Next());
+            score.TotalScore = (long)(((double)score.Rank + 1) / (Enum.GetValues<ScoreRank>().Length + 1) * 1000000);
+            score.Date = DateTimeOffset.Now;
+            applyToScore?.Invoke(score);
+            return score;
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModIcon.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModIcon.cs
index c18f00677d..d554ac7424 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModIcon.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModIcon.cs
@@ -4,11 +4,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -22,6 +24,9 @@ namespace osu.Game.Tests.Visual.UserInterface
         private FillFlowContainer spreadOutFlow = null!;
         private ModDisplay modDisplay = null!;
 
+        [Resolved]
+        private RulesetStore rulesetStore { get; set; } = null!;
+
         [SetUpSteps]
         public void SetUpSteps()
         {
@@ -70,9 +75,26 @@ namespace osu.Game.Tests.Visual.UserInterface
         [Test]
         public void TestShowAllMods()
         {
-            AddStep("create mod icons", () =>
+            createModIconsForRuleset(0);
+            createModIconsForRuleset(1);
+            createModIconsForRuleset(2);
+            createModIconsForRuleset(3);
+
+            AddStep("toggle selected", () =>
             {
-                addRange(Ruleset.Value.CreateInstance().CreateAllMods().Select(m =>
+                foreach (var icon in this.ChildrenOfType<ModIcon>())
+                    icon.Selected.Toggle();
+            });
+        }
+
+        private void createModIconsForRuleset(int rulesetId)
+        {
+            AddStep($"create mod icons for ruleset {rulesetId}", () =>
+            {
+                spreadOutFlow.Clear();
+                modDisplay.Current.Value = [];
+
+                addRange(rulesetStore.GetRuleset(rulesetId)!.CreateInstance().CreateAllMods().Select(m =>
                 {
                     if (m is OsuModFlashlight fl)
                         fl.FollowDelay.Value = 1245;
@@ -89,12 +111,6 @@ namespace osu.Game.Tests.Visual.UserInterface
                     return m;
                 }));
             });
-
-            AddStep("toggle selected", () =>
-            {
-                foreach (var icon in this.ChildrenOfType<ModIcon>())
-                    icon.Selected.Toggle();
-            });
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
index 3648291816..9d23b2130a 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using NUnit.Framework;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -65,7 +64,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep(@"simple #2", sendAmazingNotification);
             AddStep(@"progress #1", sendUploadProgress);
             AddStep(@"progress #2", sendDownloadProgress);
-            AddStep(@"User notification", sendUserNotification);
 
             checkProgressingCount(2);
 
@@ -577,16 +575,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             progressingNotifications.Add(n);
         }
 
-        private void sendUserNotification()
-        {
-            var user = userLookupCache.GetUserAsync(0).GetResultSafely();
-            if (user == null) return;
-
-            var n = new UserAvatarNotification(user, $"{user.Username} invited you to a multiplayer match!");
-
-            notificationOverlay.Post(n);
-        }
-
         private void sendUploadProgress()
         {
             var n = new ProgressNotification
diff --git a/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs b/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
index 31583bf8b7..eb9faa5930 100644
--- a/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
+++ b/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
@@ -6,6 +6,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.IPC;
 using osu.Game.Tournament.Screens.Gameplay;
@@ -66,6 +67,6 @@ namespace osu.Game.Tournament.Tests.Screens
                 () => this.ChildrenOfType<TeamScore>().All(score => score.Alpha == (visible ? 1 : 0)));
 
         private void toggleWarmup()
-            => AddStep("toggle warmup", () => this.ChildrenOfType<TourneyButton>().First().TriggerClick());
+            => AddStep("toggle warmup", () => this.ChildrenOfType<LabelledSwitchButton>().First().ChildrenOfType<SwitchButton>().First().TriggerClick());
     }
 }
diff --git a/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs b/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
index b2152eaf3d..2cf7ce1961 100644
--- a/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
+++ b/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
@@ -7,7 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Threading;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays.Settings;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.IPC;
@@ -24,7 +24,6 @@ namespace osu.Game.Tournament.Screens.Gameplay
         private readonly BindableBool warmup = new BindableBool();
 
         public readonly Bindable<TourneyState> State = new Bindable<TourneyState>();
-        private OsuButton warmupButton = null!;
         private MatchIPCInfo ipc = null!;
 
         [Resolved]
@@ -40,6 +39,8 @@ namespace osu.Game.Tournament.Screens.Gameplay
         {
             this.ipc = ipc;
 
+            LabelledSwitchButton chatToggle;
+
             AddRangeInternal(new Drawable[]
             {
                 new TourneyVideo("gameplay")
@@ -95,17 +96,14 @@ namespace osu.Game.Tournament.Screens.Gameplay
                 {
                     Children = new Drawable[]
                     {
-                        warmupButton = new TourneyButton
+                        new LabelledSwitchButton
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Text = "Toggle warmup",
-                            Action = () => warmup.Toggle()
+                            Label = "Warmup",
+                            Current = warmup,
                         },
-                        new TourneyButton
+                        chatToggle = new LabelledSwitchButton
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Text = "Toggle chat",
-                            Action = () => { State.Value = State.Value == TourneyState.Idle ? TourneyState.Playing : TourneyState.Idle; }
+                            Label = "Show chat",
                         },
                         new SettingsSlider<int>
                         {
@@ -123,13 +121,12 @@ namespace osu.Game.Tournament.Screens.Gameplay
                 }
             });
 
+            State.BindValueChanged(state => chatToggle.Current.Value = State.Value == TourneyState.Idle, true);
+            chatToggle.Current.BindValueChanged(v => State.Value = v.NewValue ? TourneyState.Idle : TourneyState.Playing);
+
             LadderInfo.ChromaKeyWidth.BindValueChanged(width => chroma.Width = width.NewValue, true);
 
-            warmup.BindValueChanged(w =>
-            {
-                warmupButton.Alpha = !w.NewValue ? 0.5f : 1;
-                header.ShowScores = !w.NewValue;
-            }, true);
+            warmup.BindValueChanged(w => header.ShowScores = !w.NewValue, true);
         }
 
         protected override void LoadComplete()
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/APIBeatmapMetadataSource.cs b/osu.Game/Beatmaps/APIBeatmapMetadataSource.cs
index 34eedfb474..e15de7ec02 100644
--- a/osu.Game/Beatmaps/APIBeatmapMetadataSource.cs
+++ b/osu.Game/Beatmaps/APIBeatmapMetadataSource.cs
@@ -63,7 +63,9 @@ namespace osu.Game.Beatmaps
                         DateRanked = res.BeatmapSet?.Ranked,
                         DateSubmitted = res.BeatmapSet?.Submitted,
                         MD5Hash = res.MD5Hash,
-                        LastUpdated = res.LastUpdated
+                        LastUpdated = res.LastUpdated,
+                        // Tags are not populated because the response does not contain tag data.
+                        // TODO: consider web change to include the tag data? or a second web request for the set to retrieve tags?
                     };
                     return true;
                 }
diff --git a/osu.Game/Beatmaps/BeatmapImporter.cs b/osu.Game/Beatmaps/BeatmapImporter.cs
index 28997509dc..f80c4de4ea 100644
--- a/osu.Game/Beatmaps/BeatmapImporter.cs
+++ b/osu.Game/Beatmaps/BeatmapImporter.cs
@@ -367,7 +367,11 @@ namespace osu.Game.Beatmaps
         {
             var beatmaps = new List<BeatmapInfo>();
 
-            foreach (var file in beatmapSet.Files.Where(f => f.Filename.EndsWith(".osu", StringComparison.OrdinalIgnoreCase)))
+            // stable appears to ignore `.osu` files which are not placed at the top level of the beatmap archive.
+            // the logic that achieves this is very difficult to make sense of, but appears to be located somewhere around
+            // https://github.com/peppy/osu-stable-reference/blob/67795dba3c308e7d0493b296149dcb073ca47ecb/osu!/GameplayElements/Beatmaps/BeatmapManager.cs#L207-L208
+            // only testing the `/` path separator character is sufficient as `RealmNamedFileUsage`s are normalised to use the front slash unix path separator convention
+            foreach (var file in beatmapSet.Files.Where(f => !f.Filename.Contains('/') && f.Filename.EndsWith(@".osu", StringComparison.OrdinalIgnoreCase)))
             {
                 using (var memoryStream = new MemoryStream(Files.Store.Get(file.File.GetStoragePath()))) // we need a memory stream so we can seek
                 {
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/BeatmapMetadata.cs b/osu.Game/Beatmaps/BeatmapMetadata.cs
index 811dc54e16..1603a9848c 100644
--- a/osu.Game/Beatmaps/BeatmapMetadata.cs
+++ b/osu.Game/Beatmaps/BeatmapMetadata.cs
@@ -2,9 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Game.Models;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Users;
 using osu.Game.Utils;
 using Realms;
@@ -15,10 +17,10 @@ namespace osu.Game.Beatmaps
     /// A realm model containing metadata for a beatmap.
     /// </summary>
     /// <remarks>
-    /// This is currently stored against each beatmap difficulty, even when it is duplicated.
+    /// An instance of this object is stored against each beatmap difficulty.
     /// It is also provided via <see cref="BeatmapSetInfo"/> for convenience and historical purposes.
-    /// A future effort could see this converted to an <see cref="EmbeddedObject"/> or potentially de-duped
-    /// and shared across multiple difficulties in the same set, if required.
+    /// Note that accessing the metadata via <see cref="BeatmapSetInfo"/> may result in indeterminate results
+    /// as metadata can meaningfully differ per beatmap in a set.
     ///
     /// Note that difficulty name is not stored in this metadata but in <see cref="BeatmapInfo"/>.
     /// </remarks>
@@ -43,6 +45,13 @@ namespace osu.Game.Beatmaps
         [JsonProperty(@"tags")]
         public string Tags { get; set; } = string.Empty;
 
+        /// <summary>
+        /// The list of user-voted tags applicable to this beatmap.
+        /// This information is populated from online sources (<see cref="RealmPopulatingOnlineLookupSource"/>)
+        /// and can meaningfully differ between beatmaps of a single set.
+        /// </summary>
+        public IList<string> UserTags { get; } = null!;
+
         /// <summary>
         /// The time in milliseconds to begin playing the track for preview purposes.
         /// If -1, the track should begin playing at 40% of its length.
diff --git a/osu.Game/Beatmaps/BeatmapOnlineStatus.cs b/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
index bc1438d7c7..65591abbf6 100644
--- a/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
+++ b/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
@@ -18,6 +18,7 @@ namespace osu.Game.Beatmaps
         [Description("Local")]
         LocallyModified = -4,
 
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.StatusUnknown))]
         [Description("Unknown")]
         None = -3,
 
diff --git a/osu.Game/Beatmaps/BeatmapUpdaterMetadataLookup.cs b/osu.Game/Beatmaps/BeatmapUpdaterMetadataLookup.cs
index 364a0f9b4b..d2d9a54fba 100644
--- a/osu.Game/Beatmaps/BeatmapUpdaterMetadataLookup.cs
+++ b/osu.Game/Beatmaps/BeatmapUpdaterMetadataLookup.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Platform;
+using osu.Game.Extensions;
 using osu.Game.Online.API;
 
 namespace osu.Game.Beatmaps
@@ -76,6 +77,8 @@ namespace osu.Game.Beatmaps
                 {
                     beatmapInfo.Status = res.BeatmapStatus;
                     beatmapInfo.Metadata.Author.OnlineID = res.AuthorID;
+                    beatmapInfo.Metadata.UserTags.Clear();
+                    beatmapInfo.Metadata.UserTags.AddRange(res.UserTags);
                 }
             }
 
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
index 56103c1d6d..54f8d656fe 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
@@ -7,7 +7,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
@@ -35,6 +37,18 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
         protected readonly BeatmapDownloadTracker DownloadTracker;
 
+        private readonly Bindable<bool> preferNoVideo = new BindableBool();
+        private InputManager? containingInputManager;
+
+        [Resolved]
+        private BeatmapSetOverlay? beatmapSetOverlay { get; set; }
+
+        [Resolved]
+        private BeatmapModelDownloader? beatmaps { get; set; }
+
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         protected BeatmapCard(APIBeatmapSet beatmapSet, bool allowExpansion = true)
             : base(HoverSampleSet.Button)
         {
@@ -45,10 +59,10 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             DownloadTracker = new BeatmapDownloadTracker(beatmapSet);
         }
 
-        [BackgroundDependencyLoader(true)]
-        private void load(BeatmapSetOverlay? beatmapSetOverlay)
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager configManager)
         {
-            Action = () => beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
+            configManager.BindWith(OsuSetting.PreferNoVideo, preferNoVideo);
 
             AddInternal(DownloadTracker);
         }
@@ -60,6 +74,28 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             DownloadTracker.State.BindValueChanged(_ => UpdateState());
             Expanded.BindValueChanged(_ => UpdateState(), true);
             FinishTransforms(true);
+
+            containingInputManager = GetContainingInputManager();
+
+            Action = () =>
+            {
+                if (containingInputManager?.CurrentState.Keyboard.ShiftPressed == true)
+                {
+                    switch (DownloadTracker.State.Value)
+                    {
+                        case DownloadState.NotDownloaded:
+                            if (!BeatmapSet.Availability.DownloadDisabled)
+                                beatmaps?.Download(BeatmapSet, preferNoVideo.Value);
+                            break;
+
+                        case DownloadState.LocallyAvailable:
+                            game?.PresentBeatmap(BeatmapSet);
+                            break;
+                    }
+                }
+                else
+                    beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
+            };
         }
 
         protected override bool OnHover(HoverEvent e)
@@ -103,7 +139,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..280185ba17 100644
--- a/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
+++ b/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
@@ -23,10 +23,6 @@ namespace osu.Game.Beatmaps.Drawables
     {
         private OsuSpriteText difficultyName = null!;
         private StarRatingDisplay starRating = null!;
-        private OsuSpriteText overallDifficulty = null!;
-        private OsuSpriteText drainRate = null!;
-        private OsuSpriteText circleSize = null!;
-        private OsuSpriteText approachRate = null!;
         private OsuSpriteText bpm = null!;
         private OsuSpriteText length = null!;
 
@@ -76,13 +72,6 @@ namespace osu.Game.Beatmaps.Drawables
                             AutoSizeAxes = Axes.Both,
                             Direction = FillDirection.Horizontal,
                             Spacing = new Vector2(5),
-                            Children = new Drawable[]
-                            {
-                                circleSize = new OsuSpriteText { Font = OsuFont.GetFont(size: 14) },
-                                drainRate = new OsuSpriteText { Font = OsuFont.GetFont(size: 14) },
-                                overallDifficulty = new OsuSpriteText { Font = OsuFont.GetFont(size: 14) },
-                                approachRate = new OsuSpriteText { Font = OsuFont.GetFont(size: 14) },
-                            }
                         },
                         miscFillFlowContainer = new FillFlowContainer
                         {
@@ -131,21 +120,16 @@ namespace osu.Game.Beatmaps.Drawables
 
             double bpmAdjusted = displayedContent.BeatmapInfo.BPM * rate;
 
-            BeatmapDifficulty originalDifficulty = new BeatmapDifficulty(displayedContent.BeatmapInfo.Difficulty);
-
-            if (displayedContent.Mods != null)
-            {
-                foreach (var mod in displayedContent.Mods.OfType<IApplicableToDifficulty>())
-                    mod.ApplyToDifficulty(originalDifficulty);
-            }
-
             Ruleset ruleset = displayedContent.Ruleset.CreateInstance();
-            BeatmapDifficulty adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(originalDifficulty, rate);
+            var beatmapAttributes = ruleset.GetBeatmapAttributesForDisplay(displayedContent.BeatmapInfo, displayedContent.Mods ?? [])
+                                           .Select(attr => new OsuSpriteText
+                                           {
+                                               Font = OsuFont.Style.Caption1,
+                                               Text = $@"{attr.Acronym}: {attr.AdjustedValue:0.##}"
+                                           });
 
-            circleSize.Text = @"CS: " + adjustedDifficulty.CircleSize.ToString(@"0.##");
-            drainRate.Text = @" HP: " + adjustedDifficulty.DrainRate.ToString(@"0.##");
-            approachRate.Text = @" AR: " + adjustedDifficulty.ApproachRate.ToString(@"0.##");
-            overallDifficulty.Text = @" OD: " + adjustedDifficulty.OverallDifficulty.ToString(@"0.##");
+            difficultyFillFlowContainer.Clear();
+            difficultyFillFlowContainer.AddRange(beatmapAttributes);
 
             TimeSpan lengthTimeSpan = TimeSpan.FromMilliseconds(displayedContent.BeatmapInfo.Length / rate);
             length.Text = "Length: " + lengthTimeSpan.ToFormattedDuration();
diff --git a/osu.Game/Beatmaps/Drawables/UpdateableOnlineBeatmapSetCover.cs b/osu.Game/Beatmaps/Drawables/UpdateableOnlineBeatmapSetCover.cs
index 5bce472613..a03ee64ef4 100644
--- a/osu.Game/Beatmaps/Drawables/UpdateableOnlineBeatmapSetCover.cs
+++ b/osu.Game/Beatmaps/Drawables/UpdateableOnlineBeatmapSetCover.cs
@@ -50,8 +50,7 @@ namespace osu.Game.Beatmaps.Drawables
         protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
             => new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad, timeBeforeUnload)
             {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
             };
 
         protected override Drawable CreateDrawable(IBeatmapSetOnlineInfo model)
diff --git a/osu.Game/Beatmaps/FramedBeatmapClock.cs b/osu.Game/Beatmaps/FramedBeatmapClock.cs
index af7be235fc..8ce0db6e7b 100644
--- a/osu.Game/Beatmaps/FramedBeatmapClock.cs
+++ b/osu.Game/Beatmaps/FramedBeatmapClock.cs
@@ -59,7 +59,10 @@ namespace osu.Game.Beatmaps
 
             // An interpolating clock is used to ensure precise time values even when the host audio subsystem is not reporting
             // high precision times (on windows there's generally only 5-10ms reporting intervals, as an example).
-            interpolatedTrack = new InterpolatingFramedClock(decoupledTrack);
+            interpolatedTrack = new InterpolatingFramedClock(decoupledTrack)
+            {
+                DriftRecoveryHalfLife = 80,
+            };
 
             if (applyOffsets)
             {
diff --git a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
index d876ba55b2..c591dac36f 100644
--- a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
+++ b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Beatmaps
             this.storage = storage;
 
             if (shouldFetchCache())
-                prepareLocalCache();
+                FetchCache();
         }
 
         private bool shouldFetchCache()
@@ -105,7 +105,11 @@ namespace osu.Game.Beatmaps
                     switch (getCacheVersion(db))
                     {
                         case 2:
+                            // can be removed 20260123
                             return queryCacheVersion2(db, beatmapInfo, out onlineMetadata);
+
+                        case 3:
+                            return queryCacheVersion3(db, beatmapInfo, out onlineMetadata);
                     }
                 }
 
@@ -127,7 +131,7 @@ namespace osu.Game.Beatmaps
                             return false;
 
                         tryPurgeCache();
-                        prepareLocalCache();
+                        FetchCache();
                         return false;
                 }
 
@@ -161,7 +165,7 @@ namespace osu.Game.Beatmaps
         private SqliteConnection getConnection() =>
             new SqliteConnection(string.Concat(@"Data Source=", storage.GetFullPath(@"online.db", true)));
 
-        private void prepareLocalCache()
+        public Task FetchCache()
         {
             bool isRefetch = storage.Exists(cache_database_name);
 
@@ -188,6 +192,13 @@ namespace osu.Game.Beatmaps
             {
                 try
                 {
+                    // `SqliteConnection` by default uses pooling.
+                    // disposing an `SqliteConnection` is not enough to get `Microsoft.Data.Sqlite` to close the database file.
+                    // this means that overwriting the file may fail if the pools are not cleared before trying.
+                    // this fails especially loudly on Windows because of Windows file delete semantics being exclusive-write
+                    // rather than Unix's "file is marked for deletion after last reader closes the fd".
+                    SqliteConnection.ClearAllPools();
+
                     using (var stream = File.OpenRead(cacheDownloadRequest.Filename))
                     using (var outStream = File.OpenWrite(cacheFilePath))
                     {
@@ -214,7 +225,7 @@ namespace osu.Game.Beatmaps
                 }
             };
 
-            Task.Run(async () =>
+            return Task.Run(async () =>
             {
                 try
                 {
@@ -227,12 +238,20 @@ namespace osu.Game.Beatmaps
             });
         }
 
-        public int GetCacheVersion()
+        public bool IsAtLeastVersion(int version)
         {
-            using (var connection = getConnection())
+            try
             {
-                connection.Open();
-                return getCacheVersion(connection);
+                using (var connection = getConnection())
+                {
+                    connection.Open();
+                    return getCacheVersion(connection) >= version;
+                }
+            }
+            catch (SqliteException ex) when (ex.SqliteErrorCode == 26 || ex.SqliteErrorCode == 11) // SQLITE_NOTADB, SQLITE_CORRUPT
+            {
+                // if the database is corrupted then return `false` as the consumer may want to just refetch the db themselves
+                return false;
             }
         }
 
@@ -265,6 +284,16 @@ namespace osu.Game.Beatmaps
             }
         }
 
+        public DateTime? GetCacheFetchDate()
+        {
+            string path = storage.GetFullPath(cache_database_name);
+            var file = new FileInfo(path);
+            if (!file.Exists)
+                return null;
+
+            return file.LastWriteTime;
+        }
+
         private bool queryCacheVersion2(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
         {
             Debug.Assert(beatmapInfo.BeatmapSet != null);
@@ -311,6 +340,63 @@ namespace osu.Game.Beatmaps
             return false;
         }
 
+        private bool queryCacheVersion3(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
+        {
+            Debug.Assert(beatmapInfo.BeatmapSet != null);
+
+            using (var cmd = db.CreateCommand())
+            {
+                cmd.CommandText =
+                    """
+                    SELECT `b`.`beatmapset_id`, `b`.`beatmap_id`, `b`.`approved`, `b`.`user_id`, `b`.`checksum`, `b`.`last_update`, `s`.`submit_date`, `s`.`approved_date`
+                    FROM `osu_beatmaps` AS `b`
+                    JOIN `osu_beatmapsets` AS `s` ON `s`.`beatmapset_id` = `b`.`beatmapset_id`
+                    WHERE (`b`.`checksum` = @MD5Hash OR `b`.`filename` = @Path)
+                    """;
+
+                cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
+                cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
+
+                using (var reader = cmd.ExecuteReader())
+                {
+                    if (!reader.Read())
+                    {
+                        onlineMetadata = null;
+                        return false;
+                    }
+
+                    logForModel(beatmapInfo.BeatmapSet, $@"Cached local retrieval for {beatmapInfo} (cache version 3).");
+
+                    onlineMetadata = new OnlineBeatmapMetadata
+                    {
+                        BeatmapSetID = reader.GetInt32(0),
+                        BeatmapID = reader.GetInt32(1),
+                        BeatmapStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                        BeatmapSetStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                        AuthorID = reader.GetInt32(3),
+                        MD5Hash = reader.GetString(4),
+                        LastUpdated = reader.GetDateTimeOffset(5),
+                        DateSubmitted = reader.GetDateTimeOffset(6),
+                        DateRanked = reader.GetDateTimeOffset(7),
+                    };
+                }
+            }
+
+            using (var tagsCommand = db.CreateCommand())
+            {
+                tagsCommand.CommandText = "SELECT `name` FROM `tags` WHERE `id` IN (SELECT `tag_id` FROM `beatmap_tags` WHERE `beatmap_id` = @BeatmapID)";
+                tagsCommand.Parameters.Add(new SqliteParameter(@"@BeatmapID", onlineMetadata.BeatmapID));
+
+                using (var tagsReader = tagsCommand.ExecuteReader())
+                {
+                    while (tagsReader.Read())
+                        onlineMetadata.UserTags.Add(tagsReader.GetString(0));
+                }
+            }
+
+            return true;
+        }
+
         private static void log(string message)
             => Logger.Log($@"[{nameof(LocalCachedBeatmapMetadataSource)}] {message}", LoggingTarget.Database);
 
diff --git a/osu.Game/Beatmaps/OnlineBeatmapMetadata.cs b/osu.Game/Beatmaps/OnlineBeatmapMetadata.cs
index 8640883ca1..2acadde352 100644
--- a/osu.Game/Beatmaps/OnlineBeatmapMetadata.cs
+++ b/osu.Game/Beatmaps/OnlineBeatmapMetadata.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 
 namespace osu.Game.Beatmaps
 {
@@ -57,5 +58,10 @@ namespace osu.Game.Beatmaps
         /// The date when this metadata was last updated.
         /// </summary>
         public DateTimeOffset LastUpdated { get; init; }
+
+        /// <summary>
+        /// The list of tags that users have assigned to this beatmap.
+        /// </summary>
+        public List<string> UserTags { get; } = [];
     }
 }
diff --git a/osu.Game/Beatmaps/WorkingBeatmapCache.cs b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
index 30bbbbc1fe..9957935977 100644
--- a/osu.Game/Beatmaps/WorkingBeatmapCache.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
@@ -20,6 +20,7 @@ using osu.Framework.Platform;
 using osu.Framework.Statistics;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.IO;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
@@ -341,27 +342,10 @@ namespace osu.Game.Beatmaps
             {
                 // Matches stable implementation, because it's probably simpler than trying to do anything else.
                 // This may need to be reconsidered after we begin storing storyboards in the new editor.
-                return windowsFilenameStrip(
-                    (metadata.Artist.Length > 0 ? metadata.Artist + @" - " + metadata.Title : Path.GetFileNameWithoutExtension(metadata.AudioFile))
-                    + (metadata.Author.Username.Length > 0 ? @" (" + metadata.Author.Username + @")" : string.Empty)
-                    + @".osb");
-
-                string windowsFilenameStrip(string entry)
-                {
-                    // Inlined from Path.GetInvalidFilenameChars() to ensure the windows characters are used (to match stable).
-                    char[] invalidCharacters =
-                    {
-                        '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
-                        '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
-                        '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
-                        '\x1E', '\x1F', '\x22', '\x3C', '\x3E', '\x7C', ':', '*', '?', '\\', '/'
-                    };
-
-                    foreach (char c in invalidCharacters)
-                        entry = entry.Replace(c.ToString(), string.Empty);
-
-                    return entry;
-                }
+                string baseFilename = (metadata.Artist.Length > 0 ? metadata.Artist + @" - " + metadata.Title : Path.GetFileNameWithoutExtension(metadata.AudioFile))
+                                      + (metadata.Author.Username.Length > 0 ? @" (" + metadata.Author.Username + @")" : string.Empty)
+                                      + @".osb";
+                return baseFilename.GetValidFilename();
             }
         }
     }
diff --git a/osu.Game/Collections/CollectionFilterMenuItem.cs b/osu.Game/Collections/CollectionFilterMenuItem.cs
index 49262ed917..7dfa45379a 100644
--- a/osu.Game/Collections/CollectionFilterMenuItem.cs
+++ b/osu.Game/Collections/CollectionFilterMenuItem.cs
@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Localisation;
 using osu.Game.Database;
+using osu.Game.Localisation;
 
 namespace osu.Game.Collections
 {
@@ -20,7 +22,7 @@ namespace osu.Game.Collections
         /// <summary>
         /// The name of the collection.
         /// </summary>
-        public string CollectionName { get; }
+        public LocalisableString CollectionName { get; }
 
         /// <summary>
         /// Creates a new <see cref="CollectionFilterMenuItem"/>.
@@ -32,7 +34,7 @@ namespace osu.Game.Collections
             Collection = collection;
         }
 
-        protected CollectionFilterMenuItem(string name)
+        protected CollectionFilterMenuItem(LocalisableString name)
         {
             CollectionName = name;
         }
@@ -53,7 +55,7 @@ namespace osu.Game.Collections
     public class AllBeatmapsCollectionFilterMenuItem : CollectionFilterMenuItem
     {
         public AllBeatmapsCollectionFilterMenuItem()
-            : base("All beatmaps")
+            : base(CollectionsStrings.AllBeatmaps)
         {
         }
 
@@ -65,7 +67,7 @@ namespace osu.Game.Collections
     public class ManageCollectionsFilterMenuItem : CollectionFilterMenuItem
     {
         public ManageCollectionsFilterMenuItem()
-            : base("Manage collections...")
+            : base(CollectionsStrings.ManageCollections)
         {
         }
 
diff --git a/osu.Game/Collections/DrawableCollectionListItem.cs b/osu.Game/Collections/DrawableCollectionListItem.cs
index b0dd70227c..3031112333 100644
--- a/osu.Game/Collections/DrawableCollectionListItem.cs
+++ b/osu.Game/Collections/DrawableCollectionListItem.cs
@@ -17,6 +17,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
@@ -173,7 +174,7 @@ namespace osu.Game.Collections
                 }
                 else
                 {
-                    PlaceholderText = "Create a new collection";
+                    PlaceholderText = CollectionsStrings.CreateNew;
                 }
             }
         }
diff --git a/osu.Game/Collections/ManageCollectionsDialog.cs b/osu.Game/Collections/ManageCollectionsDialog.cs
index a738ae66cb..79166840f9 100644
--- a/osu.Game/Collections/ManageCollectionsDialog.cs
+++ b/osu.Game/Collections/ManageCollectionsDialog.cs
@@ -11,6 +11,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Resources.Localisation.Web;
 using osuTK;
@@ -79,7 +80,7 @@ namespace osu.Game.Collections
                                         {
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,
-                                            Text = "Manage collections",
+                                            Text = CollectionsStrings.ManageCollectionsTitle,
                                             Font = OsuFont.GetFont(size: 30),
                                             Padding = new MarginPadding { Vertical = 10 },
                                         },
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index bca905e7bb..cdccf7eb61 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -21,6 +21,7 @@ using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Skinning;
 using osu.Game.Users;
 
@@ -41,6 +42,7 @@ namespace osu.Game.Configuration
             SetDefault(OsuSetting.Skin, SkinInfo.ARGON_SKIN.ToString());
 
             SetDefault(OsuSetting.BeatmapDetailTab, BeatmapDetailTab.Local);
+            SetDefault(OsuSetting.BeatmapLeaderboardSortMode, LeaderboardSortMode.Score);
             SetDefault(OsuSetting.BeatmapDetailModsFilter, false);
 
             SetDefault(OsuSetting.ShowConvertedBeatmaps, true);
@@ -106,6 +108,8 @@ namespace osu.Game.Configuration
 
             SetDefault(OsuSetting.AudioOffset, 0, -500.0, 500.0, 1);
 
+            SetDefault(OsuSetting.AutomaticallyAdjustBeatmapOffset, false);
+
             // Input
             SetDefault(OsuSetting.MenuCursorSize, 1.0f, 0.5f, 2f, 0.01f);
             SetDefault(OsuSetting.GameplayCursorSize, 1.0f, 0.1f, 2f, 0.01f);
@@ -227,6 +231,9 @@ namespace osu.Game.Configuration
             SetDefault(OsuSetting.EditorSubmissionLoadInBrowserAfterSubmission, true);
 
             SetDefault(OsuSetting.WasSupporter, false);
+
+            // intentionally uses `DateTime?` and not `DateTimeOffset?` because the latter fails due to `DateTimeOffset` not implementing `IConvertible`
+            SetDefault(OsuSetting.LastOnlineTagsPopulation, (DateTime?)null);
         }
 
         protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -382,6 +389,7 @@ namespace osu.Game.Configuration
         MenuParallax,
         Prefer24HourTime,
         BeatmapDetailTab,
+        BeatmapLeaderboardSortMode,
         BeatmapDetailModsFilter,
         Username,
         ReleaseStream,
@@ -473,6 +481,10 @@ namespace osu.Game.Configuration
         /// Cached state of whether local user is a supporter.
         /// Used to allow early checks (ie for startup samples) to be in the correct state, even if the API authentication process has not completed.
         /// </summary>
-        WasSupporter
+        WasSupporter,
+
+        LastOnlineTagsPopulation,
+
+        AutomaticallyAdjustBeatmapOffset,
     }
 }
diff --git a/osu.Game/Database/BackgroundDataStoreProcessor.cs b/osu.Game/Database/BackgroundDataStoreProcessor.cs
index 4e813fa2c7..f8d1b9ae51 100644
--- a/osu.Game/Database/BackgroundDataStoreProcessor.cs
+++ b/osu.Game/Database/BackgroundDataStoreProcessor.cs
@@ -10,10 +10,12 @@ using System.Threading.Tasks;
 using Newtonsoft.Json;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
@@ -23,6 +25,7 @@ using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Scoring.Legacy;
 using osu.Game.Screens.Play;
+using Realms;
 
 namespace osu.Game.Database
 {
@@ -66,12 +69,19 @@ namespace osu.Game.Database
         [Resolved]
         private Storage storage { get; set; } = null!;
 
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        private LocalCachedBeatmapMetadataSource localMetadataSource = null!;
+
         protected virtual int TimeToSleepDuringGameplay => 30000;
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            localMetadataSource = new LocalCachedBeatmapMetadataSource(storage);
+
             ProcessingTask = Task.Factory.StartNew(() =>
             {
                 Logger.Log("Beginning background data store processing..");
@@ -85,6 +95,7 @@ namespace osu.Game.Database
                 convertLegacyTotalScoreToStandardised();
                 upgradeScoreRanks();
                 backpopulateMissingSubmissionAndRankDates();
+                backpopulateUserTags();
             }, TaskCreationOptions.LongRunning).ContinueWith(t =>
             {
                 if (t.Exception?.InnerException is ObjectDisposedException)
@@ -481,7 +492,7 @@ namespace osu.Game.Database
             if (scoreIds.Count == 0)
                 return;
 
-            var notification = showProgressNotification(scoreIds.Count, "Adjusting ranks of scores", "scores now have more correct ranks");
+            var notification = showProgressNotification(scoreIds.Count, "Adjusting ranks of scores", "scores now have more correct ranks.");
 
             int processedCount = 0;
             int failedCount = 0;
@@ -525,8 +536,6 @@ namespace osu.Game.Database
 
         private void backpopulateMissingSubmissionAndRankDates()
         {
-            var localMetadataSource = new LocalCachedBeatmapMetadataSource(storage);
-
             if (!localMetadataSource.Available)
             {
                 Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is missing.");
@@ -535,7 +544,7 @@ namespace osu.Game.Database
 
             try
             {
-                if (localMetadataSource.GetCacheVersion() < 2)
+                if (!localMetadataSource.IsAtLeastVersion(2))
                 {
                     Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is too old.");
                     return;
@@ -549,9 +558,15 @@ namespace osu.Game.Database
 
             Logger.Log("Querying for beatmap sets that contain missing submission/rank date...");
 
+            // find all ranked beatmap sets with missing date ranked or date submitted that have at least one difficulty ranked as well.
+            // the reason for checking ranked status of the difficulties is that they can be locally modified or unknown too, and for those the lookup is likely to fail.
+            // this is because metadata lookups are primarily based on file hash, so they will fail to match if the beatmap does not match the online version
+            // (which is likely to be the case if the beatmap is locally modified or unknown).
+            // that said, one difficulty in ranked state is enough for the backpopulation to work.
             HashSet<Guid> beatmapSetIds = realmAccess.Run(r => new HashSet<Guid>(
                 r.All<BeatmapSetInfo>()
-                 .Where(b => b.StatusInt > 0 && (b.DateRanked == null || b.DateSubmitted == null))
+                 .Filter($@"{nameof(BeatmapSetInfo.StatusInt)} > 0 && ({nameof(BeatmapSetInfo.DateRanked)} == null || {nameof(BeatmapSetInfo.DateSubmitted)} == null) "
+                         + $@"&& ANY {nameof(BeatmapSetInfo.Beatmaps)}.{nameof(BeatmapInfo.StatusInt)} > 0")
                  .AsEnumerable()
                  .Select(b => b.ID)));
 
@@ -582,11 +597,7 @@ namespace osu.Game.Database
                     {
                         BeatmapSetInfo beatmapSet = r.Find<BeatmapSetInfo>(id)!;
 
-                        // we want any ranked representative of the set.
-                        // the reason for checking ranked status of the difficulty is that it can be locally modified,
-                        // at which point the lookup will fail - but there might still be another unmodified difficulty on which it will work.
-                        if (beatmapSet.Beatmaps.FirstOrDefault(b => b.Status >= BeatmapOnlineStatus.Ranked) is not BeatmapInfo beatmap)
-                            return false;
+                        var beatmap = beatmapSet.Beatmaps.First(b => b.Status >= BeatmapOnlineStatus.Ranked);
 
                         bool lookupSucceeded = localMetadataSource.TryLookup(beatmap, out var result);
 
@@ -621,6 +632,110 @@ namespace osu.Game.Database
             completeNotification(notification, processedCount, beatmapSetIds.Count, failedCount);
         }
 
+        private void backpopulateUserTags()
+        {
+            if (!localMetadataSource.Available || !localMetadataSource.IsAtLeastVersion(3))
+            {
+                Logger.Log(@"Local metadata cache has too low version to backpopulate user tags, attempting refetch...");
+                localMetadataSource.FetchCache().WaitSafely();
+
+                if (!localMetadataSource.Available || !localMetadataSource.IsAtLeastVersion(3))
+                {
+                    Logger.Log(@"Local metadata cache refetch failed. Aborting user tags backpopulation.");
+                    return;
+                }
+            }
+
+            var lastPopulation = config.Get<DateTime?>(OsuSetting.LastOnlineTagsPopulation);
+            // dropping time data here completely is intentional, because storing the date to config is a lossy operation
+            // (truncates some ticks off of the date when it's being converted to string and back).
+            // therefore, if precision isn't explicitly constrained, the condition below would always fail just because the date stored to config
+            // is less accurate than the cache file's fetch date which is stored with higher precision in the filesystem metadata.
+            var metadataSourceFetchDate = localMetadataSource.GetCacheFetchDate()?.Date;
+
+            if (metadataSourceFetchDate <= lastPopulation)
+            {
+                Logger.Log($@"Skipping user tag population because the local metadata source hasn't been updated since the last time user tags were checked ({lastPopulation.Value:d})");
+                return;
+            }
+
+            Logger.Log(@"Querying for beatmaps that do not have user tags");
+
+            // it is not an abnormal situation for a map not to have user tags.
+            // while this is constrained to run every month or so (every time a new online.db cache is retrieved), there's some chance that this will still run much too often and be annoying to users.
+            // if that turns out to be the case we may need a better way to debounce this (or just delete the backpopulation logic after some time has passed?)
+            HashSet<Guid> beatmapIds = realmAccess.Run(r => new HashSet<Guid>(
+                r.All<BeatmapInfo>()
+                 .Filter($"{nameof(BeatmapInfo.Metadata)}.{nameof(BeatmapMetadata.UserTags)}.@count == 0 AND {nameof(BeatmapInfo.StatusInt)} IN {{ 1,2,4 }}")
+                 .AsEnumerable()
+                 .Select(b => b.ID)));
+
+            if (beatmapIds.Count == 0)
+                return;
+
+            Logger.Log($@"Found {beatmapIds.Count} beatmaps with missing user tags.");
+
+            var notification = showProgressNotification(beatmapIds.Count, @"Populating missing user tags", @"beatmaps have had their tags updated.");
+
+            int processedCount = 0;
+            int failedCount = 0;
+
+            foreach (var id in beatmapIds)
+            {
+                if (notification?.State == ProgressNotificationState.Cancelled)
+                    break;
+
+                updateNotificationProgress(notification, processedCount, beatmapIds.Count);
+
+                sleepIfRequired();
+
+                try
+                {
+                    // Can't use async overload because we're not on the update thread.
+                    // ReSharper disable once MethodHasAsyncOverload
+                    realmAccess.Write(r =>
+                    {
+                        BeatmapInfo beatmap = r.Find<BeatmapInfo>(id)!;
+
+                        bool lookupSucceeded = localMetadataSource.TryLookup(beatmap, out var result);
+
+                        if (lookupSucceeded)
+                        {
+                            Debug.Assert(result != null);
+
+                            var userTags = result.UserTags.ToHashSet();
+
+                            if (!userTags.SetEquals(beatmap.Metadata.UserTags))
+                            {
+                                beatmap.Metadata.UserTags.Clear();
+                                beatmap.Metadata.UserTags.AddRange(userTags);
+                                return true;
+                            }
+
+                            return false;
+                        }
+
+                        Logger.Log(@$"Could not find {beatmap.GetDisplayString()} in local cache while backpopulating missing user tags");
+                        return false;
+                    });
+
+                    ++processedCount;
+                }
+                catch (ObjectDisposedException)
+                {
+                    throw;
+                }
+                catch (Exception e)
+                {
+                    Logger.Log(@$"Failed to update user tags for beatmap {id}: {e}");
+                    ++failedCount;
+                }
+            }
+
+            completeNotification(notification, processedCount, beatmapIds.Count, failedCount);
+            config.SetValue(OsuSetting.LastOnlineTagsPopulation, metadataSourceFetchDate);
+        }
+
         private void updateNotificationProgress(ProgressNotification? notification, int processedCount, int totalCount)
         {
             if (notification == null)
diff --git a/osu.Game/Database/RealmAccess.cs b/osu.Game/Database/RealmAccess.cs
index 59cbfcb1e3..17f4068fc4 100644
--- a/osu.Game/Database/RealmAccess.cs
+++ b/osu.Game/Database/RealmAccess.cs
@@ -99,8 +99,10 @@ namespace osu.Game.Database
         /// 47   2025-01-21    Remove right mouse button binding for absolute scroll. Never use mouse buttons (or scroll) for global actions.
         /// 48   2025-03-19    Clear online status for all qualified beatmaps (some were stuck in a qualified state due to local caching issues).
         /// 49   2025-06-10    Reset the LegacyOnlineID to -1 for all scores that have it set to 0 (which is semantically the same) for consistency of handling with OnlineID.
+        /// 50   2025-07-11    Add UserTags to BeatmapMetadata.
+        /// 51   2025-07-22    Add ScoreInfo.Pauses.
         /// </summary>
-        private const int schema_version = 49;
+        private const int schema_version = 51;
 
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking realm retrieval during blocking periods.
diff --git a/osu.Game/Database/RealmArchiveModelImporter.cs b/osu.Game/Database/RealmArchiveModelImporter.cs
index a3cdc2dc77..0f9832578b 100644
--- a/osu.Game/Database/RealmArchiveModelImporter.cs
+++ b/osu.Game/Database/RealmArchiveModelImporter.cs
@@ -208,7 +208,16 @@ namespace osu.Game.Database
             foreach (var realmFile in model.Files)
             {
                 string sourcePath = Files.Storage.GetFullPath(realmFile.File.GetStoragePath());
-                string destinationPath = Path.Join(mountedPath, realmFile.Filename);
+                // there are edge cases where externalising an imported model to the filesystem could fail due to invalid filenames.
+                // one scenario where this happens goes something like this:
+                // - stable user exports an archive, which contains filenames that get mangled by stable's default zip encoding codepage (Shift-JIS)
+                // - said archive is imported to lazer, but the invalid filename is not actually an issue due to lazer file store structure
+                //   (the file is stored under a filename correspondent to its SHA instead, and its real filename is only stored in realm)
+                // - however attempts to externally edit the model fail as the external edit attempts and fails to produce the file's "real" filename in the mounted path
+                // to prevent this bricking external edit, strip invalid characters on external edit.
+                // the presumption here is that whatever produced the mangled archive is primarily at fault here, and we're just trying to trudge on locally as best as possible.
+                // if there are further troubles related to similar issues, reevaluate moving this sort of check to the import side instead (sanitising filenames on import from archive).
+                string destinationPath = Path.Join(mountedPath, realmFile.Filename.GetValidFilename());
 
                 Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
 
diff --git a/osu.Game/Database/RealmObjectExtensions.cs b/osu.Game/Database/RealmObjectExtensions.cs
index d43f90c292..2c4d36f7d0 100644
--- a/osu.Game/Database/RealmObjectExtensions.cs
+++ b/osu.Game/Database/RealmObjectExtensions.cs
@@ -10,6 +10,7 @@ using AutoMapper;
 using AutoMapper.Internal;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 using osu.Game.Input.Bindings;
 using osu.Game.Models;
 using osu.Game.Rulesets;
@@ -170,6 +171,7 @@ namespace osu.Game.Database
             });
 
             c.CreateMap<RealmKeyBinding, RealmKeyBinding>();
+            c.CreateMap<BeatmapCollection, BeatmapCollection>();
             c.CreateMap<BeatmapMetadata, BeatmapMetadata>();
             c.CreateMap<BeatmapUserSettings, BeatmapUserSettings>();
             c.CreateMap<BeatmapDifficulty, BeatmapDifficulty>();
diff --git a/osu.Game/Extensions/ModelExtensions.cs b/osu.Game/Extensions/ModelExtensions.cs
index 18c991297a..7c9d929999 100644
--- a/osu.Game/Extensions/ModelExtensions.cs
+++ b/osu.Game/Extensions/ModelExtensions.cs
@@ -175,6 +175,7 @@ namespace osu.Game.Extensions
         /// DO NOT CHANGE THE SEMANTICS OF THIS METHOD unless you know well what you are doing.
         /// </para>
         /// </remarks>
+        /// <seealso href="https://github.com/peppy/osu-stable-reference/blob/67795dba3c308e7d0493b296149dcb073ca47ecb/osu!common/Helpers/GeneralHelper.cs#L41-L46"/>
         public static string GetValidFilename(this string filename)
         {
             foreach (char c in invalid_filename_chars)
diff --git a/osu.Game/Graphics/Carousel/Carousel.cs b/osu.Game/Graphics/Carousel/Carousel.cs
index b0e2ad428e..0df183bb71 100644
--- a/osu.Game/Graphics/Carousel/Carousel.cs
+++ b/osu.Game/Graphics/Carousel/Carousel.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
@@ -17,14 +18,12 @@ using osu.Framework.Extensions.PolygonExtensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Layout;
 using osu.Framework.Logging;
 using osu.Framework.Utils;
-using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using osu.Game.Online.Multiplayer;
 using osuTK;
@@ -73,10 +72,15 @@ namespace osu.Game.Graphics.Carousel
         /// </summary>
         public bool IsFiltering => !filterTask.IsCompleted;
 
+        /// <summary>
+        /// Whether absolute scrolling is currently triggered.
+        /// </summary>
+        public bool AbsoluteScrolling => Scroll.AbsoluteScrolling;
+
         /// <summary>
         /// The number of times filter operations have been triggered.
         /// </summary>
-        internal int FilterCount { get; private set; }
+        public int FilterCount { get; private set; }
 
         /// <summary>
         /// The number of displayable items currently being tracked (before filtering).
@@ -103,7 +107,7 @@ namespace osu.Game.Graphics.Carousel
         /// The selection is never reset due to not existing. It can be set to anything.
         /// If no matching carousel item exists, there will be no visually selected item while waiting for potential new item which matches.
         /// </remarks>
-        public object? CurrentSelection
+        protected object? CurrentSelection
         {
             get => currentSelection.Model;
             set
@@ -115,14 +119,21 @@ namespace osu.Game.Graphics.Carousel
                     if (currentSelection.Model != null)
                         HandleItemDeselected(currentSelection.Model);
 
-                    currentKeyboardSelection = new Selection(value);
-                    currentSelection = currentKeyboardSelection;
+                    currentSelection = new Selection(value);
+                    currentKeyboardSelection = currentSelection;
                     selectionValid.Invalidate();
                 }
-                else if (currentKeyboardSelection.Model != value)
+
+                // Check keyboard selection equality separately.
+                //
+                // If current selection set to an already-selected value, we want to ensure
+                // that keyboard selection (which basically represents the "visual" tracking of selection)
+                // is still reset back to the newly set value.
+                //
+                // The main case this handles is when a set header is clicked and we want to make sure one of its
+                // "children" are re-selected.
+                if (!CheckModelEquality(currentKeyboardSelection.Model, value))
                 {
-                    // Even if the current selection matches, let's ensure the keyboard selection is reset
-                    // to the newly selected object. This matches user expectations (for now).
                     currentKeyboardSelection = currentSelection;
                     selectionValid.Invalidate();
                 }
@@ -200,6 +211,12 @@ namespace osu.Game.Graphics.Carousel
             return filterTask;
         }
 
+        /// <summary>
+        /// Called when <see cref="Items"/> changes in any way.
+        /// </summary>
+        /// <returns>Whether a re-filter is required.</returns>
+        protected virtual bool HandleItemsChanged(NotifyCollectionChangedEventArgs args) => true;
+
         /// <summary>
         /// Fired after a filter operation completed.
         /// </summary>
@@ -281,17 +298,21 @@ namespace osu.Game.Graphics.Carousel
 
         #region Initialisation
 
-        protected readonly CarouselScrollContainer Scroll;
+        protected readonly ScrollContainer Scroll;
 
         protected Carousel()
         {
-            InternalChild = Scroll = new CarouselScrollContainer
+            InternalChild = Scroll = new ScrollContainer
             {
                 Masking = false,
                 RelativeSizeAxes = Axes.Both,
             };
 
-            Items.BindCollectionChanged((_, _) => filterAfterItemsChanged.Invalidate());
+            Items.BindCollectionChanged((_, args) =>
+            {
+                if (HandleItemsChanged(args))
+                    filterAfterItemsChanged.Invalidate();
+            });
         }
 
         [BackgroundDependencyLoader]
@@ -307,7 +328,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;
 
@@ -347,11 +368,6 @@ namespace osu.Game.Graphics.Carousel
                     {
                         log($"Performing {filter.GetType().ReadableName()}");
                         items = await filter.Run(items, cts.Token).ConfigureAwait(false);
-
-                        // To avoid shooting ourselves in the foot, ensure that we manifest a list after each filter.
-                        //
-                        // A future improvement may be passing a reference list through each filter rather than copying each time,
-                        // but this is the safest approach.
                     }
 
                     log("Updating Y positions");
@@ -691,6 +707,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>
@@ -1024,166 +1045,6 @@ namespace osu.Game.Graphics.Carousel
             public static readonly DisplayRange EMPTY = new DisplayRange(-1, -1);
         }
 
-        /// <summary>
-        /// Implementation of scroll container which handles very large vertical lists by internally using <c>double</c> precision
-        /// for pre-display Y values.
-        /// </summary>
-        public partial class CarouselScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
-        {
-            public readonly Container Panels;
-
-            public void SetLayoutHeight(float height) => Panels.Height = height;
-
-            /// <summary>
-            /// Allow handling right click scroll outside of the carousel's display area.
-            /// </summary>
-            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
-
-            public CarouselScrollContainer()
-            {
-                // Managing our own custom layout within ScrollContent causes feedback with public ScrollContainer calculations,
-                // so we must maintain one level of separation from ScrollContent.
-                base.Add(Panels = new Container
-                {
-                    Name = "Layout content",
-                    RelativeSizeAxes = Axes.X,
-                });
-            }
-
-            public override void OffsetScrollPosition(double offset)
-            {
-                base.OffsetScrollPosition(offset);
-
-                foreach (var panel in Panels)
-                    ((ICarouselPanel)panel).DrawYPosition += offset;
-            }
-
-            public override void Clear(bool disposeChildren)
-            {
-                Panels.Height = 0;
-                Panels.Clear(disposeChildren);
-            }
-
-            public override void Add(Drawable drawable)
-            {
-                if (drawable is not ICarouselPanel)
-                    throw new InvalidOperationException($"Carousel panel drawables must implement {typeof(ICarouselPanel)}");
-
-                Panels.Add(drawable);
-            }
-
-            public override double GetChildPosInContent(Drawable d, Vector2 offset)
-            {
-                if (d is not ICarouselPanel panel)
-                    return base.GetChildPosInContent(d, offset);
-
-                return panel.DrawYPosition + offset.X;
-            }
-
-            protected override void ApplyCurrentToContent()
-            {
-                Debug.Assert(ScrollDirection == Direction.Vertical);
-
-                double scrollableExtent = -Current + ScrollableExtent * ScrollContent.RelativeAnchorPosition.Y;
-
-                foreach (var d in Panels)
-                    d.Y = (float)(((ICarouselPanel)d).DrawYPosition + scrollableExtent);
-            }
-
-            #region Scrollbar padding
-
-            public float ScrollbarPaddingTop { get; set; } = 5;
-            public float ScrollbarPaddingBottom { get; set; } = 5;
-
-            protected override float ToScrollbarPosition(double scrollPosition)
-            {
-                if (Precision.AlmostEquals(0, ScrollableExtent))
-                    return 0;
-
-                return (float)(ScrollbarPaddingTop + (ScrollbarMovementExtent - (ScrollbarPaddingTop + ScrollbarPaddingBottom)) * (scrollPosition / ScrollableExtent));
-            }
-
-            protected override float FromScrollbarPosition(float scrollbarPosition)
-            {
-                if (Precision.AlmostEquals(0, ScrollbarMovementExtent))
-                    return 0;
-
-                return (float)(ScrollableExtent * ((scrollbarPosition - ScrollbarPaddingTop) / (ScrollbarMovementExtent - (ScrollbarPaddingTop + ScrollbarPaddingBottom))));
-            }
-
-            #endregion
-
-            #region Absolute scrolling
-
-            private bool absoluteScrolling;
-
-            protected override bool IsDragging => base.IsDragging || absoluteScrolling;
-
-            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-            {
-                switch (e.Action)
-                {
-                    case GlobalAction.AbsoluteScrollSongList:
-                        beginAbsoluteScrolling(e);
-                        return true;
-                }
-
-                return false;
-            }
-
-            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
-            {
-                switch (e.Action)
-                {
-                    case GlobalAction.AbsoluteScrollSongList:
-                        endAbsoluteScrolling();
-                        break;
-                }
-            }
-
-            protected override bool OnMouseDown(MouseDownEvent e)
-            {
-                if (e.Button == MouseButton.Right)
-                {
-                    // To avoid conflicts with context menus, disallow absolute scroll if it looks like things will fall over.
-                    if (GetContainingInputManager()!.HoveredDrawables.OfType<IHasContextMenu>().Any())
-                        return false;
-
-                    beginAbsoluteScrolling(e);
-                }
-
-                return base.OnMouseDown(e);
-            }
-
-            protected override void OnMouseUp(MouseUpEvent e)
-            {
-                if (e.Button == MouseButton.Right)
-                    endAbsoluteScrolling();
-                base.OnMouseUp(e);
-            }
-
-            protected override bool OnMouseMove(MouseMoveEvent e)
-            {
-                if (absoluteScrolling)
-                {
-                    ScrollToAbsolutePosition(e.CurrentState.Mouse.Position);
-                    return true;
-                }
-
-                return base.OnMouseMove(e);
-            }
-
-            private void beginAbsoluteScrolling(UIEvent e)
-            {
-                ScrollToAbsolutePosition(e.CurrentState.Mouse.Position);
-                absoluteScrolling = true;
-            }
-
-            private void endAbsoluteScrolling() => absoluteScrolling = false;
-
-            #endregion
-        }
-
         #endregion
     }
 }
diff --git a/osu.Game/Graphics/Carousel/Carousel_ScrollContainer.cs b/osu.Game/Graphics/Carousel/Carousel_ScrollContainer.cs
new file mode 100644
index 0000000000..accd74aa4b
--- /dev/null
+++ b/osu.Game/Graphics/Carousel/Carousel_ScrollContainer.cs
@@ -0,0 +1,301 @@
+// 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.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Containers;
+using osu.Game.Input.Bindings;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Game.Graphics.Carousel
+{
+    /// <summary>
+    /// A highly efficient vertical list display that is used primarily for the song select screen,
+    /// but flexible enough to be used for other use cases.
+    /// </summary>
+    public abstract partial class Carousel<T> where T : notnull
+    {
+        /// <summary>
+        /// Implementation of scroll container which handles very large vertical lists by internally using <c>double</c> precision
+        /// for pre-display Y values.
+        /// </summary>
+        protected partial class ScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
+        {
+            public readonly Container Panels;
+
+            public void SetLayoutHeight(float height) => Panels.Height = height;
+
+            protected override ScrollbarContainer CreateScrollbar(Direction direction) => new ScrollBar();
+
+            /// <summary>
+            /// Allow handling right click scroll outside of the carousel's display area.
+            /// </summary>
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
+            public ScrollContainer()
+            {
+                // Managing our own custom layout within ScrollContent causes feedback with public ScrollContainer calculations,
+                // so we must maintain one level of separation from ScrollContent.
+                base.Add(Panels = new Container
+                {
+                    Name = "Layout content",
+                    RelativeSizeAxes = Axes.X,
+                });
+            }
+
+            public override void OffsetScrollPosition(double offset)
+            {
+                base.OffsetScrollPosition(offset);
+
+                foreach (var panel in Panels)
+                    ((ICarouselPanel)panel).DrawYPosition += offset;
+            }
+
+            public override void Clear(bool disposeChildren)
+            {
+                Panels.Height = 0;
+                Panels.Clear(disposeChildren);
+            }
+
+            public override void Add(Drawable drawable)
+            {
+                if (drawable is not ICarouselPanel)
+                    throw new InvalidOperationException($"Carousel panel drawables must implement {typeof(ICarouselPanel)}");
+
+                Panels.Add(drawable);
+            }
+
+            public override double GetChildPosInContent(Drawable d, Vector2 offset)
+            {
+                if (d is not ICarouselPanel panel)
+                    return base.GetChildPosInContent(d, offset);
+
+                return panel.DrawYPosition + offset.X;
+            }
+
+            protected override void ApplyCurrentToContent()
+            {
+                Debug.Assert(ScrollDirection == Direction.Vertical);
+
+                double scrollableExtent = -Current + ScrollableExtent * ScrollContent.RelativeAnchorPosition.Y;
+
+                foreach (var d in Panels)
+                    d.Y = (float)(((ICarouselPanel)d).DrawYPosition + scrollableExtent);
+            }
+
+            #region Scrollbar padding
+
+            public float ScrollbarPaddingTop { get; set; } = 5;
+            public float ScrollbarPaddingBottom { get; set; } = 5;
+
+            protected override float ToScrollbarPosition(double scrollPosition)
+            {
+                if (Precision.AlmostEquals(0, ScrollableExtent))
+                    return 0;
+
+                return (float)(ScrollbarPaddingTop + (ScrollbarMovementExtent - (ScrollbarPaddingTop + ScrollbarPaddingBottom)) * (scrollPosition / ScrollableExtent));
+            }
+
+            protected override float FromScrollbarPosition(float scrollbarPosition)
+            {
+                if (Precision.AlmostEquals(0, ScrollbarMovementExtent))
+                    return 0;
+
+                return (float)(ScrollableExtent * ((scrollbarPosition - ScrollbarPaddingTop) / (ScrollbarMovementExtent - (ScrollbarPaddingTop + ScrollbarPaddingBottom))));
+            }
+
+            #endregion
+
+            #region Absolute scrolling
+
+            /// <summary>
+            /// Whether absolute scrolling is currently triggered.
+            /// </summary>
+            public bool AbsoluteScrolling { get; private set; }
+
+            protected override bool IsDragging => base.IsDragging || AbsoluteScrolling;
+
+            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+            {
+                switch (e.Action)
+                {
+                    case GlobalAction.AbsoluteScrollSongList:
+                        beginAbsoluteScrolling(e);
+                        return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+            {
+                switch (e.Action)
+                {
+                    case GlobalAction.AbsoluteScrollSongList:
+                        endAbsoluteScrolling();
+                        break;
+                }
+            }
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                if (e.Button == MouseButton.Right)
+                {
+                    // To avoid conflicts with context menus, disallow absolute scroll if it looks like things will fall over.
+                    if (GetContainingInputManager()!.HoveredDrawables.OfType<IHasContextMenu>().Any())
+                        return false;
+
+                    beginAbsoluteScrolling(e);
+                }
+
+                return base.OnMouseDown(e);
+            }
+
+            protected override void OnMouseUp(MouseUpEvent e)
+            {
+                if (e.Button == MouseButton.Right)
+                    endAbsoluteScrolling();
+                base.OnMouseUp(e);
+            }
+
+            protected override bool OnMouseMove(MouseMoveEvent e)
+            {
+                if (AbsoluteScrolling)
+                {
+                    ScrollToAbsolutePosition(e.CurrentState.Mouse.Position);
+                    return true;
+                }
+
+                return base.OnMouseMove(e);
+            }
+
+            private void beginAbsoluteScrolling(UIEvent e)
+            {
+                ScrollToAbsolutePosition(e.CurrentState.Mouse.Position);
+                AbsoluteScrolling = true;
+            }
+
+            private void endAbsoluteScrolling() => AbsoluteScrolling = false;
+
+            #endregion
+
+            #region Scrollbar
+
+            private partial class ScrollBar : ScrollbarContainer
+            {
+                private Color4 hoverColour;
+                private Color4 defaultColour;
+                private Color4 highlightColour;
+
+                private readonly Drawable box;
+
+                protected override float MinimumDimSize => SCROLL_BAR_WIDTH * 3;
+
+                private const float expanded_size_ratio = 2;
+
+                public ScrollBar()
+                    : base(Direction.Vertical)
+                {
+                    Blending = BlendingParameters.Additive;
+
+                    // needs to be set initially for the ResizeTo to respect minimum size
+                    Size = new Vector2(SCROLL_BAR_WIDTH * expanded_size_ratio, SCROLL_BAR_WIDTH);
+
+                    const float margin = 3;
+
+                    Margin = new MarginPadding
+                    {
+                        Left = margin,
+                        Right = margin,
+                    };
+
+                    Child = box = new Circle
+                    {
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 1 / expanded_size_ratio,
+                    };
+                }
+
+                [BackgroundDependencyLoader(true)]
+                private void load(OverlayColourProvider? colourProvider, OsuColour colours)
+                {
+                    Colour = defaultColour = colours.Gray8;
+                    hoverColour = colours.GrayF;
+                    highlightColour = colourProvider?.Highlight1 ?? colours.Green;
+                }
+
+                public override void ResizeTo(float val, int duration = 0, Easing easing = Easing.None)
+                {
+                    this.ResizeTo(new Vector2(SCROLL_BAR_WIDTH * expanded_size_ratio)
+                    {
+                        [(int)ScrollDirection] = val
+                    }, duration, easing);
+                }
+
+                protected override bool OnHover(HoverEvent e)
+                {
+                    updateVisuals(e);
+                    return true;
+                }
+
+                protected override void OnHoverLost(HoverLostEvent e)
+                {
+                    updateVisuals(e);
+                }
+
+                protected override bool OnMouseDown(MouseDownEvent e)
+                {
+                    if (!base.OnMouseDown(e)) return false;
+
+                    updateVisuals(e);
+                    return true;
+                }
+
+                protected override void OnDragEnd(DragEndEvent e)
+                {
+                    updateVisuals(e);
+                    base.OnDragEnd(e);
+                }
+
+                protected override void OnMouseUp(MouseUpEvent e)
+                {
+                    if (e.Button != MouseButton.Left) return;
+
+                    updateVisuals(e);
+                    base.OnMouseUp(e);
+                }
+
+                private void updateVisuals(MouseEvent e)
+                {
+                    if (IsDragged || e.PressedButtons.Contains(MouseButton.Left))
+                        box.FadeColour(highlightColour, 100);
+                    else if (IsHovered)
+                        box.FadeColour(hoverColour, 100);
+                    else
+                        box.FadeColour(defaultColour, 100);
+
+                    if (IsHovered || IsDragged)
+                        box.ResizeWidthTo(1, 300, Easing.OutElasticHalf);
+                    else
+                        box.ResizeWidthTo(1 / expanded_size_ratio, 200, Easing.OutQuint);
+                }
+            }
+
+            #endregion
+        }
+    }
+}
diff --git a/osu.Game/Graphics/Carousel/ICarouselFilter.cs b/osu.Game/Graphics/Carousel/ICarouselFilter.cs
index a85b44b46a..a498c0ebc2 100644
--- a/osu.Game/Graphics/Carousel/ICarouselFilter.cs
+++ b/osu.Game/Graphics/Carousel/ICarouselFilter.cs
@@ -19,5 +19,10 @@ namespace osu.Game.Graphics.Carousel
         /// <param name="cancellationToken">A cancellation token.</param>
         /// <returns>The post-filtered items.</returns>
         Task<List<CarouselItem>> Run(IEnumerable<CarouselItem> items, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// The total number of beatmap difficulties displayed post filter.
+        /// </summary>
+        int BeatmapItemsCount { get; }
     }
 }
diff --git a/osu.Game/Graphics/Containers/ExpandingContainer.cs b/osu.Game/Graphics/Containers/ExpandingContainer.cs
index 4b70fd6987..65a00b725c 100644
--- a/osu.Game/Graphics/Containers/ExpandingContainer.cs
+++ b/osu.Game/Graphics/Containers/ExpandingContainer.cs
@@ -76,12 +76,6 @@ namespace osu.Game.Graphics.Containers
             return true;
         }
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
-        {
-            updateHoverExpansion();
-            return base.OnMouseMove(e);
-        }
-
         protected override void OnHoverLost(HoverLostEvent e)
         {
             if (hoverExpandEvent != null)
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/Graphics/InputBlockingContainer.cs b/osu.Game/Graphics/InputBlockingContainer.cs
index f652dc8850..dedf328642 100644
--- a/osu.Game/Graphics/InputBlockingContainer.cs
+++ b/osu.Game/Graphics/InputBlockingContainer.cs
@@ -8,6 +8,8 @@ namespace osu.Game.Graphics
 {
     /// <summary>
     /// A simple container which blocks input events from travelling through it.
+    ///
+    /// Note that this will block right clicks as well. Special care needs to be taken to not break context menus from displaying.
     /// </summary>
     public partial class InputBlockingContainer : Container
     {
diff --git a/osu.Game/Graphics/OsuIcon.cs b/osu.Game/Graphics/OsuIcon.cs
index 84ff86a5e5..3a8dfac826 100644
--- a/osu.Game/Graphics/OsuIcon.cs
+++ b/osu.Game/Graphics/OsuIcon.cs
@@ -81,27 +81,6 @@ namespace osu.Game.Graphics
         public static IconUsage InsaneMania => get(0xe027);
         public static IconUsage ExpertMania => get(0xe028);
 
-        // mod icons
-        public static IconUsage ModPerfect => get(0xe049);
-        public static IconUsage ModAutopilot => get(0xe03a);
-        public static IconUsage ModAuto => get(0xe03b);
-        public static IconUsage ModCinema => get(0xe03c);
-        public static IconUsage ModDoubleTime => get(0xe03d);
-        public static IconUsage ModEasy => get(0xe03e);
-        public static IconUsage ModFlashlight => get(0xe03f);
-        public static IconUsage ModHalftime => get(0xe040);
-        public static IconUsage ModHardRock => get(0xe041);
-        public static IconUsage ModHidden => get(0xe042);
-        public static IconUsage ModNightcore => get(0xe043);
-        public static IconUsage ModNoFail => get(0xe044);
-        public static IconUsage ModRelax => get(0xe045);
-        public static IconUsage ModSpunOut => get(0xe046);
-        public static IconUsage ModSuddenDeath => get(0xe047);
-        public static IconUsage ModTarget => get(0xe048);
-
-        // Use "Icons/BeatmapDetails/mod-icon" instead
-        // public static IconUsage ModBg => Get(0xe04a);
-
         #endregion
 
         #region New single-file-based icons
@@ -181,6 +160,88 @@ namespace osu.Game.Graphics
         public static IconUsage Tortoise => get(OsuIconMapping.Tortoise);
         public static IconUsage Hare => get(OsuIconMapping.Hare);
 
+        // mod icons
+
+        public static IconUsage ModNoMod => get(OsuIconMapping.ModNoMod);
+
+        /*
+         can be regenerated semi-automatically using osu-web's mod database via
+
+         $ jq -r '.[].Mods[].Name' mods.json | sort | uniq | \
+           sed 's/ //g' | \
+           awk '{print "public static IconUsage Mod" $0 " => get(OsuIconMapping.Mod" $0 ");"}' | pbcopy
+         */
+
+        public static IconUsage ModAccuracyChallenge => get(OsuIconMapping.ModAccuracyChallenge);
+        public static IconUsage ModAdaptiveSpeed => get(OsuIconMapping.ModAdaptiveSpeed);
+        public static IconUsage ModAlternate => get(OsuIconMapping.ModAlternate);
+        public static IconUsage ModApproachDifferent => get(OsuIconMapping.ModApproachDifferent);
+        public static IconUsage ModAutopilot => get(OsuIconMapping.ModAutopilot);
+        public static IconUsage ModAutoplay => get(OsuIconMapping.ModAutoplay);
+        public static IconUsage ModBarrelRoll => get(OsuIconMapping.ModBarrelRoll);
+        public static IconUsage ModBlinds => get(OsuIconMapping.ModBlinds);
+        public static IconUsage ModBloom => get(OsuIconMapping.ModBloom);
+        public static IconUsage ModBubbles => get(OsuIconMapping.ModBubbles);
+        public static IconUsage ModCinema => get(OsuIconMapping.ModCinema);
+        public static IconUsage ModClassic => get(OsuIconMapping.ModClassic);
+        public static IconUsage ModConstantSpeed => get(OsuIconMapping.ModConstantSpeed);
+        public static IconUsage ModCover => get(OsuIconMapping.ModCover);
+        public static IconUsage ModDaycore => get(OsuIconMapping.ModDaycore);
+        public static IconUsage ModDeflate => get(OsuIconMapping.ModDeflate);
+        public static IconUsage ModDepth => get(OsuIconMapping.ModDepth);
+        public static IconUsage ModDifficultyAdjust => get(OsuIconMapping.ModDifficultyAdjust);
+        public static IconUsage ModDoubleTime => get(OsuIconMapping.ModDoubleTime);
+        public static IconUsage ModDualStages => get(OsuIconMapping.ModDualStages);
+        public static IconUsage ModEasy => get(OsuIconMapping.ModEasy);
+        public static IconUsage ModEightKeys => get(OsuIconMapping.ModEightKeys);
+        public static IconUsage ModFadeIn => get(OsuIconMapping.ModFadeIn);
+        public static IconUsage ModFiveKeys => get(OsuIconMapping.ModFiveKeys);
+        public static IconUsage ModFlashlight => get(OsuIconMapping.ModFlashlight);
+        public static IconUsage ModFloatingFruits => get(OsuIconMapping.ModFloatingFruits);
+        public static IconUsage ModFourKeys => get(OsuIconMapping.ModFourKeys);
+        public static IconUsage ModFreezeFrame => get(OsuIconMapping.ModFreezeFrame);
+        public static IconUsage ModGrow => get(OsuIconMapping.ModGrow);
+        public static IconUsage ModHalfTime => get(OsuIconMapping.ModHalfTime);
+        public static IconUsage ModHardRock => get(OsuIconMapping.ModHardRock);
+        public static IconUsage ModHidden => get(OsuIconMapping.ModHidden);
+        public static IconUsage ModHoldOff => get(OsuIconMapping.ModHoldOff);
+        public static IconUsage ModInvert => get(OsuIconMapping.ModInvert);
+        public static IconUsage ModMagnetised => get(OsuIconMapping.ModMagnetised);
+        public static IconUsage ModMirror => get(OsuIconMapping.ModMirror);
+        public static IconUsage ModMovingFast => get(OsuIconMapping.ModMovingFast);
+        public static IconUsage ModMuted => get(OsuIconMapping.ModMuted);
+        public static IconUsage ModNightcore => get(OsuIconMapping.ModNightcore);
+        public static IconUsage ModNineKeys => get(OsuIconMapping.ModNineKeys);
+        public static IconUsage ModNoFail => get(OsuIconMapping.ModNoFail);
+        public static IconUsage ModNoRelease => get(OsuIconMapping.ModNoRelease);
+        public static IconUsage ModNoScope => get(OsuIconMapping.ModNoScope);
+        public static IconUsage ModOneKey => get(OsuIconMapping.ModOneKey);
+        public static IconUsage ModPerfect => get(OsuIconMapping.ModPerfect);
+        public static IconUsage ModRandom => get(OsuIconMapping.ModRandom);
+        public static IconUsage ModRelax => get(OsuIconMapping.ModRelax);
+        public static IconUsage ModRepel => get(OsuIconMapping.ModRepel);
+        public static IconUsage ModScoreV2 => get(OsuIconMapping.ModScoreV2);
+        public static IconUsage ModSevenKeys => get(OsuIconMapping.ModSevenKeys);
+        public static IconUsage ModSimplifiedRhythm => get(OsuIconMapping.ModSimplifiedRhythm);
+        public static IconUsage ModSingleTap => get(OsuIconMapping.ModSingleTap);
+        public static IconUsage ModSixKeys => get(OsuIconMapping.ModSixKeys);
+        public static IconUsage ModSpinIn => get(OsuIconMapping.ModSpinIn);
+        public static IconUsage ModSpunOut => get(OsuIconMapping.ModSpunOut);
+        public static IconUsage ModStrictTracking => get(OsuIconMapping.ModStrictTracking);
+        public static IconUsage ModSuddenDeath => get(OsuIconMapping.ModSuddenDeath);
+        public static IconUsage ModSwap => get(OsuIconMapping.ModSwap);
+        public static IconUsage ModSynesthesia => get(OsuIconMapping.ModSynesthesia);
+        public static IconUsage ModTargetPractice => get(OsuIconMapping.ModTargetPractice);
+        public static IconUsage ModTenKeys => get(OsuIconMapping.ModTenKeys);
+        public static IconUsage ModThreeKeys => get(OsuIconMapping.ModThreeKeys);
+        public static IconUsage ModTouchDevice => get(OsuIconMapping.ModTouchDevice);
+        public static IconUsage ModTraceable => get(OsuIconMapping.ModTraceable);
+        public static IconUsage ModTransform => get(OsuIconMapping.ModTransform);
+        public static IconUsage ModTwoKeys => get(OsuIconMapping.ModTwoKeys);
+        public static IconUsage ModWiggle => get(OsuIconMapping.ModWiggle);
+        public static IconUsage ModWindDown => get(OsuIconMapping.ModWindDown);
+        public static IconUsage ModWindUp => get(OsuIconMapping.ModWindUp);
+
         private static IconUsage get(OsuIconMapping glyph) => new IconUsage((char)glyph, FONT_NAME);
 
         private enum OsuIconMapping
@@ -400,6 +461,224 @@ namespace osu.Game.Graphics
 
             [Description(@"hare")]
             Hare,
+
+            // mod icons
+
+            [Description(@"Mods/mod-no-mod")]
+            ModNoMod,
+
+            /*
+             rest can be regenerated semi-automatically using osu-web's mod database via
+             $ jq -r '.[].Mods[].Name' mods.json | sort | uniq | \
+               awk '{kebab = $0; gsub(" ", "-", kebab); pascal = $0; gsub(" ", "", pascal); print "[Description(@\"Mods/mod-" tolower(kebab) "\")]\nMod" pascal ",\n" }' | pbcopy
+             */
+
+            [Description(@"Mods/mod-accuracy-challenge")]
+            ModAccuracyChallenge,
+
+            [Description(@"Mods/mod-adaptive-speed")]
+            ModAdaptiveSpeed,
+
+            [Description(@"Mods/mod-alternate")]
+            ModAlternate,
+
+            [Description(@"Mods/mod-approach-different")]
+            ModApproachDifferent,
+
+            [Description(@"Mods/mod-autopilot")]
+            ModAutopilot,
+
+            [Description(@"Mods/mod-autoplay")]
+            ModAutoplay,
+
+            [Description(@"Mods/mod-barrel-roll")]
+            ModBarrelRoll,
+
+            [Description(@"Mods/mod-blinds")]
+            ModBlinds,
+
+            [Description(@"Mods/mod-bloom")]
+            ModBloom,
+
+            [Description(@"Mods/mod-bubbles")]
+            ModBubbles,
+
+            [Description(@"Mods/mod-cinema")]
+            ModCinema,
+
+            [Description(@"Mods/mod-classic")]
+            ModClassic,
+
+            [Description(@"Mods/mod-constant-speed")]
+            ModConstantSpeed,
+
+            [Description(@"Mods/mod-cover")]
+            ModCover,
+
+            [Description(@"Mods/mod-daycore")]
+            ModDaycore,
+
+            [Description(@"Mods/mod-deflate")]
+            ModDeflate,
+
+            [Description(@"Mods/mod-depth")]
+            ModDepth,
+
+            [Description(@"Mods/mod-difficulty-adjust")]
+            ModDifficultyAdjust,
+
+            [Description(@"Mods/mod-double-time")]
+            ModDoubleTime,
+
+            [Description(@"Mods/mod-dual-stages")]
+            ModDualStages,
+
+            [Description(@"Mods/mod-easy")]
+            ModEasy,
+
+            [Description(@"Mods/mod-eight-keys")]
+            ModEightKeys,
+
+            [Description(@"Mods/mod-fade-in")]
+            ModFadeIn,
+
+            [Description(@"Mods/mod-five-keys")]
+            ModFiveKeys,
+
+            [Description(@"Mods/mod-flashlight")]
+            ModFlashlight,
+
+            [Description(@"Mods/mod-floating-fruits")]
+            ModFloatingFruits,
+
+            [Description(@"Mods/mod-four-keys")]
+            ModFourKeys,
+
+            [Description(@"Mods/mod-freeze-frame")]
+            ModFreezeFrame,
+
+            [Description(@"Mods/mod-grow")]
+            ModGrow,
+
+            [Description(@"Mods/mod-half-time")]
+            ModHalfTime,
+
+            [Description(@"Mods/mod-hard-rock")]
+            ModHardRock,
+
+            [Description(@"Mods/mod-hidden")]
+            ModHidden,
+
+            [Description(@"Mods/mod-hold-off")]
+            ModHoldOff,
+
+            [Description(@"Mods/mod-invert")]
+            ModInvert,
+
+            [Description(@"Mods/mod-magnetised")]
+            ModMagnetised,
+
+            [Description(@"Mods/mod-mirror")]
+            ModMirror,
+
+            [Description(@"Mods/mod-moving-fast")]
+            ModMovingFast,
+
+            [Description(@"Mods/mod-muted")]
+            ModMuted,
+
+            [Description(@"Mods/mod-nightcore")]
+            ModNightcore,
+
+            [Description(@"Mods/mod-nine-keys")]
+            ModNineKeys,
+
+            [Description(@"Mods/mod-no-fail")]
+            ModNoFail,
+
+            [Description(@"Mods/mod-no-release")]
+            ModNoRelease,
+
+            [Description(@"Mods/mod-no-scope")]
+            ModNoScope,
+
+            [Description(@"Mods/mod-one-key")]
+            ModOneKey,
+
+            [Description(@"Mods/mod-perfect")]
+            ModPerfect,
+
+            [Description(@"Mods/mod-random")]
+            ModRandom,
+
+            [Description(@"Mods/mod-relax")]
+            ModRelax,
+
+            [Description(@"Mods/mod-repel")]
+            ModRepel,
+
+            [Description(@"Mods/mod-score-v2")]
+            ModScoreV2,
+
+            [Description(@"Mods/mod-seven-keys")]
+            ModSevenKeys,
+
+            [Description(@"Mods/mod-simplified-rhythm")]
+            ModSimplifiedRhythm,
+
+            [Description(@"Mods/mod-single-tap")]
+            ModSingleTap,
+
+            [Description(@"Mods/mod-six-keys")]
+            ModSixKeys,
+
+            [Description(@"Mods/mod-spin-in")]
+            ModSpinIn,
+
+            [Description(@"Mods/mod-spun-out")]
+            ModSpunOut,
+
+            [Description(@"Mods/mod-strict-tracking")]
+            ModStrictTracking,
+
+            [Description(@"Mods/mod-sudden-death")]
+            ModSuddenDeath,
+
+            [Description(@"Mods/mod-swap")]
+            ModSwap,
+
+            [Description(@"Mods/mod-synesthesia")]
+            ModSynesthesia,
+
+            [Description(@"Mods/mod-target-practice")]
+            ModTargetPractice,
+
+            [Description(@"Mods/mod-ten-keys")]
+            ModTenKeys,
+
+            [Description(@"Mods/mod-three-keys")]
+            ModThreeKeys,
+
+            [Description(@"Mods/mod-touch-device")]
+            ModTouchDevice,
+
+            [Description(@"Mods/mod-traceable")]
+            ModTraceable,
+
+            [Description(@"Mods/mod-transform")]
+            ModTransform,
+
+            [Description(@"Mods/mod-two-keys")]
+            ModTwoKeys,
+
+            [Description(@"Mods/mod-wiggle")]
+            ModWiggle,
+
+            [Description(@"Mods/mod-wind-down")]
+            ModWindDown,
+
+            [Description(@"Mods/mod-wind-up")]
+            ModWindUp,
         }
 
         public class OsuIconStore : ITextureStore, ITexturedGlyphLookupStore
diff --git a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
index e6385072aa..e365e20ad5 100644
--- a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
@@ -236,8 +236,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 var hoveredColour = colourProvider.Light4;
                 var unhoveredColour = colourProvider.Background5;
 
-                Colour = Color4.White;
-                Alpha = Enabled.Value ? 1 : 0.3f;
+                Colour = Enabled.Value ? Color4.White : OsuColour.Gray(0.6f);
 
                 if (SearchBar.State.Value == Visibility.Visible)
                 {
diff --git a/osu.Game/Localisation/AudioSettingsStrings.cs b/osu.Game/Localisation/AudioSettingsStrings.cs
index 5c9e207f84..58caea7dd4 100644
--- a/osu.Game/Localisation/AudioSettingsStrings.cs
+++ b/osu.Game/Localisation/AudioSettingsStrings.cs
@@ -89,6 +89,16 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString OffsetWizard => new TranslatableString(getKey(@"offset_wizard"), @"Offset wizard");
 
+        /// <summary>
+        /// "Adjust beatmap offset automatically"
+        /// </summary>
+        public static LocalisableString AdjustBeatmapOffsetAutomatically => new TranslatableString(getKey(@"adjust_beatmap_offset_automatically"), @"Adjust beatmap offset automatically");
+
+        /// <summary>
+        /// "If enabled, the offset suggested from last play on a beatmap is automatically applied."
+        /// </summary>
+        public static LocalisableString AdjustBeatmapOffsetAutomaticallyTooltip => new TranslatableString(getKey(@"adjust_beatmap_offset_automatically_tooltip"), @"If enabled, the offset suggested from last play on a beatmap is automatically applied.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/BeatmapLeaderboardWedgeStrings.cs b/osu.Game/Localisation/BeatmapLeaderboardWedgeStrings.cs
new file mode 100644
index 0000000000..68c1920a1b
--- /dev/null
+++ b/osu.Game/Localisation/BeatmapLeaderboardWedgeStrings.cs
@@ -0,0 +1,74 @@
+// 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.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public class BeatmapLeaderboardWedgeStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.BeatmapLeaderboardWedge";
+
+        /// <summary>
+        /// "Scope"
+        /// </summary>
+        public static LocalisableString Scope => new TranslatableString(getKey(@"scope"), @"Scope");
+
+        /// <summary>
+        /// "Local"
+        /// </summary>
+        public static LocalisableString Local => new TranslatableString(getKey(@"local"), @"Local");
+
+        /// <summary>
+        /// "Global"
+        /// </summary>
+        public static LocalisableString Global => new TranslatableString(getKey(@"global"), @"Global");
+
+        /// <summary>
+        /// "Country"
+        /// </summary>
+        public static LocalisableString Country => new TranslatableString(getKey(@"country"), @"Country");
+
+        /// <summary>
+        /// "Friend"
+        /// </summary>
+        public static LocalisableString Friend => new TranslatableString(getKey(@"friend"), @"Friend");
+
+        /// <summary>
+        /// "Team"
+        /// </summary>
+        public static LocalisableString Team => new TranslatableString(getKey(@"team"), @"Team");
+
+        /// <summary>
+        /// "Sort"
+        /// </summary>
+        public static LocalisableString Sort => new TranslatableString(getKey(@"sort"), @"Sort");
+
+        /// <summary>
+        /// "Score"
+        /// </summary>
+        public static LocalisableString Score => new TranslatableString(getKey(@"score"), @"Score");
+
+        /// <summary>
+        /// "Accuracy"
+        /// </summary>
+        public static LocalisableString Accuracy => new TranslatableString(getKey(@"accuracy"), @"Accuracy");
+
+        /// <summary>
+        /// "Max Combo"
+        /// </summary>
+        public static LocalisableString MaxCombo => new TranslatableString(getKey(@"max_combo"), @"Max Combo");
+
+        /// <summary>
+        /// "Misses"
+        /// </summary>
+        public static LocalisableString Misses => new TranslatableString(getKey(@"misses"), @"Misses");
+
+        /// <summary>
+        /// "Date"
+        /// </summary>
+        public static LocalisableString Date => new TranslatableString(getKey(@"date"), @"Date");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/osu.Game/Localisation/CollectionsStrings.cs b/osu.Game/Localisation/CollectionsStrings.cs
new file mode 100644
index 0000000000..f096dd9570
--- /dev/null
+++ b/osu.Game/Localisation/CollectionsStrings.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.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public class CollectionsStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.Collections";
+
+        /// <summary>
+        /// "Manage Collections"
+        /// </summary>
+        public static LocalisableString ManageCollectionsTitle => new TranslatableString(getKey(@"manage_collections_title"), @"Manage Collections");
+
+        /// <summary>
+        /// "Collection"
+        /// </summary>
+        public static LocalisableString Collection => new TranslatableString(getKey(@"collection"), @"Collection");
+
+        /// <summary>
+        /// "All beatmaps"
+        /// </summary>
+        public static LocalisableString AllBeatmaps => new TranslatableString(getKey(@"all_beatmaps"), @"All beatmaps");
+
+        /// <summary>
+        /// "Manage collections..."
+        /// </summary>
+        public static LocalisableString ManageCollections => new TranslatableString(getKey(@"manage_collections"), @"Manage collections...");
+
+        /// <summary>
+        /// "Create a new collection"
+        /// </summary>
+        public static LocalisableString CreateNew => new TranslatableString(getKey(@"create_new"), @"Create a new collection");
+
+        /// <summary>
+        /// "Remove selected beatmap"
+        /// </summary>
+        public static LocalisableString RemoveSelectedBeatmap => new TranslatableString(getKey(@"remove_selected_beatmap"), @"Remove selected beatmap");
+
+        /// <summary>
+        /// "Add selected beatmap"
+        /// </summary>
+        public static LocalisableString AddSelectedBeatmap => new TranslatableString(getKey(@"add_selected_beatmap"), @"Add selected beatmap");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/osu.Game/Localisation/CommonStrings.cs b/osu.Game/Localisation/CommonStrings.cs
index f9d0feb5e2..9009785f1c 100644
--- a/osu.Game/Localisation/CommonStrings.cs
+++ b/osu.Game/Localisation/CommonStrings.cs
@@ -184,6 +184,16 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString CopyLink => new TranslatableString(getKey(@"copy_link"), @"Copy link");
 
+        /// <summary>
+        /// "Manage..."
+        /// </summary>
+        public static LocalisableString Manage => new TranslatableString(getKey(@"manage"), @"Manage...");
+
+        /// <summary>
+        /// "Details..."
+        /// </summary>
+        public static LocalisableString Details => new TranslatableString(getKey(@"details"), @"Details...");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
-}
\ No newline at end of file
+}
diff --git a/osu.Game/Localisation/EditorStrings.cs b/osu.Game/Localisation/EditorStrings.cs
index eeccdc8e8a..c8b163c678 100644
--- a/osu.Game/Localisation/EditorStrings.cs
+++ b/osu.Game/Localisation/EditorStrings.cs
@@ -209,6 +209,16 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString OpenDiscussionPage => new TranslatableString(getKey(@"open_discussion_page"), @"Open beatmap discussion page");
 
+        /// <summary>
+        /// "Current difficulty"
+        /// </summary>
+        public static LocalisableString CheckCurrentDifficulty => new TranslatableString(getKey(@"check_current_difficulty"), @"Current difficulty");
+
+        /// <summary>
+        /// "Entire beatmap set"
+        /// </summary>
+        public static LocalisableString CheckEntireBeatmapSet => new TranslatableString(getKey(@"check_entire_beatmap_set"), @"Entire beatmap set");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
index 9c484a5cb0..8536249d35 100644
--- a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
+++ b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
@@ -345,9 +345,9 @@ namespace osu.Game.Localisation
         public static LocalisableString SeekReplayBackward => new TranslatableString(getKey(@"seek_replay_backward"), @"Seek replay backward");
 
         /// <summary>
-        /// "Seek replay forward one frame"
+        /// "Step replay forward one frame"
         /// </summary>
-        public static LocalisableString StepReplayForward => new TranslatableString(getKey(@"step_replay_forward"), @"Seek replay forward one frame");
+        public static LocalisableString StepReplayForward => new TranslatableString(getKey(@"step_replay_forward"), @"Step replay forward one frame");
 
         /// <summary>
         /// "Step replay backward one frame"
diff --git a/osu.Game/Localisation/HUD/AimErrorMeterStrings.cs b/osu.Game/Localisation/HUD/AimErrorMeterStrings.cs
new file mode 100644
index 0000000000..31d81d41e3
--- /dev/null
+++ b/osu.Game/Localisation/HUD/AimErrorMeterStrings.cs
@@ -0,0 +1,74 @@
+// 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.Localisation;
+
+namespace osu.Game.Localisation.HUD
+{
+    public static class AimErrorMeterStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.HUD.AimErrorMeterStrings";
+
+        /// <summary>
+        /// "Hit marker size"
+        /// </summary>
+        public static LocalisableString HitMarkerSize => new TranslatableString(getKey(@"hit_marker_size"), @"Hit marker size");
+
+        /// <summary>
+        /// "Controls the size of the markers displayed after every hit."
+        /// </summary>
+        public static LocalisableString HitMarkerSizeDescription => new TranslatableString(getKey(@"hit_marker_size_description"), @"Controls the size of the markers displayed after every hit.");
+
+        /// <summary>
+        /// "Hit marker style"
+        /// </summary>
+        public static LocalisableString HitMarkerStyle => new TranslatableString(getKey(@"hit_marker_style"), @"Hit marker style");
+
+        /// <summary>
+        /// "The visual style of the hit markers."
+        /// </summary>
+        public static LocalisableString HitMarkerStyleDescription => new TranslatableString(getKey(@"hit_marker_style_description"), @"The visual style of the hit markers.");
+
+        /// <summary>
+        /// "Average position marker size"
+        /// </summary>
+        public static LocalisableString AverageMarkerSize => new TranslatableString(getKey(@"average_marker_size"), @"Average position marker size");
+
+        /// <summary>
+        /// "Controls the size of the marker showing average hit position."
+        /// </summary>
+        public static LocalisableString AverageMarkerSizeDescription => new TranslatableString(getKey(@"average_marker_size_description"), @"Controls the size of the marker showing average hit position.");
+
+        /// <summary>
+        /// "Average position marker style"
+        /// </summary>
+        public static LocalisableString AverageMarkerStyle => new TranslatableString(getKey(@"average_marker_style"), @"Average position marker style");
+
+        /// <summary>
+        /// "The visual style of the average position marker."
+        /// </summary>
+        public static LocalisableString AverageMarkerStyleDescription => new TranslatableString(getKey(@"average_marker_style_description"), @"The visual style of the average position marker.");
+
+        /// <summary>
+        /// "Position display style"
+        /// </summary>
+        public static LocalisableString PositionDisplayStyle => new TranslatableString(getKey(@"position_style"), @"Position display style");
+
+        /// <summary>
+        /// "Controls whether positions displayed on the meter are absolute (as seen on screen) or normalised (relative to the direction of movement from previous object)."
+        /// </summary>
+        public static LocalisableString PositionDisplayStyleDescription => new TranslatableString(getKey(@"position_style_description"), @"Controls whether positions displayed on the meter are absolute (as seen on screen) or normalised (relative to the direction of movement from previous object).");
+
+        /// <summary>
+        /// "Absolute"
+        /// </summary>
+        public static LocalisableString Absolute => new TranslatableString(getKey(@"absolute"), @"Absolute");
+
+        /// <summary>
+        /// "Normalised"
+        /// </summary>
+        public static LocalisableString Normalised => new TranslatableString(getKey(@"normalised"), @"Normalised");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/osu.Game/Localisation/MenuTipStrings.cs b/osu.Game/Localisation/MenuTipStrings.cs
index 4d1f2ceaa6..ebab9f4d02 100644
--- a/osu.Game/Localisation/MenuTipStrings.cs
+++ b/osu.Game/Localisation/MenuTipStrings.cs
@@ -154,6 +154,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString RightMouseAbsoluteScroll => new TranslatableString(getKey(@"right_mouse_absolute_scroll"), @"Try holding your right mouse button near the beatmap carousel to quickly scroll to an absolute position!");
 
+        /// <summary>
+        /// "Shift-click on a beatmap panel in the beatmap listing overlay to quickly download or view the beatmap in song select!"
+        /// </summary>
+        public static LocalisableString ShiftClickInBeatmapOverlay => new TranslatableString(getKey(@"shift_click_in_beatmap_overlay"), @"Shift-click on a beatmap panel in the beatmap listing overlay to quickly download or view the beatmap in song select!");
+
         /// <summary>
         /// "a tip for you:"
         /// </summary>
diff --git a/osu.Game/Localisation/NotificationsStrings.cs b/osu.Game/Localisation/NotificationsStrings.cs
index 3614ed9133..66250d1629 100644
--- a/osu.Game/Localisation/NotificationsStrings.cs
+++ b/osu.Game/Localisation/NotificationsStrings.cs
@@ -83,16 +83,6 @@ Please try changing your audio device to a working setting.");
         /// </summary>
         public static LocalisableString LinkTypeNotSupported => new TranslatableString(getKey(@"unsupported_link_type"), @"This link type is not yet supported!");
 
-        /// <summary>
-        /// "You received a private message from &#39;{0}&#39;. Click to read it!"
-        /// </summary>
-        public static LocalisableString PrivateMessageReceived(string username) => new TranslatableString(getKey(@"private_message_received"), @"You received a private message from '{0}'. Click to read it!", username);
-
-        /// <summary>
-        /// "Your name was mentioned in chat by &#39;{0}&#39;. Click to find out why!"
-        /// </summary>
-        public static LocalisableString YourNameWasMentioned(string username) => new TranslatableString(getKey(@"your_name_was_mentioned"), @"Your name was mentioned in chat by '{0}'. Click to find out why!", username);
-
         /// <summary>
         /// "{0} invited you to the multiplayer match &quot;{1}&quot;! Click to join."
         /// </summary>
@@ -140,6 +130,11 @@ Click to see what's new!", version);
         /// </summary>
         public static LocalisableString MultiplayerRoomEnded => new TranslatableString(getKey(@"multiplayer_room_ended"), @"This multiplayer room has ended. Click to display room results.");
 
+        /// <summary>
+        /// "Mention"
+        /// </summary>
+        public static LocalisableString Mention => new TranslatableString(getKey(@"mention"), @"Mention");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/ReplayFailIndicatorStrings.cs b/osu.Game/Localisation/ReplayFailIndicatorStrings.cs
new file mode 100644
index 0000000000..f4507a1d96
--- /dev/null
+++ b/osu.Game/Localisation/ReplayFailIndicatorStrings.cs
@@ -0,0 +1,24 @@
+// 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.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public static class ReplayFailIndicatorStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.ReplayFailIndicator";
+
+        /// <summary>
+        /// "Replay failed"
+        /// </summary>
+        public static LocalisableString ReplayFailed => new TranslatableString(getKey(@"replay_failed"), @"Replay failed");
+
+        /// <summary>
+        /// "Go to results"
+        /// </summary>
+        public static LocalisableString GoToResults => new TranslatableString(getKey(@"go_to_results"), @"Go to results");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
\ No newline at end of file
diff --git a/osu.Game/Localisation/RulesetSettingsStrings.cs b/osu.Game/Localisation/RulesetSettingsStrings.cs
index fc4fb58e26..891da585d8 100644
--- a/osu.Game/Localisation/RulesetSettingsStrings.cs
+++ b/osu.Game/Localisation/RulesetSettingsStrings.cs
@@ -95,9 +95,14 @@ namespace osu.Game.Localisation
         public static LocalisableString MobileLayout => new TranslatableString(getKey(@"mobile_layout"), @"Mobile layout");
 
         /// <summary>
-        /// "Portrait (expanded columns)"
+        /// "Portrait"
         /// </summary>
-        public static LocalisableString PortraitExpandedColumns => new TranslatableString(getKey(@"portrait_expanded_columns"), @"Portrait (expanded columns)");
+        public static LocalisableString Portrait => new TranslatableString(getKey(@"portrait"), @"Portrait");
+
+        /// <summary>
+        /// "Landscape"
+        /// </summary>
+        public static LocalisableString Landscape => new TranslatableString(getKey(@"landscape"), @"Landscape");
 
         /// <summary>
         /// "Landscape (expanded columns)"
@@ -105,9 +110,9 @@ namespace osu.Game.Localisation
         public static LocalisableString LandscapeExpandedColumns => new TranslatableString(getKey(@"landscape_expanded_columns"), @"Landscape (expanded columns)");
 
         /// <summary>
-        /// "Landscape (touch overlay)"
+        /// "Touch overlay"
         /// </summary>
-        public static LocalisableString LandscapeTouchOverlay => new TranslatableString(getKey(@"landscape_touch_overlay"), @"Landscape (touch overlay)");
+        public static LocalisableString TouchOverlay => new TranslatableString(getKey(@"touch_overlay"), @"Touch overlay");
 
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
diff --git a/osu.Game/Localisation/SongSelectStrings.cs b/osu.Game/Localisation/SongSelectStrings.cs
index 055caccc87..71bf15360e 100644
--- a/osu.Game/Localisation/SongSelectStrings.cs
+++ b/osu.Game/Localisation/SongSelectStrings.cs
@@ -9,6 +9,26 @@ namespace osu.Game.Localisation
     {
         private const string prefix = @"osu.Game.Resources.Localisation.SongSelect";
 
+        /// <summary>
+        /// "Mods"
+        /// </summary>
+        public static LocalisableString Mods => new TranslatableString(getKey(@"mods"), @"Mods");
+
+        /// <summary>
+        /// "Random"
+        /// </summary>
+        public static LocalisableString Random => new TranslatableString(getKey(@"random"), @"Random");
+
+        /// <summary>
+        /// "Rewind"
+        /// </summary>
+        public static LocalisableString Rewind => new TranslatableString(getKey(@"rewind"), @"Rewind");
+
+        /// <summary>
+        /// "Options"
+        /// </summary>
+        public static LocalisableString Options => new TranslatableString(getKey(@"options"), @"Options");
+
         /// <summary>
         /// "Local"
         /// </summary>
@@ -20,39 +40,19 @@ namespace osu.Game.Localisation
         public static LocalisableString LocallyModifiedTooltip => new TranslatableString(getKey(@"locally_modified_tooltip"), @"Has been locally modified");
 
         /// <summary>
-        /// "Manage collections"
+        /// "Unknown"
         /// </summary>
-        public static LocalisableString ManageCollections => new TranslatableString(getKey(@"manage_collections"), @"Manage collections");
+        public static LocalisableString StatusUnknown => new TranslatableString(getKey(@"status_unknown"), @"Unknown");
 
         /// <summary>
-        /// "For all difficulties"
+        /// "Total Plays"
         /// </summary>
-        public static LocalisableString ForAllDifficulties => new TranslatableString(getKey(@"for_all_difficulties"), @"For all difficulties");
+        public static LocalisableString TotalPlays => new TranslatableString(getKey(@"total_plays"), @"Total Plays");
 
         /// <summary>
-        /// "Delete beatmap"
+        /// "Personal Plays"
         /// </summary>
-        public static LocalisableString DeleteBeatmap => new TranslatableString(getKey(@"delete_beatmap"), @"Delete beatmap");
-
-        /// <summary>
-        /// "For selected difficulty"
-        /// </summary>
-        public static LocalisableString ForSelectedDifficulty => new TranslatableString(getKey(@"for_selected_difficulty"), @"For selected difficulty");
-
-        /// <summary>
-        /// "Mark as played"
-        /// </summary>
-        public static LocalisableString MarkAsPlayed => new TranslatableString(getKey(@"mark_as_played"), @"Mark as played");
-
-        /// <summary>
-        /// "Clear all local scores"
-        /// </summary>
-        public static LocalisableString ClearAllLocalScores => new TranslatableString(getKey(@"clear_all_local_scores"), @"Clear all local scores");
-
-        /// <summary>
-        /// "Edit beatmap"
-        /// </summary>
-        public static LocalisableString EditBeatmap => new TranslatableString(getKey(@"edit_beatmap"), @"Edit beatmap");
+        public static LocalisableString PersonalPlays => new TranslatableString(getKey(@"personal_plays"), @"Personal Plays");
 
         /// <summary>
         /// "Circle Size"
@@ -79,6 +79,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString HPDrain => new TranslatableString(getKey(@"hp_drain"), @"HP Drain");
 
+        /// <summary>
+        /// "Scroll Speed"
+        /// </summary>
+        public static LocalisableString ScrollSpeed => new TranslatableString(getKey(@"scroll_speed"), @"Scroll Speed");
+
         /// <summary>
         /// "Submitted"
         /// </summary>
@@ -89,11 +94,166 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString Ranked => new TranslatableString(getKey(@"ranked"), @"Ranked");
 
+        /// <summary>
+        /// "Details"
+        /// </summary>
+        public static LocalisableString Details => new TranslatableString(getKey(@"details"), @"Details");
+
+        /// <summary>
+        /// "Ranking"
+        /// </summary>
+        public static LocalisableString Ranking => new TranslatableString(getKey(@"ranking"), @"Ranking");
+
+        /// <summary>
+        /// "Use these mods"
+        /// </summary>
+        public static LocalisableString UseTheseMods => new TranslatableString(getKey(@"use_these_mods"), @"Use these mods");
+
+        /// <summary>
+        /// "For all difficulties"
+        /// </summary>
+        public static LocalisableString ForAllDifficulties => new TranslatableString(getKey(@"for_all_difficulties"), @"For all difficulties");
+
+        /// <summary>
+        /// "For selected difficulty"
+        /// </summary>
+        public static LocalisableString ForSelectedDifficulty => new TranslatableString(getKey(@"for_selected_difficulty"), @"For selected difficulty");
+
+        /// <summary>
+        /// "Update beatmap with online changes"
+        /// </summary>
+        public static LocalisableString UpdateBeatmapTooltip => new TranslatableString(getKey(@"update_beatmap_tooltip"), @"Update beatmap with online changes");
+
+        /// <summary>
+        /// "Mark as played"
+        /// </summary>
+        public static LocalisableString MarkAsPlayed => new TranslatableString(getKey(@"mark_as_played"), @"Mark as played");
+
+        /// <summary>
+        /// "Clear all local scores"
+        /// </summary>
+        public static LocalisableString ClearAllLocalScores => new TranslatableString(getKey(@"clear_all_local_scores"), @"Clear all local scores");
+
+        /// <summary>
+        /// "Delete beatmap"
+        /// </summary>
+        public static LocalisableString DeleteBeatmap => new TranslatableString(getKey(@"delete_beatmap"), @"Delete beatmap");
+
+        /// <summary>
+        /// "Restore all hidden"
+        /// </summary>
+        public static LocalisableString RestoreAllHidden => new TranslatableString(getKey(@"restore_all_hidden"), @"Restore all hidden");
+
         /// <summary>
         /// "{0} stars"
         /// </summary>
         public static LocalisableString Stars(LocalisableString value) => new TranslatableString(getKey(@"stars"), @"{0} stars", value);
 
+        /// <summary>
+        /// "Sort"
+        /// </summary>
+        public static LocalisableString Sort => new TranslatableString(getKey(@"sort"), @"Sort");
+
+        /// <summary>
+        /// "Group"
+        /// </summary>
+        public static LocalisableString Group => new TranslatableString(getKey(@"group"), @"Group");
+
+        /// <summary>
+        /// "None"
+        /// </summary>
+        public static LocalisableString None => new TranslatableString(getKey(@"none"), @"None");
+
+        /// <summary>
+        /// "Title"
+        /// </summary>
+        public static LocalisableString Title => new TranslatableString(getKey(@"title"), @"Title");
+
+        /// <summary>
+        /// "Artist"
+        /// </summary>
+        public static LocalisableString Artist => new TranslatableString(getKey(@"artist"), @"Artist");
+
+        /// <summary>
+        /// "Author"
+        /// </summary>
+        public static LocalisableString Author => new TranslatableString(getKey(@"author"), @"Author");
+
+        /// <summary>
+        /// "BPM"
+        /// </summary>
+        public static LocalisableString BPM => new TranslatableString(getKey(@"bpm"), @"BPM");
+
+        /// <summary>
+        /// "Date Submitted"
+        /// </summary>
+        public static LocalisableString DateSubmitted => new TranslatableString(getKey(@"date_submitted"), @"Date Submitted");
+
+        /// <summary>
+        /// "Date Ranked"
+        /// </summary>
+        public static LocalisableString DateRanked => new TranslatableString(getKey(@"date_ranked"), @"Date Ranked");
+
+        /// <summary>
+        /// "Date Added"
+        /// </summary>
+        public static LocalisableString DateAdded => new TranslatableString(getKey(@"date_added"), @"Date Added");
+
+        /// <summary>
+        /// "Last Played"
+        /// </summary>
+        public static LocalisableString LastPlayed => new TranslatableString(getKey(@"last_played"), @"Last Played");
+
+        /// <summary>
+        /// "Difficulty"
+        /// </summary>
+        public static LocalisableString Difficulty => new TranslatableString(getKey(@"difficulty"), @"Difficulty");
+
+        /// <summary>
+        /// "Length"
+        /// </summary>
+        public static LocalisableString Length => new TranslatableString(getKey(@"length"), @"Length");
+
+        /// <summary>
+        /// "Favourites"
+        /// </summary>
+        public static LocalisableString Favourites => new TranslatableString(getKey(@"favourites"), @"Favourites");
+
+        /// <summary>
+        /// "My Maps"
+        /// </summary>
+        public static LocalisableString MyMaps => new TranslatableString(getKey(@"my_maps"), @"My Maps");
+
+        /// <summary>
+        /// "Collections"
+        /// </summary>
+        public static LocalisableString Collections => new TranslatableString(getKey(@"collections"), @"Collections");
+
+        /// <summary>
+        /// "Rank Achieved"
+        /// </summary>
+        public static LocalisableString RankAchieved => new TranslatableString(getKey(@"rank_achieved"), @"Rank Achieved");
+
+        /// <summary>
+        /// "Ranked Status"
+        /// </summary>
+        public static LocalisableString RankedStatus => new TranslatableString(getKey(@"ranked_status"), @"Ranked Status");
+
+        /// <summary>
+        /// "Source"
+        /// </summary>
+        public static LocalisableString Source => new TranslatableString(getKey(@"source"), @"Source");
+
+        /// <summary>
+        /// "No matching beatmaps"
+        /// </summary>
+        public static LocalisableString NoMatchingBeatmaps => new TranslatableString(getKey(@"no_matching_beatmaps"), @"No matching beatmaps");
+
+        /// <summary>
+        /// "No beatmaps match your filter criteria!"
+        /// </summary>
+        public static LocalisableString NoMatchingBeatmapsDescription => new TranslatableString(getKey(@"no_matching_beatmaps_description"), @"No beatmaps match your filter criteria!");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/UserInterfaceStrings.cs b/osu.Game/Localisation/UserInterfaceStrings.cs
index 95d0a4a9ec..7fbccf1919 100644
--- a/osu.Game/Localisation/UserInterfaceStrings.cs
+++ b/osu.Game/Localisation/UserInterfaceStrings.cs
@@ -164,6 +164,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString TrueRandom => new TranslatableString(getKey(@"true_random"), @"True Random");
 
+        /// <summary>
+        /// "Selected Mods"
+        /// </summary>
+        public static LocalisableString SelectedMods => new TranslatableString(getKey(@"selected_mods"), @"Selected Mods");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Online/API/APIAccess.cs b/osu.Game/Online/API/APIAccess.cs
index 525eb98a86..54eed58c13 100644
--- a/osu.Game/Online/API/APIAccess.cs
+++ b/osu.Game/Online/API/APIAccess.cs
@@ -409,8 +409,8 @@ namespace osu.Game.Online.API
             SecondFactorCode = code;
         }
 
-        public IHubClientConnector GetHubConnector(string clientName, string endpoint, bool preferMessagePack) =>
-            new HubClientConnector(clientName, endpoint, this, versionHash, preferMessagePack);
+        public IHubClientConnector GetHubConnector(string clientName, string endpoint) =>
+            new HubClientConnector(clientName, endpoint, this, versionHash);
 
         public IChatClient GetChatClient() => new WebSocketChatClient(this);
 
diff --git a/osu.Game/Online/API/DummyAPIAccess.cs b/osu.Game/Online/API/DummyAPIAccess.cs
index 0c2ed9903c..74e0ca2873 100644
--- a/osu.Game/Online/API/DummyAPIAccess.cs
+++ b/osu.Game/Online/API/DummyAPIAccess.cs
@@ -185,7 +185,7 @@ namespace osu.Game.Online.API
         {
         }
 
-        public IHubClientConnector? GetHubConnector(string clientName, string endpoint, bool preferMessagePack) => null;
+        public IHubClientConnector? GetHubConnector(string clientName, string endpoint) => null;
 
         public IChatClient GetChatClient() => new TestChatClientConnector(this);
 
diff --git a/osu.Game/Online/API/IAPIProvider.cs b/osu.Game/Online/API/IAPIProvider.cs
index 3ab985e41f..2634ea137f 100644
--- a/osu.Game/Online/API/IAPIProvider.cs
+++ b/osu.Game/Online/API/IAPIProvider.cs
@@ -138,8 +138,7 @@ namespace osu.Game.Online.API
         /// </summary>
         /// <param name="clientName">The name of the client this connector connects for, used for logging.</param>
         /// <param name="endpoint">The endpoint to the hub.</param>
-        /// <param name="preferMessagePack">Whether to use MessagePack for serialisation if available on this platform.</param>
-        IHubClientConnector? GetHubConnector(string clientName, string endpoint, bool preferMessagePack = true);
+        IHubClientConnector? GetHubConnector(string clientName, string endpoint);
 
         /// <summary>
         /// Accesses the <see cref="INotificationsClient"/> used to receive asynchronous notifications from web.
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/API/Requests/Responses/SoloScoreInfo.cs b/osu.Game/Online/API/Requests/Responses/SoloScoreInfo.cs
index da4122c434..58c819f391 100644
--- a/osu.Game/Online/API/Requests/Responses/SoloScoreInfo.cs
+++ b/osu.Game/Online/API/Requests/Responses/SoloScoreInfo.cs
@@ -87,6 +87,9 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty("legacy_score_id")]
         public ulong? LegacyScoreId { get; set; }
 
+        [JsonProperty("pauses")]
+        public int[] Pauses { get; set; } = [];
+
         #region osu-web API additions (not stored to database).
 
         [JsonProperty("id")]
@@ -260,6 +263,7 @@ namespace osu.Game.Online.API.Requests.Responses
             Mods = score.APIMods,
             Statistics = score.Statistics.Where(kvp => kvp.Value != 0).ToDictionary(),
             MaximumStatistics = score.MaximumStatistics.Where(kvp => kvp.Value != 0).ToDictionary(),
+            Pauses = score.Pauses.ToArray(),
         };
     }
 }
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/Chat/MessageNotifier.cs b/osu.Game/Online/Chat/MessageNotifier.cs
index 49304c93a3..4e17a5e28a 100644
--- a/osu.Game/Online/Chat/MessageNotifier.cs
+++ b/osu.Game/Online/Chat/MessageNotifier.cs
@@ -8,18 +8,20 @@ using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using System.Text.RegularExpressions;
+using Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
-using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Online.Chat
 {
@@ -136,59 +138,105 @@ namespace osu.Game.Online.Chat
 
         private void checkForMentions(Channel channel, Message message)
         {
-            if (!notifyOnUsername.Value || !CheckContainsUsername(message.Content, localUser.Value.Username)) return;
+            if (!notifyOnUsername.Value)
+                return;
 
-            notifications.Post(new MentionNotification(message, channel));
+            var match = MatchUsername(message.Content, localUser.Value.Username);
+            if (!match.Success)
+                return;
+
+            notifications.Post(new MentionNotification(message, channel, match));
         }
 
         /// <summary>
         /// Checks if <paramref name="message"/> mentions <paramref name="username"/>.
         /// This will match against the case where underscores are used instead of spaces (which is how osu-stable handles usernames with spaces).
         /// </summary>
-        public static bool CheckContainsUsername(string message, string username)
+        public static Match MatchUsername(string message, string username)
         {
             string fullName = Regex.Escape(username);
             string underscoreName = Regex.Escape(username.Replace(' ', '_'));
-            return Regex.IsMatch(message, $@"(^|\W)({fullName}|{underscoreName})($|\W)", RegexOptions.IgnoreCase);
+            return Regex.Match(message, $@"(^|\W)({fullName}|{underscoreName})($|\W)", RegexOptions.IgnoreCase);
         }
 
-        public partial class PrivateMessageNotification : HighlightMessageNotification
+        private const int truncate_length = 60;
+
+        public partial class PrivateMessageNotification : UserAvatarNotification
         {
+            private readonly Message message;
+            private readonly Channel channel;
+
             public PrivateMessageNotification(Message message, Channel channel)
-                : base(message, channel)
-            {
-                Icon = FontAwesome.Solid.Envelope;
-                Text = NotificationsStrings.PrivateMessageReceived(message.Sender.Username);
-            }
-        }
-
-        public partial class MentionNotification : HighlightMessageNotification
-        {
-            public MentionNotification(Message message, Channel channel)
-                : base(message, channel)
-            {
-                Icon = FontAwesome.Solid.At;
-                Text = NotificationsStrings.YourNameWasMentioned(message.Sender.Username);
-            }
-        }
-
-        public abstract partial class HighlightMessageNotification : SimpleNotification
-        {
-            public override string PopInSampleName => "UI/notification-mention";
-
-            protected HighlightMessageNotification(Message message, Channel channel)
+                : base(message.Sender)
             {
                 this.message = message;
                 this.channel = channel;
             }
 
+            [BackgroundDependencyLoader]
+            private void load(ChatOverlay chatOverlay, INotificationOverlay notificationOverlay, OverlayColourProvider colourProvider)
+            {
+                TextFlow.AddText(NotificationsStrings.ItemChannelChannelDefault.ToUpper(), s => s.Font = OsuFont.Style.Caption2.With(weight: FontWeight.Bold));
+                TextFlow.NewLine();
+                TextFlow.AddText($"{message.Sender.Username}", s =>
+                {
+                    s.Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold);
+                    s.Colour = colourProvider.Content2;
+                });
+                TextFlow.AddParagraph($"\"{message.Content.Truncate(truncate_length)}\"");
+
+                Avatar.Colour = OsuColour.Gray(0.4f);
+                Icon = FontAwesome.Solid.Comments;
+
+                Activated = delegate
+                {
+                    notificationOverlay.Hide();
+                    chatOverlay.HighlightMessage(message, channel);
+                    return true;
+                };
+            }
+        }
+
+        public partial class MentionNotification : UserAvatarNotification
+        {
+            public override string PopInSampleName => "UI/notification-mention";
+
             private readonly Message message;
             private readonly Channel channel;
+            private readonly Match match;
+
+            public MentionNotification(Message message, Channel channel, Match match)
+                : base(message.Sender)
+            {
+                this.message = message;
+                this.channel = channel;
+                this.match = match;
+            }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours, ChatOverlay chatOverlay, INotificationOverlay notificationOverlay)
+            private void load(ChatOverlay chatOverlay, INotificationOverlay notificationOverlay, OverlayColourProvider colourProvider)
             {
-                IconContent.Colour = colours.PurpleDark;
+                TextFlow.AddText(Localisation.NotificationsStrings.Mention.ToUpper(), s => s.Font = OsuFont.Style.Caption2.With(weight: FontWeight.Bold));
+                TextFlow.NewLine();
+                TextFlow.AddText($"{message.Sender.Username} in {channel.Name}", s =>
+                {
+                    s.Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold);
+                    s.Colour = colourProvider.Content2;
+                });
+
+                int start = match.Index;
+                int end = match.Index + match.Length;
+
+                TextFlow.AddParagraph($"\"{message.Content[..start].Truncate(truncate_length / 2, "…", from: TruncateFrom.Left)}");
+                TextFlow.AddText(message.Content[start..end], s =>
+                {
+                    s.Font = s.Font.With(weight: FontWeight.SemiBold);
+                    s.Colour = colourProvider.Colour0;
+                });
+                TextFlow.AddText($"{message.Content[end..].Truncate(truncate_length / 2, "…", from: TruncateFrom.Right)}\"");
+
+                Avatar.Colour = OsuColour.Gray(0.4f);
+                Icon = FontAwesome.Solid.At;
 
                 Activated = delegate
                 {
diff --git a/osu.Game/Online/FriendPresenceNotifier.cs b/osu.Game/Online/FriendPresenceNotifier.cs
index a73c705d76..0ab8fb205a 100644
--- a/osu.Game/Online/FriendPresenceNotifier.cs
+++ b/osu.Game/Online/FriendPresenceNotifier.cs
@@ -6,6 +6,7 @@ using System.Collections.Specialized;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Configuration;
@@ -17,6 +18,7 @@ using osu.Game.Online.Metadata;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Users;
+using osuTK.Graphics;
 
 namespace osu.Game.Online
 {
@@ -182,52 +184,67 @@ namespace osu.Game.Online
             lastOfflineAlertTime = null;
         }
 
-        public partial class FriendOnlineNotification : SimpleNotification
+        public partial class FriendOnlineNotification : UserAvatarNotification
         {
             private readonly ICollection<APIUser> users;
 
             public FriendOnlineNotification(ICollection<APIUser> users)
+                : base(users.Count == 1 ? users.Single() : null)
             {
                 this.users = users;
+
                 Transient = true;
                 IsImportant = false;
-                Icon = FontAwesome.Solid.User;
                 Text = $"Online: {string.Join(@", ", users.Select(u => u.Username))}";
             }
 
             [BackgroundDependencyLoader]
             private void load(OsuColour colours, ChannelManager channelManager, ChatOverlay chatOverlay)
             {
-                IconColour = colours.GrayD;
-                Activated = () =>
+                if (users.Count > 1)
                 {
-                    APIUser? singleUser = users.Count == 1 ? users.Single() : null;
-
-                    if (singleUser != null)
+                    Icon = FontAwesome.Solid.User;
+                    IconColour = colours.GrayD;
+                }
+                else
+                {
+                    Activated = () =>
                     {
-                        channelManager.OpenPrivateChannel(singleUser);
+                        channelManager.OpenPrivateChannel(users.Single());
                         chatOverlay.Show();
-                    }
 
-                    return true;
-                };
+                        return true;
+                    };
+                }
             }
 
             public override string PopInSampleName => "UI/notification-friend-online";
         }
 
-        private partial class FriendOfflineNotification : SimpleNotification
+        public partial class FriendOfflineNotification : UserAvatarNotification
         {
+            private readonly ICollection<APIUser> users;
+
             public FriendOfflineNotification(ICollection<APIUser> users)
+                : base(users.Count == 1 ? users.Single() : null)
             {
+                this.users = users;
+
                 Transient = true;
                 IsImportant = false;
-                Icon = FontAwesome.Solid.UserSlash;
                 Text = $"Offline: {string.Join(@", ", users.Select(u => u.Username))}";
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours) => IconColour = colours.Gray3;
+            private void load(OsuColour colours)
+            {
+                Icon = FontAwesome.Solid.UserSlash;
+
+                if (users.Count == 1)
+                    Avatar.Colour = Color4.White.Opacity(0.25f);
+                else
+                    IconColour = colours.Gray3;
+            }
 
             public override string PopInSampleName => "UI/notification-friend-offline";
         }
diff --git a/osu.Game/Online/HubClientConnector.cs b/osu.Game/Online/HubClientConnector.cs
index 9288a32052..e6391e8810 100644
--- a/osu.Game/Online/HubClientConnector.cs
+++ b/osu.Game/Online/HubClientConnector.cs
@@ -2,14 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Net;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.Extensions.DependencyInjection;
-using Newtonsoft.Json;
 using osu.Framework;
 using osu.Game.Online.API;
 
@@ -29,7 +26,6 @@ namespace osu.Game.Online
 
         private readonly string endpoint;
         private readonly string versionHash;
-        private readonly bool preferMessagePack;
 
         /// <summary>
         /// The current connection opened by this connector.
@@ -43,14 +39,12 @@ namespace osu.Game.Online
         /// <param name="endpoint">The endpoint to the hub.</param>
         /// <param name="api"> An API provider used to react to connection state changes.</param>
         /// <param name="versionHash">The hash representing the current game version, used for verification purposes.</param>
-        /// <param name="preferMessagePack">Whether to use MessagePack for serialisation if available on this platform.</param>
-        public HubClientConnector(string clientName, string endpoint, IAPIProvider api, string versionHash, bool preferMessagePack = true)
+        public HubClientConnector(string clientName, string endpoint, IAPIProvider api, string versionHash)
             : base(api)
         {
             ClientName = clientName;
             this.endpoint = endpoint;
             this.versionHash = versionHash;
-            this.preferMessagePack = preferMessagePack;
 
             // Automatically start these connections.
             Start();
@@ -78,26 +72,10 @@ namespace osu.Game.Online
                     options.Headers.Add(CLIENT_SESSION_ID_HEADER, API.SessionIdentifier.ToString());
                 });
 
-            if (RuntimeFeature.IsDynamicCodeCompiled && preferMessagePack)
+            builder.AddMessagePackProtocol(options =>
             {
-                builder.AddMessagePackProtocol(options =>
-                {
-                    options.SerializerOptions = SignalRUnionWorkaroundResolver.OPTIONS;
-                });
-            }
-            else
-            {
-                // eventually we will precompile resolvers for messagepack, but this isn't working currently
-                // see https://github.com/neuecc/MessagePack-CSharp/issues/780#issuecomment-768794308.
-                builder.AddNewtonsoftJsonProtocol(options =>
-                {
-                    options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
-                    options.PayloadSerializerSettings.Converters = new List<JsonConverter>
-                    {
-                        new SignalRDerivedTypeWorkaroundJsonConverter(),
-                    };
-                });
-            }
+                options.SerializerOptions = SignalRUnionWorkaroundResolver.OPTIONS;
+            });
 
             var newConnection = builder.Build();
 
diff --git a/osu.Game/Online/Leaderboards/LeaderboardManager.cs b/osu.Game/Online/Leaderboards/LeaderboardManager.cs
index d5d1672e1b..632771afc1 100644
--- a/osu.Game/Online/Leaderboards/LeaderboardManager.cs
+++ b/osu.Game/Online/Leaderboards/LeaderboardManager.cs
@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
@@ -24,7 +25,11 @@ namespace osu.Game.Online.Leaderboards
 {
     public partial class LeaderboardManager : Component
     {
+        /// <summary>
+        /// The latest leaderboard scores fetched by the criteria in <see cref="CurrentCriteria"/>.
+        /// </summary>
         public IBindable<LeaderboardScores?> Scores => scores;
+
         private readonly Bindable<LeaderboardScores?> scores = new Bindable<LeaderboardScores?>();
 
         public LeaderboardCriteria? CurrentCriteria { get; private set; }
@@ -47,6 +52,9 @@ namespace osu.Game.Online.Leaderboards
         /// </summary>
         public void FetchWithCriteria(LeaderboardCriteria newCriteria, bool forceRefresh = false)
         {
+            if (!ThreadSafety.IsUpdateThread)
+                throw new InvalidOperationException(@$"{nameof(FetchWithCriteria)} must be called from the update thread.");
+
             if (!forceRefresh && CurrentCriteria?.Equals(newCriteria) == true && scores.Value?.FailState == null)
                 return;
 
@@ -76,6 +84,9 @@ namespace osu.Game.Online.Leaderboards
 
                 default:
                 {
+                    if (newCriteria.Sorting != LeaderboardSortMode.Score)
+                        throw new NotSupportedException($@"Requesting online scores with a {nameof(LeaderboardSortMode)} other than {nameof(LeaderboardSortMode.Score)} is not supported");
+
                     if (!api.IsLoggedIn)
                     {
                         scores.Value = LeaderboardScores.Failure(LeaderboardFailState.NotLoggedIn);
@@ -180,18 +191,26 @@ namespace osu.Game.Online.Leaderboards
                 }
             }
 
-            newScores = newScores.Detach().OrderByTotalScore();
+            newScores = newScores.Detach().OrderByCriteria(CurrentCriteria.Sorting);
 
             var newScoresArray = newScores.ToArray();
             scores.Value = LeaderboardScores.Success(newScoresArray, newScoresArray.Length, null);
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            localScoreSubscription?.Dispose();
+        }
     }
 
     public record LeaderboardCriteria(
         BeatmapInfo? Beatmap,
         RulesetInfo? Ruleset,
         BeatmapLeaderboardScope Scope,
-        Mod[]? ExactMods
+        Mod[]? ExactMods,
+        LeaderboardSortMode Sorting = LeaderboardSortMode.Score
     );
 
     public record LeaderboardScores
diff --git a/osu.Game/Online/Leaderboards/UpdateableRank.cs b/osu.Game/Online/Leaderboards/UpdateableRank.cs
index b64fab6861..ea5a985ef7 100644
--- a/osu.Game/Online/Leaderboards/UpdateableRank.cs
+++ b/osu.Game/Online/Leaderboards/UpdateableRank.cs
@@ -11,7 +11,9 @@ namespace osu.Game.Online.Leaderboards
 {
     public partial class UpdateableRank : ModelBackedDrawable<ScoreRank?>
     {
-        protected override double TransformDuration => 600;
+        private readonly bool animate;
+
+        protected override double TransformDuration => animate ? 600 : 0;
         protected override bool TransformImmediately => true;
 
         public ScoreRank? Rank
@@ -20,8 +22,10 @@ namespace osu.Game.Online.Leaderboards
             set => Model = value;
         }
 
-        public UpdateableRank(ScoreRank? rank = null)
+        public UpdateableRank(ScoreRank? rank = null, bool animate = true)
         {
+            this.animate = animate;
+
             Rank = rank;
         }
 
@@ -58,7 +62,6 @@ namespace osu.Game.Online.Leaderboards
         protected override TransformSequence<Drawable> ApplyHideTransforms(Drawable drawable)
         {
             drawable.ScaleTo(1.8f, TransformDuration, Easing.Out);
-
             return base.ApplyHideTransforms(drawable);
         }
     }
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/Matchmaking/IMatchmakingClient.cs b/osu.Game/Online/Matchmaking/IMatchmakingClient.cs
new file mode 100644
index 0000000000..70e1ce0b5d
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/IMatchmakingClient.cs
@@ -0,0 +1,53 @@
+// 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.Threading.Tasks;
+
+namespace osu.Game.Online.Matchmaking
+{
+    public interface IMatchmakingClient : IStatefulUserHubClient
+    {
+        /// <summary>
+        /// Signals that the local user was placed in the matchmaking queue.
+        /// </summary>
+        Task MatchmakingQueueJoined();
+
+        /// <summary>
+        /// Signals that the local user was removed from the matchmaking queue.
+        /// </summary>
+        Task MatchmakingQueueLeft();
+
+        /// <summary>
+        /// Signals that a match has been found and the local user is invited to it.
+        /// The invitation may be <see cref="IMatchmakingServer.MatchmakingAcceptInvitation">accepted</see>,
+        /// <see cref="IMatchmakingServer.MatchmakingDeclineInvitation">declined</see>,
+        /// or ignored - in which case it will automatically be declined after a short timeout period.
+        /// </summary>
+        Task MatchmakingRoomInvited();
+
+        /// <summary>
+        /// Signals that the matchmaking room is ready to be opened.
+        /// </summary>
+        Task MatchmakingRoomReady(long roomId, string password);
+
+        /// <summary>
+        /// The matchmaking lobby status has changed.
+        /// </summary>
+        Task MatchmakingLobbyStatusChanged(MatchmakingLobbyStatus status);
+
+        /// <summary>
+        /// The matchmaking status of the current user has changed.
+        /// </summary>
+        Task MatchmakingQueueStatusChanged(MatchmakingQueueStatus status);
+
+        /// <summary>
+        /// The user has raised a candidate playlist item to be played.
+        /// </summary>
+        Task MatchmakingItemSelected(int userId, long playlistItemId);
+
+        /// <summary>
+        /// The user has removed a candidate playlist item.
+        /// </summary>
+        Task MatchmakingItemDeselected(int userId, long playlistItemId);
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/IMatchmakingServer.cs b/osu.Game/Online/Matchmaking/IMatchmakingServer.cs
new file mode 100644
index 0000000000..66fd8c36da
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/IMatchmakingServer.cs
@@ -0,0 +1,56 @@
+// 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.Threading.Tasks;
+
+namespace osu.Game.Online.Matchmaking
+{
+    public interface IMatchmakingServer
+    {
+        /// <summary>
+        /// Retrieves all active matchmaking pools.
+        /// </summary>
+        Task<MatchmakingPool[]> GetMatchmakingPools();
+
+        /// <summary>
+        /// Joins the matchmaking lobby, allowing the local user to receive status updates.
+        /// </summary>
+        Task MatchmakingJoinLobby();
+
+        /// <summary>
+        /// Leaves the matchmaking lobby.
+        /// </summary>
+        Task MatchmakingLeaveLobby();
+
+        /// <summary>
+        /// Joins the matchmaking queue, allowing the local user to get matched up with others.
+        /// </summary>
+        Task MatchmakingJoinQueue(int poolId);
+
+        /// <summary>
+        /// Leaves the matchmaking queue.
+        /// </summary>
+        Task MatchmakingLeaveQueue();
+
+        /// <summary>
+        /// Accepts a matchmaking room invitation.
+        /// </summary>
+        Task MatchmakingAcceptInvitation();
+
+        /// <summary>
+        /// Declines a matchmaking room invitation.
+        /// </summary>
+        Task MatchmakingDeclineInvitation();
+
+        /// <summary>
+        /// Raise a candidate playlist item to be played in the current round.
+        /// </summary>
+        /// <param name="playlistItemId">The playlist item.</param>
+        Task MatchmakingToggleSelection(long playlistItemId);
+
+        /// <summary>
+        /// Debug only - skips to the next stage of the matchmaking room.
+        /// </summary>
+        Task MatchmakingSkipToNextStage();
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs b/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs
new file mode 100644
index 0000000000..9a1e083b84
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs
@@ -0,0 +1,16 @@
+// 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 MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingLobbyStatus
+    {
+        [Key(0)]
+        public int[] UsersInQueue { get; set; } = [];
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingPool.cs b/osu.Game/Online/Matchmaking/MatchmakingPool.cs
new file mode 100644
index 0000000000..3f256d5251
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingPool.cs
@@ -0,0 +1,39 @@
+// 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.Diagnostics.CodeAnalysis;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MatchmakingPool : IEquatable<MatchmakingPool>
+    {
+        [Key(0)]
+        public int Id { get; set; }
+
+        [Key(1)]
+        public int RulesetId { get; set; }
+
+        [Key(2)]
+        public int Variant { get; set; }
+
+        [Key(3)]
+        public string Name { get; set; } = string.Empty;
+
+        public bool Equals(MatchmakingPool? other)
+            => other != null
+               && Id == other.Id
+               && RulesetId == other.RulesetId
+               && Variant == other.Variant
+               && Name == other.Name;
+
+        public override bool Equals(object? obj)
+            => obj is MatchmakingPool other && Equals(other);
+
+        [SuppressMessage("ReSharper", "NonReadonlyMemberInGetHashCode")]
+        public override int GetHashCode() => HashCode.Combine(Id, RulesetId, Variant, Name);
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs b/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs
new file mode 100644
index 0000000000..a57e04bd10
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs
@@ -0,0 +1,34 @@
+// 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 MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [Serializable]
+    [MessagePackObject]
+    [Union(0, typeof(Searching))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(1, typeof(MatchFound))]
+    [Union(2, typeof(JoiningMatch))]
+    public abstract class MatchmakingQueueStatus
+    {
+        [Serializable]
+        [MessagePackObject]
+        public class Searching : MatchmakingQueueStatus
+        {
+        }
+
+        [Serializable]
+        [MessagePackObject]
+        public class MatchFound : MatchmakingQueueStatus
+        {
+        }
+
+        [Serializable]
+        [MessagePackObject]
+        public class JoiningMatch : MatchmakingQueueStatus
+        {
+        }
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs b/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs
new file mode 100644
index 0000000000..8df1bb000a
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs
@@ -0,0 +1,16 @@
+// 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 MessagePack;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [MessagePackObject]
+    public class MatchmakingStageCountdown : MultiplayerCountdown
+    {
+        [Key(2)]
+        public MatchmakingStage Stage { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Metadata/OnlineMetadataClient.cs b/osu.Game/Online/Metadata/OnlineMetadataClient.cs
index 6637fc8dba..6402962e85 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
@@ -55,7 +56,7 @@ namespace osu.Game.Online.Metadata
         {
             // Importantly, we are intentionally not using MessagePack here to correctly support derived class serialization.
             // More information on the limitations / reasoning can be found in osu-server-spectator's initialisation code.
-            connector = api.GetHubConnector(nameof(OnlineMetadataClient), endpoint, false);
+            connector = api.GetHubConnector(nameof(OnlineMetadataClient), endpoint);
 
             if (connector != null)
             {
@@ -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/Multiplayer/MatchRoomState.cs b/osu.Game/Online/Multiplayer/MatchRoomState.cs
index cae3aaf7d0..25de8c7fab 100644
--- a/osu.Game/Online/Multiplayer/MatchRoomState.cs
+++ b/osu.Game/Online/Multiplayer/MatchRoomState.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 
 namespace osu.Game.Online.Multiplayer
@@ -14,6 +15,7 @@ namespace osu.Game.Online.Multiplayer
     [Serializable]
     [MessagePackObject]
     [Union(0, typeof(TeamVersusRoomState))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(1, typeof(MatchmakingRoomState))]
     public abstract class MatchRoomState
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs
new file mode 100644
index 0000000000..9e1953fc59
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs
@@ -0,0 +1,101 @@
+// 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.Linq;
+using MessagePack;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the state of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRoomState : MatchRoomState
+    {
+        /// <summary>
+        /// The current room status.
+        /// </summary>
+        [Key(0)]
+        public MatchmakingStage Stage { get; set; }
+
+        /// <summary>
+        /// The current round number (1-based).
+        /// </summary>
+        [Key(1)]
+        public int CurrentRound { get; set; }
+
+        /// <summary>
+        /// The playlist items that were picked as gameplay candidates.
+        /// </summary>
+        [Key(2)]
+        public long[] CandidateItems { get; set; } = [];
+
+        /// <summary>
+        /// The final gameplay candidate.
+        /// </summary>
+        [Key(3)]
+        public long CandidateItem { get; set; }
+
+        /// <summary>
+        /// The users in the room.
+        /// </summary>
+        [Key(4)]
+        public MatchmakingUserList Users { get; set; } = new MatchmakingUserList();
+
+        /// <summary>
+        /// Advances to the next round.
+        /// </summary>
+        public void AdvanceRound()
+        {
+            CurrentRound++;
+        }
+
+        /// <summary>
+        /// Sets scores for the current round, applying points and adjusting user placements.
+        /// </summary>
+        /// <remarks>
+        /// When applying points:
+        /// <list type="bullet">
+        ///   <item>Matching scores are considered to be placed in the lower-equal (e.g. two equal top scores are considered "equal-second").</item>
+        ///   <item>Failed scores are considered to have passed the map.</item>
+        ///   <item>Missing scores are not considered.</item>
+        /// </list>
+        /// </remarks>
+        /// <param name="scores">The scores to apply.</param>
+        /// <param name="placementPoints">The number of points to award for each placement position (0-indexed). Must be at least of equal length to <paramref name="scores"/>.</param>
+        public void RecordScores(SoloScoreInfo[] scores, int[] placementPoints)
+        {
+            if (placementPoints.Length < scores.Length)
+                throw new ArgumentException($"{nameof(placementPoints)} must be at least of equal length to {nameof(scores)}.");
+
+            SoloScoreInfo[] orderedScores = scores.OrderByDescending(s => s.TotalScore).ToArray();
+
+            int placement = 0;
+
+            foreach (var scoreGroup in orderedScores.GroupBy(s => s.TotalScore))
+            {
+                placement += scoreGroup.Count();
+
+                foreach (var score in scoreGroup)
+                {
+                    MatchmakingUser mmUser = Users[score.UserID];
+                    mmUser.Points += placementPoints[placement - 1];
+
+                    MatchmakingRound mmRound = mmUser.Rounds[CurrentRound];
+                    mmRound.Placement = placement;
+                    mmRound.TotalScore = score.TotalScore;
+                    mmRound.Accuracy = score.Accuracy;
+                    mmRound.MaxCombo = score.MaxCombo;
+                    mmRound.Statistics = score.Statistics;
+                }
+            }
+
+            int i = 1;
+            foreach (var user in Users.Order(new MatchmakingUserComparer(CurrentRound)))
+                user.Placement = i++;
+        }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.cs
new file mode 100644
index 0000000000..6a9d595ab5
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.cs
@@ -0,0 +1,54 @@
+// 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 MessagePack;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes a user's score for a round of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRound
+    {
+        /// <summary>
+        /// The round.
+        /// </summary>
+        [Key(0)]
+        public required int Round { get; set; }
+
+        /// <summary>
+        /// The user's placement in this round (1-based).
+        /// </summary>
+        [Key(1)]
+        public int Placement { get; set; }
+
+        /// <summary>
+        /// The achieved total score.
+        /// </summary>
+        [Key(2)]
+        public long TotalScore { get; set; }
+
+        /// <summary>
+        /// The achieved accuracy.
+        /// </summary>
+        [Key(3)]
+        public double Accuracy { get; set; }
+
+        /// <summary>
+        /// The achieved maximum combo.
+        /// </summary>
+        [Key(4)]
+        public int MaxCombo { get; set; }
+
+        /// <summary>
+        /// The achieved score statistics.
+        /// </summary>
+        [Key(5)]
+        public IDictionary<HitResult, int> Statistics { get; set; } = new Dictionary<HitResult, int>();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.cs
new file mode 100644
index 0000000000..c34d1771f8
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.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 System;
+using System.Collections;
+using System.Collections.Generic;
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the per-round scores of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRoundList : IEnumerable<MatchmakingRound>
+    {
+        /// <summary>
+        /// A key-value-pair mapping of rounds to scores.
+        /// </summary>
+        [Key(0)]
+        public IDictionary<int, MatchmakingRound> RoundsDictionary { get; set; } = new Dictionary<int, MatchmakingRound>();
+
+        /// <summary>
+        /// Creates or retrieves the score for the given round.
+        /// </summary>
+        /// <param name="round">The round.</param>
+        public MatchmakingRound this[int round]
+        {
+            get
+            {
+                if (RoundsDictionary.TryGetValue(round, out MatchmakingRound? score))
+                    return score;
+
+                return RoundsDictionary[round] = new MatchmakingRound { Round = round };
+            }
+        }
+
+        /// <summary>
+        /// The total number of rounds.
+        /// </summary>
+        [IgnoreMember]
+        public int Count => RoundsDictionary.Count;
+
+        public IEnumerator<MatchmakingRound> GetEnumerator() => RoundsDictionary.Values.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs
new file mode 100644
index 0000000000..edffa4ec23
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs
@@ -0,0 +1,59 @@
+// 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;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the current status of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    public enum MatchmakingStage
+    {
+        /// <summary>
+        /// The initial state of a room. Users are still joining.
+        /// </summary>
+        WaitingForClientsJoin,
+
+        /// <summary>
+        /// A short delay before the round begins.
+        /// </summary>
+        RoundWarmupTime,
+
+        /// <summary>
+        /// Users are given a chance to lock in their beatmap picks.
+        /// </summary>
+        UserBeatmapSelect,
+
+        /// <summary>
+        /// Clients have sent their picks, and the server has responded with the finalised beatmap.
+        /// </summary>
+        ServerBeatmapFinalised,
+
+        /// <summary>
+        /// Clients are given an opportunity to download the beatmap.
+        /// </summary>
+        WaitingForClientsBeatmapDownload,
+
+        /// <summary>
+        /// A short delay before gameplay starts.
+        /// </summary>
+        GameplayWarmupTime,
+
+        /// <summary>
+        /// Gameplay is ongoing.
+        /// </summary>
+        Gameplay,
+
+        /// <summary>
+        /// Gameplay has finished, results are being displayed.
+        /// </summary>
+        ResultsDisplaying,
+
+        /// <summary>
+        /// All rounds have completed. Users may still be chatting.
+        /// </summary>
+        Ended
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs
new file mode 100644
index 0000000000..f596f2473e
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs
@@ -0,0 +1,40 @@
+// 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 MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes a user of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingUser
+    {
+        /// <summary>
+        /// The user's ID.
+        /// </summary>
+        [Key(0)]
+        public required int UserId { get; set; }
+
+        /// <summary>
+        /// The aggregate room placement (1-based).
+        /// </summary>
+        [Key(1)]
+        public int Placement { get; set; }
+
+        /// <summary>
+        /// The aggregate points.
+        /// </summary>
+        [Key(2)]
+        public int Points { get; set; }
+
+        /// <summary>
+        /// The scores set.
+        /// </summary>
+        [Key(3)]
+        public MatchmakingRoundList Rounds { get; set; } = new MatchmakingRoundList();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs
new file mode 100644
index 0000000000..74da6a9b2a
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs
@@ -0,0 +1,65 @@
+// 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;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Orders <see cref="MatchmakingUser"/> in order of placement.
+    /// </summary>
+    public class MatchmakingUserComparer : Comparer<MatchmakingUser>
+    {
+        private readonly int rounds;
+
+        public MatchmakingUserComparer(int rounds)
+        {
+            this.rounds = rounds;
+        }
+
+        public override int Compare(MatchmakingUser? x, MatchmakingUser? y)
+        {
+            ArgumentNullException.ThrowIfNull(x);
+            ArgumentNullException.ThrowIfNull(y);
+
+            // X appears earlier in the list if it has more points.
+            if (x.Points > y.Points)
+                return -1;
+
+            // Y appears earlier in the list if it has more points.
+            if (y.Points > x.Points)
+                return 1;
+
+            // Tiebreaker 1 (likely): From each user's point-of-view, their earliest and best placement.
+            for (int r = 1; r <= rounds; r++)
+            {
+                MatchmakingRound? xRound;
+                x.Rounds.RoundsDictionary.TryGetValue(r, out xRound);
+
+                MatchmakingRound? yRound;
+                y.Rounds.RoundsDictionary.TryGetValue(r, out yRound);
+
+                // Nothing to do if both players haven't played this round.
+                if (xRound == null && yRound == null)
+                    continue;
+
+                // X appears later in the list if it hasn't played this round.
+                if (xRound == null)
+                    return 1;
+
+                // Y appears later in the list if it hasn't played this round.
+                if (yRound == null)
+                    return -1;
+
+                // X appears earlier in the list if it has a better placement in the round.
+                int compare = xRound.Placement.CompareTo(yRound.Placement);
+                if (compare != 0)
+                    return compare;
+            }
+
+            // Tiebreaker 2 (unlikely): User ID.
+            return x.UserId.CompareTo(y.UserId);
+        }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.cs
new file mode 100644
index 0000000000..600134de4e
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.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 System;
+using System.Collections;
+using System.Collections.Generic;
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the users of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingUserList : IEnumerable<MatchmakingUser>
+    {
+        /// <summary>
+        /// A key-value-pair mapping of ids to users.
+        /// </summary>
+        [Key(0)]
+        public IDictionary<int, MatchmakingUser> UserDictionary { get; set; } = new Dictionary<int, MatchmakingUser>();
+
+        /// <summary>
+        /// Creates or retrieves the user for the given id.
+        /// </summary>
+        /// <param name="userId">The user id.</param>
+        public MatchmakingUser this[int userId]
+        {
+            get
+            {
+                if (UserDictionary.TryGetValue(userId, out MatchmakingUser? user))
+                    return user;
+
+                return UserDictionary[userId] = new MatchmakingUser { UserId = userId };
+            }
+        }
+
+        /// <summary>
+        /// The total number of users.
+        /// </summary>
+        [IgnoreMember]
+        public int Count => UserDictionary.Count;
+
+        public IEnumerator<MatchmakingUser> GetEnumerator() => UserDictionary.Values.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClient.cs b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
index 92fc8a3dcf..745e773512 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
@@ -11,6 +11,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Database;
 using osu.Game.Localisation;
 using osu.Game.Online.API;
@@ -171,6 +172,8 @@ namespace osu.Game.Online.Multiplayer
 
         protected Room? APIRoom { get; private set; }
 
+        private readonly Queue<Action> pendingRequests = new Queue<Action>();
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -199,6 +202,7 @@ namespace osu.Game.Online.Multiplayer
 
             await joinOrLeaveTaskChain.Add(async () =>
             {
+                await runOnUpdateThreadAsync(() => pendingRequests.Clear(), cancellationSource.Token).ConfigureAwait(false);
                 var multiplayerRoom = await CreateRoomInternal(new MultiplayerRoom(room)).ConfigureAwait(false);
                 await setupJoinedRoom(room, multiplayerRoom, cancellationSource.Token).ConfigureAwait(false);
             }, cancellationSource.Token).ConfigureAwait(false);
@@ -222,6 +226,7 @@ namespace osu.Game.Online.Multiplayer
 
             await joinOrLeaveTaskChain.Add(async () =>
             {
+                await runOnUpdateThreadAsync(() => pendingRequests.Clear(), cancellationSource.Token).ConfigureAwait(false);
                 var multiplayerRoom = await JoinRoomInternal(room.RoomID.Value, password ?? room.Password).ConfigureAwait(false);
                 await setupJoinedRoom(room, multiplayerRoom, cancellationSource.Token).ConfigureAwait(false);
             }, cancellationSource.Token).ConfigureAwait(false);
@@ -265,6 +270,9 @@ namespace osu.Game.Online.Multiplayer
 
                 updateLocalRoomSettings(joinedRoom.Settings);
 
+                while (pendingRequests.TryDequeue(out Action? action))
+                    action();
+
                 postServerShuttingDownNotification();
 
                 OnRoomJoined();
@@ -299,10 +307,23 @@ namespace osu.Game.Online.Multiplayer
                 RoomUpdated?.Invoke();
             });
 
-            return joinOrLeaveTaskChain.Add(async () =>
+            return Task.Run(async () =>
             {
-                await scheduledReset.ConfigureAwait(false);
-                await LeaveRoomInternal().ConfigureAwait(false);
+                try
+                {
+                    await joinOrLeaveTaskChain.Add(async () =>
+                    {
+                        await scheduledReset.ConfigureAwait(false);
+                        await LeaveRoomInternal().ConfigureAwait(false);
+                    }).ConfigureAwait(false);
+                }
+                finally
+                {
+                    await runOnUpdateThreadAsync(() =>
+                    {
+                        pendingRequests.Clear();
+                    }).ConfigureAwait(false);
+                }
             });
         }
 
@@ -448,11 +469,9 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.RoomStateChanged(MultiplayerRoomState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.State = state;
@@ -475,7 +494,7 @@ namespace osu.Game.Online.Multiplayer
                 }
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -484,10 +503,9 @@ namespace osu.Game.Online.Multiplayer
         {
             await PopulateUsers([user]).ConfigureAwait(false);
 
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 // for sanity, ensure that there can be no duplicate users in the room user list.
                 if (Room.Users.Any(existing => existing.UserID == user.UserID))
@@ -499,18 +517,18 @@ namespace osu.Game.Online.Multiplayer
 
                 UserJoined?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
         }
 
         Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user)
         {
-            Scheduler.Add(() => handleUserLeft(user, UserLeft), false);
+            handleRoomRequest(() => handleUserLeft(user, UserLeft));
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserKicked(MultiplayerRoomUser user)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
                 if (LocalUser == null)
                     return;
@@ -519,7 +537,7 @@ namespace osu.Game.Online.Multiplayer
                     LeaveRoom();
 
                 handleUserLeft(user, UserKicked);
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -527,9 +545,7 @@ namespace osu.Game.Online.Multiplayer
         private void handleUserLeft(MultiplayerRoomUser user, Action<MultiplayerRoomUser>? callback)
         {
             Debug.Assert(ThreadSafety.IsUpdateThread);
-
-            if (Room == null)
-                return;
+            Debug.Assert(Room != null);
 
             Room.Users.Remove(user);
             PlayingUserIds.Remove(user.UserID);
@@ -549,16 +565,14 @@ namespace osu.Game.Online.Multiplayer
 
             if (apiUser == null || apiRoom == null) return;
 
-            PostNotification?.Invoke(
-                new UserAvatarNotification(apiUser, NotificationsStrings.InvitedYouToTheMultiplayer(apiUser.Username, apiRoom.Name))
+            PostNotification?.Invoke(new MultiplayerInvitationNotification(apiUser, apiRoom)
+            {
+                Activated = () =>
                 {
-                    Activated = () =>
-                    {
-                        PresentMatch?.Invoke(apiRoom, password);
-                        return true;
-                    }
+                    PresentMatch?.Invoke(apiRoom, password);
+                    return true;
                 }
-            );
+            });
 
             Task<Room?> getRoomAsync(long id)
             {
@@ -588,11 +602,9 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.HostChanged(int userId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 var user = Room.Users.FirstOrDefault(u => u.UserID == userId);
@@ -602,22 +614,24 @@ namespace osu.Game.Online.Multiplayer
 
                 HostChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.SettingsChanged(MultiplayerRoomSettings newSettings)
         {
-            Scheduler.Add(() => updateLocalRoomSettings(newSettings));
+            handleRoomRequest(() => updateLocalRoomSettings(newSettings));
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserStateChanged(int userId, MultiplayerUserState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // TODO: user should NEVER be null here, see https://github.com/ppy/osu/issues/17713.
                 if (user == null)
@@ -627,16 +641,18 @@ namespace osu.Game.Online.Multiplayer
                 updateUserPlayingState(userId, state);
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.MatchUserStateChanged(int userId, MatchUserState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // TODO: user should NEVER be null here, see https://github.com/ppy/osu/issues/17713.
                 if (user == null)
@@ -644,31 +660,29 @@ namespace osu.Game.Online.Multiplayer
 
                 user.MatchState = state;
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.MatchRoomStateChanged(MatchRoomState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 Room.MatchState = state;
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         public Task MatchEvent(MatchServerEvent e)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 switch (e)
                 {
@@ -692,7 +706,7 @@ namespace osu.Game.Online.Multiplayer
                 }
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -709,9 +723,11 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.UserBeatmapAvailabilityChanged(int userId, BeatmapAvailability beatmapAvailability)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - beatmap availability state is mostly for display.
                 if (user == null)
@@ -720,16 +736,18 @@ namespace osu.Game.Online.Multiplayer
                 user.BeatmapAvailability = beatmapAvailability;
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserStyleChanged(int userId, int? beatmapId, int? rulesetId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - user style is mostly for display.
                 if (user == null)
@@ -740,16 +758,18 @@ namespace osu.Game.Online.Multiplayer
 
                 UserStyleChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserModsChanged(int userId, IEnumerable<APIMod> mods)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - user mods are mostly for display.
                 if (user == null)
@@ -759,70 +779,60 @@ namespace osu.Game.Online.Multiplayer
 
                 UserModsChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.LoadRequested()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 LoadRequested?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.GameplayAborted(GameplayAbortReason reason)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 GameplayAborted?.Invoke(reason);
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.GameplayStarted()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 GameplayStarted?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.ResultsReady()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 ResultsReady?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         public Task PlaylistItemAdded(MultiplayerPlaylistItem item)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist.Add(item);
@@ -837,11 +847,9 @@ namespace osu.Game.Online.Multiplayer
 
         public Task PlaylistItemRemoved(long playlistItemId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist.Remove(Room.Playlist.Single(existing => existing.ID == playlistItemId));
@@ -858,11 +866,9 @@ namespace osu.Game.Online.Multiplayer
 
         public Task PlaylistItemChanged(MultiplayerPlaylistItem item)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist[Room.Playlist.IndexOf(Room.Playlist.Single(existing => existing.ID == item.ID))] = item;
@@ -909,9 +915,7 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="settings">The new <see cref="MultiplayerRoomSettings"/> to update from.</param>
         private void updateLocalRoomSettings(MultiplayerRoomSettings settings)
         {
-            if (Room == null)
-                return;
-
+            Debug.Assert(Room != null);
             Debug.Assert(APIRoom != null);
 
             // Update a few properties of the room instantaneously.
@@ -973,6 +977,20 @@ namespace osu.Game.Online.Multiplayer
             return tcs.Task;
         }
 
+        private void handleRoomRequest(Action request)
+        {
+            Scheduler.Add(() =>
+            {
+                if (Room == null)
+                {
+                    pendingRequests.Enqueue(request);
+                    return;
+                }
+
+                request();
+            });
+        }
+
         Task IStatefulUserHubClient.DisconnectRequested()
         {
             Schedule(() =>
@@ -982,5 +1000,15 @@ namespace osu.Game.Online.Multiplayer
             });
             return Task.CompletedTask;
         }
+
+        private partial class MultiplayerInvitationNotification : UserAvatarNotification
+        {
+            protected override IconUsage CloseButtonIcon => FontAwesome.Solid.Times;
+
+            public MultiplayerInvitationNotification(APIUser user, Room room)
+                : base(user, NotificationsStrings.InvitedYouToTheMultiplayer(user.Username, room.Name))
+            {
+            }
+        }
     }
 }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
index c59f5937b0..bc2536848b 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Matchmaking;
 using osu.Game.Online.Multiplayer.Countdown;
 
 namespace osu.Game.Online.Multiplayer
@@ -14,6 +15,7 @@ namespace osu.Game.Online.Multiplayer
     [Union(0, typeof(MatchStartCountdown))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
     [Union(1, typeof(ForceGameplayStartCountdown))]
     [Union(2, typeof(ServerShuttingDownCountdown))]
+    [Union(3, typeof(MatchmakingStageCountdown))]
     public abstract class MultiplayerCountdown
     {
         /// <summary>
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 ade28458e8..bbfe25c8fd 100644
--- a/osu.Game/Online/Rooms/MatchType.cs
+++ b/osu.Game/Online/Rooms/MatchType.cs
@@ -17,5 +17,7 @@ namespace osu.Game.Online.Rooms
 
         [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVersus))]
         TeamVersus,
+
+        Matchmaking
     }
 }
diff --git a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
index d8ed20a3a8..3386b8654d 100644
--- a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
+++ b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using MessagePack;
 using osu.Game.Online.API;
@@ -13,7 +14,7 @@ namespace osu.Game.Online.Rooms
 {
     [Serializable]
     [MessagePackObject]
-    public class MultiplayerPlaylistItem
+    public class MultiplayerPlaylistItem : IEquatable<MultiplayerPlaylistItem>
     {
         [Key(0)]
         public long ID { get; set; }
@@ -118,5 +119,42 @@ namespace osu.Game.Online.Rooms
             clone.AllowedMods = AllowedMods.ToArray();
             return clone;
         }
+
+        public bool Equals(MultiplayerPlaylistItem? other)
+            => other != null
+               && ID == other.ID
+               && OwnerID == other.OwnerID
+               && BeatmapID == other.BeatmapID
+               && BeatmapChecksum == other.BeatmapChecksum
+               && RulesetID == other.RulesetID
+               && RequiredMods.SequenceEqual(other.RequiredMods)
+               && AllowedMods.SequenceEqual(other.AllowedMods)
+               && Expired == other.Expired
+               && PlaylistOrder == other.PlaylistOrder
+               && PlayedAt == other.PlayedAt
+               && StarRating == other.StarRating
+               && Freestyle == other.Freestyle;
+
+        public override bool Equals(object? obj)
+            => obj is MultiplayerPlaylistItem other && Equals(other);
+
+        [SuppressMessage("ReSharper", "NonReadonlyMemberInGetHashCode")]
+        public override int GetHashCode()
+        {
+            var hashCode = new HashCode();
+            hashCode.Add(ID);
+            hashCode.Add(OwnerID);
+            hashCode.Add(BeatmapID);
+            hashCode.Add(BeatmapChecksum);
+            hashCode.Add(RulesetID);
+            hashCode.Add(RequiredMods);
+            hashCode.Add(AllowedMods);
+            hashCode.Add(Expired);
+            hashCode.Add(PlaylistOrder);
+            hashCode.Add(PlayedAt);
+            hashCode.Add(StarRating);
+            hashCode.Add(Freestyle);
+            return hashCode.ToHashCode();
+        }
     }
 }
diff --git a/osu.Game/Online/Rooms/Room.cs b/osu.Game/Online/Rooms/Room.cs
index e965f9c187..4200fed0dd 100644
--- a/osu.Game/Online/Rooms/Room.cs
+++ b/osu.Game/Online/Rooms/Room.cs
@@ -263,6 +263,12 @@ namespace osu.Game.Online.Rooms
             set => SetField(ref availability, value);
         }
 
+        public bool Pinned
+        {
+            get => pinned;
+            set => SetField(ref pinned, value);
+        }
+
         [JsonProperty("id")]
         private long? roomId;
 
@@ -339,6 +345,9 @@ namespace osu.Game.Online.Rooms
         [JsonConverter(typeof(SnakeCaseStringEnumConverter))]
         private RoomStatus status;
 
+        [JsonProperty("pinned")]
+        private bool pinned;
+
         // Not yet serialised (not implemented).
         private RoomAvailability availability;
 
diff --git a/osu.Game/Online/SignalRDerivedTypeWorkaroundJsonConverter.cs b/osu.Game/Online/SignalRDerivedTypeWorkaroundJsonConverter.cs
deleted file mode 100644
index 86708bee82..0000000000
--- a/osu.Game/Online/SignalRDerivedTypeWorkaroundJsonConverter.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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.Linq;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace osu.Game.Online
-{
-    /// <summary>
-    /// A type of <see cref="JsonConverter"/> that serializes a subset of types used in multiplayer/spectator communication that
-    /// derive from a known base type. This is a safe alternative to using <see cref="TypeNameHandling.Auto"/> or <see cref="TypeNameHandling.All"/>,
-    /// which are known to have security issues.
-    /// </summary>
-    public class SignalRDerivedTypeWorkaroundJsonConverter : JsonConverter
-    {
-        public override bool CanConvert(Type objectType) =>
-            SignalRWorkaroundTypes.BASE_TYPE_MAPPING.Any(t =>
-                objectType == t.baseType ||
-                objectType == t.derivedType);
-
-        public override object? ReadJson(JsonReader reader, Type objectType, object? o, JsonSerializer jsonSerializer)
-        {
-            if (reader.TokenType == JsonToken.Null)
-                return null;
-
-            JObject obj = JObject.Load(reader);
-
-            string type = (string)obj[@"$dtype"]!;
-
-            var resolvedType = SignalRWorkaroundTypes.BASE_TYPE_MAPPING.Select(t => t.derivedType).Single(t => t.Name == type);
-
-            object? instance = Activator.CreateInstance(resolvedType);
-
-            if (instance != null)
-                jsonSerializer.Populate(obj["$value"]!.CreateReader(), instance);
-
-            return instance;
-        }
-
-        public override void WriteJson(JsonWriter writer, object? o, JsonSerializer serializer)
-        {
-            if (o == null)
-            {
-                writer.WriteNull();
-                return;
-            }
-
-            writer.WriteStartObject();
-
-            writer.WritePropertyName(@"$dtype");
-            serializer.Serialize(writer, o.GetType().Name);
-
-            writer.WritePropertyName(@"$value");
-            writer.WriteRawValue(JsonConvert.SerializeObject(o));
-
-            writer.WriteEndObject();
-        }
-    }
-}
diff --git a/osu.Game/Online/SignalRWorkaroundTypes.cs b/osu.Game/Online/SignalRWorkaroundTypes.cs
index 757bb07ec8..04d4b8d7af 100644
--- a/osu.Game/Online/SignalRWorkaroundTypes.cs
+++ b/osu.Game/Online/SignalRWorkaroundTypes.cs
@@ -3,8 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using osu.Game.Online.Matchmaking;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.Countdown;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Users;
 
@@ -14,7 +16,6 @@ namespace osu.Game.Online
     /// A static class providing the list of types requiring workarounds for serialisation in SignalR.
     /// </summary>
     /// <seealso cref="SignalRUnionWorkaroundResolver"/>
-    /// <seealso cref="SignalRDerivedTypeWorkaroundJsonConverter"/>
     internal static class SignalRWorkaroundTypes
     {
         internal static readonly IReadOnlyList<(Type derivedType, Type baseType)> BASE_TYPE_MAPPING = new[]
@@ -46,6 +47,13 @@ namespace osu.Game.Online
             (typeof(UserActivity.TestingBeatmap), typeof(UserActivity)),
             (typeof(UserActivity.InDailyChallengeLobby), typeof(UserActivity)),
             (typeof(UserActivity.PlayingDailyChallenge), typeof(UserActivity)),
+
+            // matchmaking
+            (typeof(MatchmakingQueueStatus.Searching), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingQueueStatus.MatchFound), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingQueueStatus.JoiningMatch), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingRoomState), typeof(MatchRoomState)),
+            (typeof(MatchmakingStageCountdown), typeof(MultiplayerCountdown))
         };
     }
 }
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 3c23ccc5cf..df1eac4461 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -90,7 +90,7 @@ namespace osu.Game
 
         public const int SAMPLE_CONCURRENCY = 6;
 
-        public const double SFX_STEREO_STRENGTH = 0.75;
+        public const double SFX_STEREO_STRENGTH = 0.6;
 
         /// <summary>
         /// Length of debounce (in milliseconds) for commonly occuring sample playbacks that could stack.
@@ -489,9 +489,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/Chat/ChatLine.cs b/osu.Game/Overlays/Chat/ChatLine.cs
index 20c3b26b8b..427d874f12 100644
--- a/osu.Game/Overlays/Chat/ChatLine.cs
+++ b/osu.Game/Overlays/Chat/ChatLine.cs
@@ -292,7 +292,7 @@ namespace osu.Game.Overlays.Chat
             // remove non-existent channels from the link list
             message.Links.RemoveAll(link => link.Action == LinkAction.OpenChannel && chatManager?.AvailableChannels.Any(c => c.Name == link.Argument.ToString()) != true);
 
-            isMention = MessageNotifier.CheckContainsUsername(message.DisplayContent, api.LocalUser.Value.Username);
+            isMention = MessageNotifier.MatchUsername(message.DisplayContent, api.LocalUser.Value.Username).Success;
 
             drawableContentFlow.Clear();
             drawableContentFlow.AddLinks(message.DisplayContent, message.Links);
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/AdjustedAttributesTooltip.cs b/osu.Game/Overlays/Mods/AdjustedAttributesTooltip.cs
deleted file mode 100644
index dcb9ecdfc8..0000000000
--- a/osu.Game/Overlays/Mods/AdjustedAttributesTooltip.cs
+++ /dev/null
@@ -1,148 +0,0 @@
-// 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.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-
-namespace osu.Game.Overlays.Mods
-{
-    public partial class AdjustedAttributesTooltip : VisibilityContainer, ITooltip<AdjustedAttributesTooltip.Data?>
-    {
-        private readonly OverlayColourProvider? colourProvider;
-        private FillFlowContainer attributesFillFlow = null!;
-
-        private Container content = null!;
-
-        private Data? data;
-
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
-
-        public AdjustedAttributesTooltip(OverlayColourProvider? colourProvider = null)
-        {
-            this.colourProvider = colourProvider;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AutoSizeAxes = Axes.Both;
-
-            Masking = true;
-            CornerRadius = 5;
-
-            InternalChildren = new Drawable[]
-            {
-                content = new Container
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = colourProvider?.Background4 ?? colours.Gray3,
-                        },
-                        new FillFlowContainer
-                        {
-                            AutoSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Vertical = 10, Horizontal = 15 },
-                            Direction = FillDirection.Vertical,
-                            Children = new Drawable[]
-                            {
-                                new OsuSpriteText
-                                {
-                                    Text = "One or more values are being adjusted by mods.",
-                                },
-                                attributesFillFlow = new FillFlowContainer
-                                {
-                                    Direction = FillDirection.Vertical,
-                                    AutoSizeAxes = Axes.Both
-                                }
-                            }
-                        }
-                    }
-                },
-            };
-
-            updateDisplay();
-        }
-
-        private void updateDisplay()
-        {
-            attributesFillFlow.Clear();
-
-            if (data != null)
-            {
-                attemptAdd("CS", bd => bd.CircleSize);
-                attemptAdd("AR", bd => bd.ApproachRate);
-                attemptAdd("OD", bd => bd.OverallDifficulty);
-                attemptAdd("HP", bd => bd.DrainRate);
-            }
-
-            if (attributesFillFlow.Any())
-                content.Show();
-            else
-                content.Hide();
-
-            void attemptAdd(string name, Func<BeatmapDifficulty, double> lookup)
-            {
-                double originalValue = lookup(data.OriginalDifficulty);
-                double adjustedValue = lookup(data.AdjustedDifficulty);
-
-                if (!Precision.AlmostEquals(originalValue, adjustedValue))
-                    attributesFillFlow.Add(new AttributeDisplay(name, originalValue, adjustedValue));
-            }
-        }
-
-        public void SetContent(Data? data)
-        {
-            if (this.data == data)
-                return;
-
-            this.data = data;
-            updateDisplay();
-        }
-
-        protected override void PopIn() => this.FadeIn(200, Easing.OutQuint);
-        protected override void PopOut() => this.FadeOut(200, Easing.OutQuint);
-
-        public void Move(Vector2 pos) => Position = pos;
-
-        public class Data
-        {
-            public BeatmapDifficulty OriginalDifficulty { get; }
-            public BeatmapDifficulty AdjustedDifficulty { get; }
-
-            public Data(BeatmapDifficulty originalDifficulty, BeatmapDifficulty adjustedDifficulty)
-            {
-                OriginalDifficulty = originalDifficulty;
-                AdjustedDifficulty = adjustedDifficulty;
-            }
-        }
-
-        private partial class AttributeDisplay : CompositeDrawable
-        {
-            public AttributeDisplay(string name, double original, double adjusted)
-            {
-                AutoSizeAxes = Axes.Both;
-
-                InternalChild = new OsuSpriteText
-                {
-                    Font = OsuFont.Default.With(weight: FontWeight.Bold),
-                    Text = $"{name}: {original:0.0#} → {adjusted:0.0#}"
-                };
-            }
-        }
-    }
-}
diff --git a/osu.Game/Overlays/Mods/BeatmapAttributeTooltip.cs b/osu.Game/Overlays/Mods/BeatmapAttributeTooltip.cs
new file mode 100644
index 0000000000..5bd4ed3dbc
--- /dev/null
+++ b/osu.Game/Overlays/Mods/BeatmapAttributeTooltip.cs
@@ -0,0 +1,157 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Difficulty;
+using osuTK;
+
+namespace osu.Game.Overlays.Mods
+{
+    public partial class BeatmapAttributeTooltip : VisibilityContainer, ITooltip<RulesetBeatmapAttribute?>
+    {
+        private readonly OverlayColourProvider? colourProvider;
+
+        private Container content = null!;
+
+        private RulesetBeatmapAttribute? attribute;
+        private OsuSpriteText adjustedByModsText = null!;
+        private OsuTextFlowContainer descriptionText = null!;
+        private GridContainer metricsGrid = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public BeatmapAttributeTooltip(OverlayColourProvider? colourProvider = null)
+        {
+            this.colourProvider = colourProvider;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            Masking = true;
+            CornerRadius = 5;
+
+            InternalChildren = new Drawable[]
+            {
+                content = new Container
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colourProvider?.Background4 ?? colours.Gray3,
+                        },
+                        new FillFlowContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Vertical = 10, Horizontal = 15 },
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(10),
+                            Children = new Drawable[]
+                            {
+                                descriptionText = new OsuTextFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    MaximumSize = new Vector2(380, 0),
+                                },
+                                metricsGrid = new GridContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    ColumnDimensions =
+                                    [
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(minSize: 10),
+                                        new Dimension(GridSizeMode.AutoSize),
+                                    ]
+                                },
+                                adjustedByModsText = new OsuSpriteText
+                                {
+                                    Font = OsuFont.Style.Caption1.With(weight: FontWeight.Bold),
+                                },
+                            }
+                        },
+                    }
+                },
+            };
+
+            updateDisplay();
+        }
+
+        private void updateDisplay()
+        {
+            bool shouldShow = false;
+
+            if (attribute != null)
+            {
+                descriptionText.Text = attribute.Description ?? default;
+                shouldShow = attribute.Description != null;
+
+                metricsGrid.Content = attribute.AdditionalMetrics.Select(metric => new[]
+                {
+                    new OsuSpriteText
+                    {
+                        Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                        Text = metric.Name,
+                        Colour = metric.Colour ?? colourProvider?.Content2 ?? Colour4.White,
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                    },
+                    Empty(),
+                    new OsuSpriteText
+                    {
+                        Font = OsuFont.Style.Caption1,
+                        Text = metric.Value,
+                        Colour = Interpolation.ValueAt<Colour4>(0.85f, colourProvider?.Content1 ?? Colour4.White, metric.Colour ?? colourProvider?.Content1 ?? Colour4.White, 0, 1),
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.CentreRight,
+                    }
+                }).ToArray();
+                metricsGrid.RowDimensions = Enumerable.Repeat(new Dimension(GridSizeMode.AutoSize), attribute.AdditionalMetrics.Length).ToArray();
+                metricsGrid.Alpha = attribute.AdditionalMetrics.Length > 0 ? 1 : 0;
+                shouldShow |= attribute.AdditionalMetrics.Length > 0;
+
+                if (!Precision.AlmostEquals(attribute.OriginalValue, attribute.AdjustedValue))
+                {
+                    adjustedByModsText.Text = $"This value is being adjusted by mods ({attribute.OriginalValue:0.0#} → {attribute.AdjustedValue:0.0#}).";
+                    adjustedByModsText.Alpha = 1;
+                    shouldShow = true;
+                }
+                else
+                    adjustedByModsText.Alpha = 0;
+            }
+
+            if (shouldShow)
+                content.Show();
+            else
+                content.Hide();
+        }
+
+        public void SetContent(RulesetBeatmapAttribute? attribute)
+        {
+            if (this.attribute == attribute)
+                return;
+
+            this.attribute = attribute;
+            updateDisplay();
+        }
+
+        protected override void PopIn() => this.FadeIn(200, Easing.OutQuint);
+        protected override void PopOut() => this.FadeOut(200, Easing.OutQuint);
+
+        public void Move(Vector2 pos) => Position = pos;
+    }
+}
diff --git a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
index 10e3df17e5..e4ca354ffd 100644
--- a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
+++ b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
@@ -8,7 +8,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -27,16 +26,11 @@ namespace osu.Game.Overlays.Mods
     /// On the mod select overlay, this provides a local updating view of BPM, star rating and other
     /// difficulty attributes so the user can have a better insight into what mods are changing.
     /// </summary>
-    public partial class BeatmapAttributesDisplay : ModFooterInformationDisplay, IHasCustomTooltip<AdjustedAttributesTooltip.Data?>
+    public partial class BeatmapAttributesDisplay : ModFooterInformationDisplay
     {
         private StarRatingDisplay starRatingDisplay = null!;
         private BPMDisplay bpmDisplay = null!;
 
-        private VerticalAttributeDisplay circleSizeDisplay = null!;
-        private VerticalAttributeDisplay drainRateDisplay = null!;
-        private VerticalAttributeDisplay approachRateDisplay = null!;
-        private VerticalAttributeDisplay overallDifficultyDisplay = null!;
-
         public Bindable<IBeatmapInfo?> BeatmapInfo { get; } = new Bindable<IBeatmapInfo?>();
 
         public Bindable<IReadOnlyList<Mod>> Mods { get; } = new Bindable<IReadOnlyList<Mod>>();
@@ -56,10 +50,6 @@ namespace osu.Game.Overlays.Mods
         private CancellationTokenSource? cancellationSource;
         private IBindable<StarDifficulty> starDifficulty = null!;
 
-        public ITooltip<AdjustedAttributesTooltip.Data?> GetCustomTooltip() => new AdjustedAttributesTooltip();
-
-        public AdjustedAttributesTooltip.Data? TooltipContent { get; private set; }
-
         private const float transition_duration = 250;
 
         [BackgroundDependencyLoader]
@@ -84,13 +74,6 @@ namespace osu.Game.Overlays.Mods
             });
 
             RightContent.Alpha = 0;
-            RightContent.AddRange(new Drawable[]
-            {
-                circleSizeDisplay = new VerticalAttributeDisplay("CS") { Shear = -OsuGame.SHEAR, },
-                approachRateDisplay = new VerticalAttributeDisplay("AR") { Shear = -OsuGame.SHEAR, },
-                overallDifficultyDisplay = new VerticalAttributeDisplay("OD") { Shear = -OsuGame.SHEAR, },
-                drainRateDisplay = new VerticalAttributeDisplay("HP") { Shear = -OsuGame.SHEAR, },
-            });
         }
 
         protected override void LoadComplete()
@@ -173,26 +156,24 @@ namespace osu.Game.Overlays.Mods
 
             bpmDisplay.Current.Value = FormatUtils.RoundBPM(BeatmapInfo.Value.BPM, rate);
 
-            BeatmapDifficulty originalDifficulty = new BeatmapDifficulty(BeatmapInfo.Value.Difficulty);
-            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(originalDifficulty);
-
-            foreach (var mod in Mods.Value.OfType<IApplicableToDifficulty>())
-                mod.ApplyToDifficulty(adjustedDifficulty);
-
             Ruleset ruleset = GameRuleset.Value.CreateInstance();
-            adjustedDifficulty = ruleset.GetRateAdjustedDisplayDifficulty(adjustedDifficulty, rate);
+            var displayAttributes = ruleset.GetBeatmapAttributesForDisplay(BeatmapInfo.Value, Mods.Value).ToList();
 
-            TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
+            // if there are not enough attribute displays, make more
+            for (int i = RightContent.Count; i < displayAttributes.Count; i++)
+                RightContent.Add(new VerticalAttributeDisplay { Shear = -OsuGame.SHEAR });
 
-            circleSizeDisplay.AdjustType.Value = VerticalAttributeDisplay.CalculateEffect(originalDifficulty.CircleSize, adjustedDifficulty.CircleSize);
-            drainRateDisplay.AdjustType.Value = VerticalAttributeDisplay.CalculateEffect(originalDifficulty.DrainRate, adjustedDifficulty.DrainRate);
-            approachRateDisplay.AdjustType.Value = VerticalAttributeDisplay.CalculateEffect(originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate);
-            overallDifficultyDisplay.AdjustType.Value = VerticalAttributeDisplay.CalculateEffect(originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty);
+            // populate all attribute displays that need to be visible...
+            for (int i = 0; i < displayAttributes.Count; i++)
+            {
+                var attribute = displayAttributes[i];
+                var display = (VerticalAttributeDisplay)RightContent[i];
+                display.SetAttribute(attribute);
+            }
 
-            circleSizeDisplay.Current.Value = adjustedDifficulty.CircleSize;
-            drainRateDisplay.Current.Value = adjustedDifficulty.DrainRate;
-            approachRateDisplay.Current.Value = adjustedDifficulty.ApproachRate;
-            overallDifficultyDisplay.Current.Value = adjustedDifficulty.OverallDifficulty;
+            // and hide any extra ones
+            for (int i = displayAttributes.Count; i < RightContent.Count; i++)
+                ((VerticalAttributeDisplay)RightContent[i]).SetAttribute(null);
         });
 
         private void updateCollapsedState()
diff --git a/osu.Game/Overlays/Mods/VerticalAttributeDisplay.cs b/osu.Game/Overlays/Mods/VerticalAttributeDisplay.cs
index a3e24b486f..977da67e31 100644
--- a/osu.Game/Overlays/Mods/VerticalAttributeDisplay.cs
+++ b/osu.Game/Overlays/Mods/VerticalAttributeDisplay.cs
@@ -7,33 +7,30 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osuTK.Graphics;
 
 namespace osu.Game.Overlays.Mods
 {
-    public partial class VerticalAttributeDisplay : Container, IHasCurrentValue<double>
+    public partial class VerticalAttributeDisplay : Container, IHasCustomTooltip<RulesetBeatmapAttribute?>
     {
-        public Bindable<double> Current
-        {
-            get => current.Current;
-            set => current.Current = value;
-        }
-
         private readonly BindableWithCurrent<double> current = new BindableWithCurrent<double>();
 
-        public Bindable<ModEffect> AdjustType = new Bindable<ModEffect>();
-
         /// <summary>
         /// Text to display in the top area of the display.
         /// </summary>
-        public LocalisableString Label { get; protected set; }
+        public LocalisableString Label
+        {
+            get => text.Text;
+            set => text.Text = value;
+        }
 
         private readonly EffectCounter counter;
         private readonly OsuSpriteText text;
@@ -41,11 +38,70 @@ namespace osu.Game.Overlays.Mods
         [Resolved]
         private OsuColour colours { get; set; } = null!;
 
-        private void updateTextColor()
+        public VerticalAttributeDisplay()
+        {
+            AutoSizeAxes = Axes.X;
+            RelativeSizeAxes = Axes.Y;
+
+            Origin = Anchor.CentreLeft;
+            Anchor = Anchor.CentreLeft;
+
+            InternalChild = new FillFlowContainer
+            {
+                Origin = Anchor.CentreLeft,
+                Anchor = Anchor.CentreLeft,
+                RelativeSizeAxes = Axes.Y,
+                Width = 42,
+                Direction = FillDirection.Vertical,
+                Children = new Drawable[]
+                {
+                    text = new OsuSpriteText
+                    {
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Font = OsuFont.Default.With(size: 20, weight: FontWeight.Bold)
+                    },
+                    counter = new EffectCounter
+                    {
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Current = { BindTarget = current },
+                    }
+                }
+            };
+        }
+
+        public void SetAttribute(RulesetBeatmapAttribute? attribute)
+        {
+            if (attribute != null)
+            {
+                text.Text = attribute.Acronym;
+                current.Value = attribute.AdjustedValue;
+                var effect = calculateEffect(attribute.OriginalValue, attribute.AdjustedValue);
+                updateTextColor(effect);
+                Alpha = 1;
+            }
+            else
+                Alpha = 0;
+
+            TooltipContent = attribute;
+        }
+
+        private static ModEffect calculateEffect(double oldValue, double newValue)
+        {
+            if (Precision.AlmostEquals(newValue, oldValue, 0.01))
+                return ModEffect.NotChanged;
+            if (newValue < oldValue)
+                return ModEffect.DifficultyReduction;
+
+            return ModEffect.DifficultyIncrease;
+        }
+
+        private void updateTextColor(ModEffect effect)
         {
             Color4 newColor;
 
-            switch (AdjustType.Value)
+            switch (effect)
             {
                 case ModEffect.NotChanged:
                     newColor = Color4.White;
@@ -60,61 +116,13 @@ namespace osu.Game.Overlays.Mods
                     break;
 
                 default:
-                    throw new ArgumentOutOfRangeException(nameof(AdjustType.Value));
+                    throw new ArgumentOutOfRangeException(nameof(effect), effect, null);
             }
 
             text.Colour = newColor;
             counter.Colour = newColor;
         }
 
-        public VerticalAttributeDisplay(LocalisableString label)
-        {
-            Label = label;
-
-            AutoSizeAxes = Axes.X;
-
-            Origin = Anchor.CentreLeft;
-            Anchor = Anchor.CentreLeft;
-
-            AdjustType.BindValueChanged(_ => updateTextColor());
-
-            InternalChild = new FillFlowContainer
-            {
-                Origin = Anchor.CentreLeft,
-                Anchor = Anchor.CentreLeft,
-                AutoSizeAxes = Axes.Y,
-                Width = 50,
-                Direction = FillDirection.Vertical,
-                Children = new Drawable[]
-                {
-                    text = new OsuSpriteText
-                    {
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Text = Label,
-                        Margin = new MarginPadding { Horizontal = 15 }, // to reserve space for 0.XX value
-                        Font = OsuFont.Default.With(size: 20, weight: FontWeight.Bold)
-                    },
-                    counter = new EffectCounter
-                    {
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Current = { BindTarget = Current },
-                    }
-                }
-            };
-        }
-
-        public static ModEffect CalculateEffect(double oldValue, double newValue)
-        {
-            if (Precision.AlmostEquals(newValue, oldValue, 0.01))
-                return ModEffect.NotChanged;
-            if (newValue < oldValue)
-                return ModEffect.DifficultyReduction;
-
-            return ModEffect.DifficultyIncrease;
-        }
-
         public enum ModEffect
         {
             NotChanged,
@@ -133,5 +141,8 @@ namespace osu.Game.Overlays.Mods
                 Font = OsuFont.Default.With(size: 18, weight: FontWeight.SemiBold)
             };
         }
+
+        public ITooltip<RulesetBeatmapAttribute?> GetCustomTooltip() => new BeatmapAttributeTooltip();
+        public RulesetBeatmapAttribute? TooltipContent { get; set; }
     }
 }
diff --git a/osu.Game/Overlays/NotificationOverlay.cs b/osu.Game/Overlays/NotificationOverlay.cs
index 18a487a312..f56e5e6ac3 100644
--- a/osu.Game/Overlays/NotificationOverlay.cs
+++ b/osu.Game/Overlays/NotificationOverlay.cs
@@ -180,7 +180,7 @@ namespace osu.Game.Overlays
             notification.Closed += () => notificationClosed(notification);
 
             if (notification is IHasCompletionTarget hasCompletionTarget)
-                hasCompletionTarget.CompletionTarget = Post;
+                hasCompletionTarget.CompletionTarget ??= Post;
 
             playDebouncedSample(notification.PopInSampleName);
 
diff --git a/osu.Game/Overlays/Notifications/SimpleNotification.cs b/osu.Game/Overlays/Notifications/SimpleNotification.cs
index 109b31ff71..517d7ead43 100644
--- a/osu.Game/Overlays/Notifications/SimpleNotification.cs
+++ b/osu.Game/Overlays/Notifications/SimpleNotification.cs
@@ -24,8 +24,7 @@ namespace osu.Game.Overlays.Notifications
             set
             {
                 text = value;
-                if (textDrawable != null)
-                    textDrawable.Text = text;
+                TextFlow.Text = text;
             }
         }
 
@@ -37,8 +36,7 @@ namespace osu.Game.Overlays.Notifications
             set
             {
                 icon = value;
-                if (iconDrawable != null)
-                    iconDrawable.Icon = icon;
+                IconDrawable.Icon = icon;
             }
         }
 
@@ -48,39 +46,6 @@ namespace osu.Game.Overlays.Notifications
             set => IconContent.Colour = value;
         }
 
-        private TextFlowContainer? textDrawable;
-
-        private SpriteIcon? iconDrawable;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours, OverlayColourProvider colourProvider)
-        {
-            Light.Colour = colours.Green;
-
-            IconContent.AddRange(new Drawable[]
-            {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background5,
-                },
-                iconDrawable = new SpriteIcon
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Icon = icon,
-                    Size = new Vector2(16),
-                }
-            });
-
-            Content.Add(textDrawable = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 14, weight: FontWeight.Medium))
-            {
-                AutoSizeAxes = Axes.Y,
-                RelativeSizeAxes = Axes.X,
-                Text = text
-            });
-        }
-
         public override bool Read
         {
             get => base.Read;
@@ -92,5 +57,42 @@ namespace osu.Game.Overlays.Notifications
                 Light.FadeTo(value ? 0 : 1, 100);
             }
         }
+
+        protected TextFlowContainer TextFlow { get; }
+        protected SpriteIcon IconDrawable { get; }
+
+        private readonly Box iconBackground;
+
+        public SimpleNotification()
+        {
+            IconContent.AddRange(new Drawable[]
+            {
+                iconBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                IconDrawable = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Icon = icon,
+                    Size = new Vector2(16),
+                }
+            });
+
+            Content.Add(TextFlow = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 14, weight: FontWeight.Medium))
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Text = text
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, OverlayColourProvider colourProvider)
+        {
+            Light.Colour = colours.Green;
+            iconBackground.Colour = colourProvider.Background5;
+        }
     }
 }
diff --git a/osu.Game/Overlays/Notifications/UserAvatarNotification.cs b/osu.Game/Overlays/Notifications/UserAvatarNotification.cs
index 5a9241a2a1..7dbecbf11e 100644
--- a/osu.Game/Overlays/Notifications/UserAvatarNotification.cs
+++ b/osu.Game/Overlays/Notifications/UserAvatarNotification.cs
@@ -3,72 +3,43 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Users.Drawables;
 
 namespace osu.Game.Overlays.Notifications
 {
-    public partial class UserAvatarNotification : Notification
+    public abstract partial class UserAvatarNotification : SimpleNotification
     {
-        private LocalisableString text;
+        private readonly APIUser? user;
 
-        public override LocalisableString Text
-        {
-            get => text;
-            set
-            {
-                text = value;
-                if (textDrawable != null)
-                    textDrawable.Text = text;
-            }
-        }
+        protected DrawableAvatar Avatar { get; private set; } = null!;
 
-        private TextFlowContainer? textDrawable;
-
-        private readonly APIUser user;
-
-        public UserAvatarNotification(APIUser user, LocalisableString text)
+        protected UserAvatarNotification(APIUser? user, LocalisableString text = default)
         {
             this.user = user;
+
+            Icon = default;
             Text = text;
         }
 
-        protected override IconUsage CloseButtonIcon => FontAwesome.Solid.Times;
-
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, OverlayColourProvider colourProvider)
+        private void load()
         {
-            Light.Colour = colours.Orange2;
-
-            Content.Add(textDrawable = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 14, weight: FontWeight.Medium))
-            {
-                AutoSizeAxes = Axes.Y,
-                RelativeSizeAxes = Axes.X,
-                Text = text
-            });
-
             IconContent.Masking = true;
             IconContent.CornerRadius = CORNER_RADIUS;
+            IconContent.ChangeChildDepth(IconDrawable, float.MinValue);
 
-            IconContent.AddRange(new Drawable[]
-            {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background5,
-                },
-            });
-
-            LoadComponentAsync(new DrawableAvatar(user)
+            LoadComponentAsync(Avatar = new DrawableAvatar(user)
             {
                 FillMode = FillMode.Fill,
             }, IconContent.Add);
         }
+
+        protected override void Update()
+        {
+            base.Update();
+            IconContent.Width = IconContent.DrawHeight;
+        }
     }
 }
diff --git a/osu.Game/Overlays/OverlayScrollContainer.cs b/osu.Game/Overlays/OverlayScrollContainer.cs
index 66a8686a88..957008d823 100644
--- a/osu.Game/Overlays/OverlayScrollContainer.cs
+++ b/osu.Game/Overlays/OverlayScrollContainer.cs
@@ -119,10 +119,13 @@ namespace osu.Game.Overlays
             private Sample scrollToTopSample;
             private Sample scrollToPreviousSample;
 
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => content.ReceivePositionalInputAt(screenSpacePos);
+
             public ScrollBackButton()
             {
                 Size = new Vector2(50);
                 Alpha = 0;
+
                 Add(content = new CircularContainer
                 {
                     RelativeSizeAxes = Axes.Both,
diff --git a/osu.Game/Overlays/Profile/Header/Components/ExtendedDetails.cs b/osu.Game/Overlays/Profile/Header/Components/ExtendedDetails.cs
index 50fc52600c..777283485d 100644
--- a/osu.Game/Overlays/Profile/Header/Components/ExtendedDetails.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/ExtendedDetails.cs
@@ -24,6 +24,7 @@ namespace osu.Game.Overlays.Profile.Header.Components
         private SpriteText playCount = null!;
         private SpriteText totalScore = null!;
         private SpriteText totalHits = null!;
+        private SpriteText hitsPerPlay = null!;
         private SpriteText maximumCombo = null!;
         private SpriteText replaysWatched = null!;
 
@@ -56,6 +57,7 @@ namespace osu.Game.Overlays.Profile.Header.Components
                             new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsPlayCount },
                             new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsTotalScore },
                             new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsTotalHits },
+                            new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsHitsPerPlay },
                             new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsMaximumCombo },
                             new OsuSpriteText { Font = font, Text = UsersStrings.ShowStatsReplaysWatchedByOthers },
                         }
@@ -73,6 +75,7 @@ namespace osu.Game.Overlays.Profile.Header.Components
                             playCount = new OsuSpriteText { Font = font },
                             totalScore = new OsuSpriteText { Font = font },
                             totalHits = new OsuSpriteText { Font = font },
+                            hitsPerPlay = new OsuSpriteText { Font = font },
                             maximumCombo = new OsuSpriteText { Font = font },
                             replaysWatched = new OsuSpriteText { Font = font },
                         }
@@ -88,6 +91,11 @@ namespace osu.Game.Overlays.Profile.Header.Components
             User.BindValueChanged(user => updateStatistics(user.NewValue?.User.Statistics), true);
         }
 
+        private int getHitsPerPlay(UserStatistics statistics)
+        {
+            return statistics.PlayCount == 0 ? 0 : statistics.TotalHits / statistics.PlayCount;
+        }
+
         private void updateStatistics(UserStatistics? statistics)
         {
             if (statistics == null)
@@ -103,6 +111,7 @@ namespace osu.Game.Overlays.Profile.Header.Components
             playCount.Text = statistics.PlayCount.ToLocalisableString(@"N0");
             totalScore.Text = statistics.TotalScore.ToLocalisableString(@"N0");
             totalHits.Text = statistics.TotalHits.ToLocalisableString(@"N0");
+            hitsPerPlay.Text = getHitsPerPlay(statistics).ToLocalisableString(@"N0");
             maximumCombo.Text = statistics.MaxCombo.ToLocalisableString(@"N0");
             replaysWatched.Text = statistics.ReplaysWatched.ToLocalisableString(@"N0");
         }
diff --git a/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileScore.cs b/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileScore.cs
index 407e9959f0..247faaeabf 100644
--- a/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileScore.cs
+++ b/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileScore.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -262,27 +263,31 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
                 };
             }
 
+            var ppTooltipText = LocalisableString.Interpolate($@"{Score.PP:N1}pp");
+
             return new FillFlowContainer
             {
                 AutoSizeAxes = Axes.Both,
                 Direction = FillDirection.Horizontal,
                 Children = new[]
                 {
-                    new OsuSpriteText
+                    new SpriteTextWithTooltip
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
                         Font = font,
-                        Text = $"{Score.PP:0}",
-                        Colour = colourProvider.Highlight1
+                        Text = Score.PP.ToLocalisableString(@"N0"),
+                        TooltipText = ppTooltipText,
+                        Colour = colourProvider.Highlight1,
                     },
-                    new OsuSpriteText
+                    new SpriteTextWithTooltip
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
                         Font = font.With(size: 12),
-                        Text = "pp",
-                        Colour = colourProvider.Light3
+                        Text = @"pp",
+                        TooltipText = ppTooltipText,
+                        Colour = colourProvider.Light3,
                     }
                 }
             };
diff --git a/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileWeightedScore.cs b/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileWeightedScore.cs
index 6cfe34ec6f..36b20d0be5 100644
--- a/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileWeightedScore.cs
+++ b/osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileWeightedScore.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API.Requests.Responses;
@@ -44,7 +45,9 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
                             Child = new OsuSpriteText
                             {
                                 Font = OsuFont.GetFont(size: 14, weight: FontWeight.Bold, italics: true),
-                                Text = Score.PP.HasValue ? $"{Score.PP * weight:0}pp" : string.Empty,
+                                Text = Score.PP.HasValue
+                                    ? LocalisableString.Interpolate($"{Score.PP * weight:N0}pp")
+                                    : string.Empty,
                             },
                         }
                     }
diff --git a/osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs b/osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs
index e05d20a5db..b839c98f9f 100644
--- a/osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Audio/OffsetSettings.cs
@@ -26,6 +26,12 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                 {
                     Current = config.GetBindable<double>(OsuSetting.AudioOffset),
                 },
+                new SettingsCheckbox
+                {
+                    LabelText = AudioSettingsStrings.AdjustBeatmapOffsetAutomatically,
+                    TooltipText = AudioSettingsStrings.AdjustBeatmapOffsetAutomaticallyTooltip,
+                    Current = config.GetBindable<bool>(OsuSetting.AutomaticallyAdjustBeatmapOffset),
+                }
             };
         }
     }
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/General/UpdateSettings.cs b/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
index f0428a4c92..596e4b2589 100644
--- a/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
@@ -12,6 +12,7 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Statistics;
 using osu.Game.Configuration;
+using osu.Game.IO;
 using osu.Game.Localisation;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays.Dialog;
@@ -38,21 +39,21 @@ namespace osu.Game.Overlays.Settings.Sections.General
         [Resolved]
         private INotificationOverlay? notifications { get; set; }
 
-        [Resolved]
-        private Storage storage { get; set; } = null!;
-
         [Resolved]
         private OsuGame? game { get; set; }
 
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
+        private Storage exportStorage = null!;
+
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load(OsuConfigManager config, Storage storage)
         {
             config.BindWith(OsuSetting.ReleaseStream, configReleaseStream);
 
             bool isDesktop = RuntimeInfo.IsDesktop;
+            bool supportsExport = RuntimeInfo.OS != RuntimeInfo.Platform.Android;
             bool canCheckUpdates = updateManager?.CanCheckForUpdate == true;
 
             if (canCheckUpdates)
@@ -95,20 +96,28 @@ namespace osu.Game.Overlays.Settings.Sections.General
                     Keywords = new[] { @"logs", @"files", @"access", "directory" },
                     Action = () => storage.PresentExternally(),
                 });
+            }
 
+            if (supportsExport)
+            {
                 Add(new SettingsButton
                 {
                     Text = GeneralSettingsStrings.ExportLogs,
                     Keywords = new[] { @"bug", "report", "logs", "files" },
                     Action = () => Task.Run(exportLogs),
                 });
+            }
 
+            if (isDesktop)
+            {
                 Add(new SettingsButton
                 {
                     Text = GeneralSettingsStrings.ChangeFolderLocation,
                     Action = () => game?.PerformFromScreen(menu => menu.Push(new MigrationSelectScreen()))
                 });
             }
+
+            exportStorage = (storage as OsuStorage)?.GetExportStorage() ?? storage.GetStorageForDirectory(@"exports");
         }
 
         private void releaseStreamChanged(ValueChangedEvent<ReleaseStream> stream)
@@ -178,7 +187,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
             notifications?.Post(notification);
 
-            const string archive_filename = "exports/compressed-logs.zip";
+            const string archive_filename = "compressed-logs.zip";
 
             try
             {
@@ -187,7 +196,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
                 var logStorage = Logger.Storage;
 
-                using (var outStream = storage.CreateFileSafely(archive_filename))
+                using (var outStream = exportStorage.CreateFileSafely(archive_filename))
                 using (var zip = ZipArchive.Create())
                 {
                     foreach (string? f in logStorage.GetFiles(string.Empty, "*.log"))
@@ -201,12 +210,12 @@ namespace osu.Game.Overlays.Settings.Sections.General
                 notification.State = ProgressNotificationState.Cancelled;
 
                 // cleanup if export is failed or canceled.
-                storage.Delete(archive_filename);
+                exportStorage.Delete(archive_filename);
                 throw;
             }
 
             notification.CompletionText = "Exported logs! Click to view.";
-            notification.CompletionClickAction = () => storage.PresentFileExternally(archive_filename);
+            notification.CompletionClickAction = () => exportStorage.PresentFileExternally(archive_filename);
 
             notification.State = ProgressNotificationState.Completed;
         }
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index eef8030121..764f5fdfb6 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -310,11 +310,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/Difficulty/RulesetBeatmapDifficulty.cs b/osu.Game/Rulesets/Difficulty/RulesetBeatmapDifficulty.cs
new file mode 100644
index 0000000000..db76974c44
--- /dev/null
+++ b/osu.Game/Rulesets/Difficulty/RulesetBeatmapDifficulty.cs
@@ -0,0 +1,67 @@
+// 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.Graphics;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Rulesets.Difficulty
+{
+    /// <summary>
+    /// A <see cref="RulesetBeatmapAttribute"/> is like a single property from <see cref="BeatmapDifficulty"/>,
+    /// but adjusted for display in the context of a specific ruleset.
+    /// The reason why this record exists is that rulesets use <see cref="BeatmapDifficulty"/> in different ways.
+    /// Some rulesets completely ignore some fields from <see cref="BeatmapDifficulty"/>,
+    /// some reuse fields in weird ways (like mania reusing <see cref="BeatmapDifficulty.CircleSize"/> to mean key count),
+    /// some want to provide specific extended information for a <see cref="BeatmapDifficulty"/> field
+    /// or adjust the "effective display" in different ways.
+    /// </summary>
+    public class RulesetBeatmapAttribute
+    {
+        /// <summary>
+        /// The long label for this beatmap attribute.
+        /// </summary>
+        public LocalisableString Label { get; }
+
+        /// <summary>
+        /// A two-letter acronym for this beatmap attribute.
+        /// </summary>
+        public string Acronym { get; }
+
+        /// <summary>
+        /// The value of this attribute before application of mods.
+        /// </summary>
+        public float OriginalValue { get; }
+
+        /// <summary>
+        /// The "effective" value of this attribute after application of mods.
+        /// </summary>
+        public float AdjustedValue { get; }
+
+        /// <summary>
+        /// The highest allowable value of this attribute.
+        /// </summary>
+        public float MaxValue { get; }
+
+        /// <summary>
+        /// An optional extended description of this attribute.
+        /// </summary>
+        public LocalisableString? Description { get; init; }
+
+        /// <summary>
+        /// Contains any and all additional metrics about how this attribute affects gameplay to show to the users.
+        /// </summary>
+        public AdditionalMetric[] AdditionalMetrics { get; init; } = [];
+
+        public RulesetBeatmapAttribute(LocalisableString label, string acronym, float originalValue, float adjustedValue, float maxValue)
+        {
+            Label = label;
+            Acronym = acronym;
+            OriginalValue = originalValue;
+            AdjustedValue = adjustedValue;
+            MaxValue = maxValue;
+        }
+
+        public record AdditionalMetric(LocalisableString Name, LocalisableString Value, Colour4? Colour = null);
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/BeatmapVerifier.cs b/osu.Game/Rulesets/Edit/BeatmapVerifier.cs
index e1c0815dac..f780472f20 100644
--- a/osu.Game/Rulesets/Edit/BeatmapVerifier.cs
+++ b/osu.Game/Rulesets/Edit/BeatmapVerifier.cs
@@ -19,6 +19,7 @@ namespace osu.Game.Rulesets.Edit
             new CheckBackgroundPresence(),
             new CheckBackgroundQuality(),
             new CheckVideoResolution(),
+            new CheckVideoUsage(),
 
             // Audio
             new CheckAudioPresence(),
@@ -30,6 +31,7 @@ namespace osu.Game.Rulesets.Edit
             new CheckDelayedHitsounds(),
             new CheckSongFormat(),
             new CheckHitsoundsFormat(),
+            new CheckInconsistentAudio(),
 
             // Files
             new CheckZeroByteFiles(),
@@ -42,12 +44,18 @@ namespace osu.Game.Rulesets.Edit
 
             // Timing
             new CheckPreviewTime(),
+            new CheckInconsistentTimingControlPoints(),
 
             // Events
             new CheckBreaks(),
 
             // Metadata
             new CheckTitleMarkers(),
+            new CheckInconsistentMetadata(),
+            new CheckMissingGenreLanguage(),
+
+            // Settings
+            new CheckInconsistentSettings(),
         };
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
diff --git a/osu.Game/Rulesets/Edit/BeatmapVerifierContext.cs b/osu.Game/Rulesets/Edit/BeatmapVerifierContext.cs
index 53bdf3140c..731a33b3ca 100644
--- a/osu.Game/Rulesets/Edit/BeatmapVerifierContext.cs
+++ b/osu.Game/Rulesets/Edit/BeatmapVerifierContext.cs
@@ -1,6 +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.
 
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Rulesets.Edit
@@ -12,25 +14,76 @@ namespace osu.Game.Rulesets.Edit
     public class BeatmapVerifierContext
     {
         /// <summary>
-        /// The playable beatmap instance of the current beatmap.
+        /// Collects the constituent parts of a beatmap being verified.
         /// </summary>
-        public readonly IBeatmap Beatmap;
-
-        /// <summary>
-        /// The working beatmap instance of the current beatmap.
-        /// </summary>
-        public readonly IWorkingBeatmap WorkingBeatmap;
+        /// <param name="Working">
+        /// Use this to access beatmap resources like its track, storyboard, waveform, or similar.
+        /// </param>
+        /// <param name="Playable">
+        /// The <see cref="IBeatmap"/> in its actual playable state after beatmap conversion.
+        /// Use this to inspect the actual beatmap contents, like its hitobjects, timing points, breaks, etc.
+        /// </param>
+        public record VerifiedBeatmap(IWorkingBeatmap Working, IBeatmap Playable);
 
         /// <summary>
         /// The difficulty level which the current beatmap is considered to be.
         /// </summary>
         public DifficultyRating InterpretedDifficulty;
 
-        public BeatmapVerifierContext(IBeatmap beatmap, IWorkingBeatmap workingBeatmap, DifficultyRating difficultyRating = DifficultyRating.ExpertPlus)
+        /// <summary>
+        /// The current beatmap being checked.
+        /// </summary>
+        public readonly VerifiedBeatmap CurrentDifficulty;
+
+        /// <summary>
+        /// Other beatmaps in the same beatmapset.
+        /// </summary>
+        public readonly IReadOnlyList<VerifiedBeatmap> OtherDifficulties;
+
+        /// <summary>
+        /// All beatmaps in the same beatmapset.
+        /// </summary>
+        public IEnumerable<VerifiedBeatmap> AllDifficulties => OtherDifficulties.Prepend(CurrentDifficulty);
+
+        public BeatmapVerifierContext(VerifiedBeatmap currentDifficulty, IReadOnlyList<VerifiedBeatmap> otherDifficulties, DifficultyRating difficultyRating)
         {
-            Beatmap = beatmap;
-            WorkingBeatmap = workingBeatmap;
+            CurrentDifficulty = currentDifficulty;
             InterpretedDifficulty = difficultyRating;
+            OtherDifficulties = otherDifficulties;
+        }
+
+        /// <summary>
+        /// Backwards-compatible constructor that allows creating a context from a single playable and working beatmap.
+        /// </summary>
+        public BeatmapVerifierContext(IBeatmap beatmap, IWorkingBeatmap workingBeatmap, DifficultyRating difficultyRating = DifficultyRating.ExpertPlus)
+            : this(new VerifiedBeatmap(workingBeatmap, beatmap), [], difficultyRating)
+        {
+        }
+
+        public static BeatmapVerifierContext Create(IBeatmap beatmap, IWorkingBeatmap workingBeatmap, DifficultyRating difficultyRating = DifficultyRating.ExpertPlus, BeatmapManager? beatmapManager = null)
+        {
+            var beatmapSet = beatmap.BeatmapInfo.BeatmapSet;
+
+            var current = new VerifiedBeatmap(workingBeatmap, beatmap);
+
+            if (beatmapSet?.Beatmaps == null || beatmapSet.Beatmaps.Count == 1)
+                return new BeatmapVerifierContext(current, [], difficultyRating);
+
+            var others = new List<VerifiedBeatmap>();
+
+            foreach (var info in beatmapSet.Beatmaps)
+            {
+                if (info.Equals(beatmap.BeatmapInfo))
+                    continue;
+
+                var otherWorking = beatmapManager?.GetWorkingBeatmap(info);
+                var otherPlayable = otherWorking?.GetPlayableBeatmap(info.Ruleset);
+
+                if (otherWorking != null && otherPlayable != null)
+                    others.Add(new VerifiedBeatmap(otherWorking, otherPlayable));
+            }
+
+            return new BeatmapVerifierContext(current, others, difficultyRating);
         }
     }
 }
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckAudioInVideo.cs b/osu.Game/Rulesets/Edit/Checks/CheckAudioInVideo.cs
index 005902a8a1..6c400c5de8 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckAudioInVideo.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckAudioInVideo.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 {
     public class CheckAudioInVideo : ICheck
     {
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Audio track in video files");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Audio track in video files", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -27,10 +27,10 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
             var videoPaths = new List<string>();
 
-            foreach (var layer in context.WorkingBeatmap.Storyboard.Layers)
+            foreach (var layer in context.CurrentDifficulty.Working.Storyboard.Layers)
             {
                 foreach (var element in layer.Elements)
                 {
@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Edit.Checks
                 try
                 {
                     // We use TagLib here for platform invariance; BASS cannot detect audio presence on Linux.
-                    using (Stream data = context.WorkingBeatmap.GetStream(storagePath))
+                    using (Stream data = context.CurrentDifficulty.Working.GetStream(storagePath))
                     using (File tagFile = TagLibUtils.GetTagLibFile(filename, data))
                     {
                         if (tagFile.Properties.AudioChannels == 0)
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs b/osu.Game/Rulesets/Edit/Checks/CheckAudioQuality.cs
index 440d4e8e62..26021716a0 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,14 +10,15 @@ 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.
         private const int min_bitrate = 128;
 
-        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Audio, "Too high or low audio bitrate");
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Audio, "Too high or low audio bitrate", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -27,18 +29,25 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            string audioFile = context.Beatmap.Metadata.AudioFile;
+            string audioFile = context.CurrentDifficulty.Playable.Metadata.AudioFile;
             if (string.IsNullOrEmpty(audioFile))
                 yield break;
 
-            var track = context.WorkingBeatmap.Track;
+            var track = context.CurrentDifficulty.Working.Track;
 
             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/CheckBackgroundQuality.cs b/osu.Game/Rulesets/Edit/Checks/CheckBackgroundQuality.cs
index 5008c13d9a..1147ff9663 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckBackgroundQuality.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckBackgroundQuality.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Edit.Checks
         private const int low_width = 960;
         private const int low_height = 540;
 
-        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Resources, "Too high or low background resolution");
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Resources, "Too high or low background resolution", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -33,11 +33,11 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            string backgroundFile = context.Beatmap.Metadata.BackgroundFile;
+            string backgroundFile = context.CurrentDifficulty.Playable.Metadata.BackgroundFile;
             if (string.IsNullOrEmpty(backgroundFile))
                 yield break;
 
-            var texture = context.WorkingBeatmap.GetBackground();
+            var texture = context.CurrentDifficulty.Working.GetBackground();
             if (texture == null)
                 yield break;
 
@@ -49,9 +49,9 @@ namespace osu.Game.Rulesets.Edit.Checks
             else if (texture.Width < low_width || texture.Height < low_height)
                 yield return new IssueTemplateLowResolution(this).Create(texture.Width, texture.Height);
 
-            string? storagePath = context.Beatmap.BeatmapInfo.BeatmapSet?.GetPathForFile(backgroundFile);
+            string? storagePath = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet?.GetPathForFile(backgroundFile);
 
-            using (Stream stream = context.WorkingBeatmap.GetStream(storagePath))
+            using (Stream stream = context.CurrentDifficulty.Working.GetStream(storagePath))
             {
                 double filesizeMb = stream.Length / (1024d * 1024d);
 
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs b/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
index f7be36beab..e16629d760 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
@@ -25,10 +25,10 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var startTimes = context.Beatmap.HitObjects.Select(ho => ho.StartTime).Order().ToList();
-            var endTimes = context.Beatmap.HitObjects.Select(ho => ho.GetEndTime()).Order().ToList();
+            var startTimes = context.CurrentDifficulty.Playable.HitObjects.Select(ho => ho.StartTime).Order().ToList();
+            var endTimes = context.CurrentDifficulty.Playable.HitObjects.Select(ho => ho.GetEndTime()).Order().ToList();
 
-            foreach (var breakPeriod in context.Beatmap.Breaks)
+            foreach (var breakPeriod in context.CurrentDifficulty.Playable.Breaks)
             {
                 if (breakPeriod.Duration < BreakPeriod.MIN_BREAK_DURATION)
                     yield return new IssueTemplateTooShort(this).Create(breakPeriod.StartTime);
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs
index c0089e6fe2..75b5b08c7f 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using osu.Game.Rulesets.Edit.Checks.Components;
 using osu.Game.Rulesets.Objects;
+using System;
 
 namespace osu.Game.Rulesets.Edit.Checks
 {
@@ -11,18 +12,19 @@ namespace osu.Game.Rulesets.Edit.Checks
     {
         // We guarantee that the objects are either treated as concurrent or unsnapped when near the same beat divisor.
         private const double ms_leniency = CheckUnsnappedObjects.UNSNAP_MS_THRESHOLD;
+        private const double almost_concurrent_threshold = 10.0;
 
         public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Compose, "Concurrent hitobjects");
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
-            new IssueTemplateConcurrentSame(this),
-            new IssueTemplateConcurrentDifferent(this)
+            new IssueTemplateConcurrent(this),
+            new IssueTemplateAlmostConcurrent(this)
         };
 
         public virtual IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var hitObjects = context.Beatmap.HitObjects;
+            var hitObjects = context.CurrentDifficulty.Playable.HitObjects;
 
             for (int i = 0; i < hitObjects.Count - 1; ++i)
             {
@@ -33,50 +35,66 @@ namespace osu.Game.Rulesets.Edit.Checks
                     var nextHitobject = hitObjects[j];
 
                     // Two hitobjects cannot be concurrent without also being concurrent with all objects in between.
-                    // So if the next object is not concurrent, then we know no future objects will be either.
-                    if (!AreConcurrent(hitobject, nextHitobject))
+                    // So if the next object is not concurrent or almost concurrent, then we know no future objects will be either.
+                    if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject))
                         break;
 
-                    if (hitobject.GetType() == nextHitobject.GetType())
-                        yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject);
-                    else
-                        yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject);
+                    if (AreConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject);
+                    }
+                    else if (AreAlmostConcurrent(hitobject, nextHitobject))
+                    {
+                        yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject);
+                    }
                 }
             }
         }
 
         protected bool AreConcurrent(HitObject hitobject, HitObject nextHitobject) => nextHitobject.StartTime <= hitobject.GetEndTime() + ms_leniency;
 
-        public abstract class IssueTemplateConcurrent : IssueTemplate
+        protected bool AreAlmostConcurrent(HitObject hitobject, HitObject nextHitobject) =>
+            Math.Abs(nextHitobject.StartTime - hitobject.GetEndTime()) < almost_concurrent_threshold;
+
+        public class IssueTemplateConcurrent : IssueTemplate
         {
-            protected IssueTemplateConcurrent(ICheck check, string unformattedMessage)
-                : base(check, IssueType.Problem, unformattedMessage)
+            public IssueTemplateConcurrent(ICheck check)
+                : base(check, IssueType.Problem, "{0}")
             {
             }
 
             public Issue Create(HitObject hitobject, HitObject nextHitobject)
             {
                 var hitobjects = new List<HitObject> { hitobject, nextHitobject };
-                return new Issue(hitobjects, this, hitobject.GetType().Name, nextHitobject.GetType().Name)
+                string message = hitobject.GetType() == nextHitobject.GetType()
+                    ? $"{hitobject.GetType().Name}s are concurrent here."
+                    : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are concurrent here.";
+
+                return new Issue(hitobjects, this, message)
                 {
                     Time = nextHitobject.StartTime
                 };
             }
         }
 
-        public class IssueTemplateConcurrentSame : IssueTemplateConcurrent
+        public class IssueTemplateAlmostConcurrent : IssueTemplate
         {
-            public IssueTemplateConcurrentSame(ICheck check)
-                : base(check, "{0}s are concurrent here.")
+            public IssueTemplateAlmostConcurrent(ICheck check)
+                : base(check, IssueType.Problem, "{0}")
             {
             }
-        }
 
-        public class IssueTemplateConcurrentDifferent : IssueTemplateConcurrent
-        {
-            public IssueTemplateConcurrentDifferent(ICheck check)
-                : base(check, "{0} and {1} are concurrent here.")
+            public Issue Create(HitObject hitobject, HitObject nextHitobject)
             {
+                var hitobjects = new List<HitObject> { hitobject, nextHitobject };
+                string message = hitobject.GetType() == nextHitobject.GetType()
+                    ? $"{hitobject.GetType().Name}s are less than {almost_concurrent_threshold}ms apart."
+                    : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are less than {almost_concurrent_threshold}ms apart.";
+
+                return new Issue(hitobjects, this, message)
+                {
+                    Time = nextHitobject.StartTime
+                };
             }
         }
     }
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckDelayedHitsounds.cs b/osu.Game/Rulesets/Edit/Checks/CheckDelayedHitsounds.cs
index ee950248db..4f64f8838f 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckDelayedHitsounds.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckDelayedHitsounds.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Edit.Checks
         private const int delay_threshold = 5;
         private const int delay_threshold_negligible = 1;
 
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Delayed hit sounds.");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Delayed hit sounds.", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -37,14 +37,14 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
 
             if (beatmapSet == null)
                 yield break;
 
             foreach (var file in beatmapSet.Files)
             {
-                using (Stream? stream = context.WorkingBeatmap.GetStream(file.File.GetStoragePath()))
+                using (Stream? stream = context.CurrentDifficulty.Working.GetStream(file.File.GetStoragePath()))
                 {
                     if (stream == null)
                         continue;
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckDrainLength.cs b/osu.Game/Rulesets/Edit/Checks/CheckDrainLength.cs
index ac65dfadff..3115f80e66 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckDrainLength.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckDrainLength.cs
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            double drainTime = context.Beatmap.CalculateDrainLength();
+            double drainTime = context.CurrentDifficulty.Playable.CalculateDrainLength();
 
             if (drainTime < min_drain_threshold)
                 yield return new IssueTemplateTooShort(this).Create((int)(drainTime / 1000));
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckFewHitsounds.cs b/osu.Game/Rulesets/Edit/Checks/CheckFewHitsounds.cs
index 97c1519c24..941cebdb4f 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckFewHitsounds.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckFewHitsounds.cs
@@ -48,16 +48,16 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            if (!context.Beatmap.HitObjects.Any())
+            if (!context.CurrentDifficulty.Playable.HitObjects.Any())
                 yield break;
 
             mapHasHitsounds = false;
             objectsWithoutHitsounds = 0;
-            lastHitsoundTime = context.Beatmap.HitObjects.First().StartTime;
+            lastHitsoundTime = context.CurrentDifficulty.Playable.HitObjects.First().StartTime;
 
             var hitObjectsIncludingNested = new List<HitObject>();
 
-            foreach (var hitObject in context.Beatmap.HitObjects)
+            foreach (var hitObject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 // Samples play on the end of objects. Some objects have nested objects to accomplish playing them elsewhere (e.g. slider head/repeat).
                 foreach (var nestedHitObject in hitObject.NestedHitObjects)
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckFilePresence.cs b/osu.Game/Rulesets/Edit/Checks/CheckFilePresence.cs
index 9a921ba808..158811044c 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckFilePresence.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckFilePresence.cs
@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Edit.Checks
         protected abstract string TypeOfFile { get; }
         protected abstract string? GetFilename(IBeatmap beatmap);
 
-        public CheckMetadata Metadata => new CheckMetadata(Category, $"Missing {TypeOfFile}");
+        public CheckMetadata Metadata => new CheckMetadata(Category, $"Missing {TypeOfFile}", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            string? filename = GetFilename(context.Beatmap);
+            string? filename = GetFilename(context.CurrentDifficulty.Playable);
 
             if (string.IsNullOrEmpty(filename))
             {
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Edit.Checks
             }
 
             // If the file is set, also make sure it still exists.
-            string? storagePath = context.Beatmap.BeatmapInfo.BeatmapSet?.GetPathForFile(filename);
+            string? storagePath = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet?.GetPathForFile(filename);
             if (storagePath != null)
                 yield break;
 
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckHitsoundsFormat.cs b/osu.Game/Rulesets/Edit/Checks/CheckHitsoundsFormat.cs
index 9b6a861358..d28de45fe9 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckHitsoundsFormat.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckHitsoundsFormat.cs
@@ -7,13 +7,14 @@ using ManagedBass;
 using osu.Framework.Audio.Callbacks;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
+using osu.Game.Models;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Edit.Checks
 {
     public class CheckHitsoundsFormat : ICheck
     {
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Checks for hitsound formats.");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Checks for hitsound formats.", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -23,16 +24,25 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
-            var audioFile = beatmapSet?.GetFile(context.Beatmap.Metadata.AudioFile);
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
 
             if (beatmapSet == null) yield break;
 
+            // Collect all audio files from all difficulties to exclude them from the check, as they aren't hitsounds.
+            var audioFiles = new HashSet<RealmNamedFileUsage>(ReferenceEqualityComparer.Instance);
+
+            foreach (var difficulty in context.AllDifficulties)
+            {
+                var audioFile = beatmapSet.GetFile(difficulty.Playable.Metadata.AudioFile);
+                if (audioFile != null)
+                    audioFiles.Add(audioFile);
+            }
+
             foreach (var file in beatmapSet.Files)
             {
-                if (audioFile != null && ReferenceEquals(file.File, audioFile.File)) continue;
+                if (audioFiles.Contains(file)) continue;
 
-                using (Stream data = context.WorkingBeatmap.GetStream(file.File.GetStoragePath()))
+                using (Stream data = context.CurrentDifficulty.Working.GetStream(file.File.GetStoragePath()))
                 {
                     if (data == null)
                         continue;
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckInconsistentAudio.cs b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentAudio.cs
new file mode 100644
index 0000000000..19f272244e
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentAudio.cs
@@ -0,0 +1,53 @@
+// 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.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckInconsistentAudio : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Inconsistent audio files", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateInconsistentAudio(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.AllDifficulties.Count() <= 1)
+                yield break;
+
+            var referenceBeatmap = context.CurrentDifficulty.Playable;
+            string referenceAudioFile = referenceBeatmap.Metadata.AudioFile;
+
+            foreach (var beatmap in context.OtherDifficulties)
+            {
+                string currentAudioFile = beatmap.Playable.Metadata.AudioFile;
+
+                if (referenceAudioFile != currentAudioFile)
+                {
+                    yield return new IssueTemplateInconsistentAudio(this).Create(
+                        string.IsNullOrEmpty(referenceAudioFile) ? "not set" : referenceAudioFile,
+                        beatmap.Playable.BeatmapInfo.DifficultyName,
+                        string.IsNullOrEmpty(currentAudioFile) ? "not set" : currentAudioFile
+                    );
+                }
+            }
+        }
+
+        public class IssueTemplateInconsistentAudio : IssueTemplate
+        {
+            public IssueTemplateInconsistentAudio(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent audio file between this difficulty ({0}) and \"{1}\" ({2}).")
+            {
+            }
+
+            public Issue Create(string referenceAudio, string otherDifficulty, string otherAudio)
+                => new Issue(this, referenceAudio, otherDifficulty, otherAudio);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckInconsistentMetadata.cs b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentMetadata.cs
new file mode 100644
index 0000000000..fdb72a3871
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentMetadata.cs
@@ -0,0 +1,105 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckInconsistentMetadata : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Metadata, "Inconsistent metadata", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateInconsistentTags(this),
+            new IssueTemplateInconsistentOtherFields(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.AllDifficulties.Count() <= 1)
+                yield break;
+
+            var referenceBeatmap = context.CurrentDifficulty.Playable;
+            var referenceMetadata = referenceBeatmap.Metadata;
+
+            // Define metadata fields to check
+            var fieldsToCheck = new (string fieldName, Func<BeatmapMetadata, string> fieldSelector)[]
+            {
+                ("artist", m => m.Artist),
+                ("unicode artist", m => m.ArtistUnicode),
+                ("title", m => m.Title),
+                ("unicode title", m => m.TitleUnicode),
+                ("source", m => m.Source),
+                ("creator", m => m.Author.Username)
+            };
+
+            foreach (var beatmap in context.OtherDifficulties)
+            {
+                var currentMetadata = beatmap.Playable.Metadata;
+
+                // Check each metadata field for inconsistencies
+                foreach ((string fieldName, var fieldSelector) in fieldsToCheck)
+                {
+                    string referenceField = fieldSelector(referenceMetadata);
+                    string currentField = fieldSelector(currentMetadata);
+
+                    if (referenceField != currentField)
+                    {
+                        yield return new IssueTemplateInconsistentOtherFields(this).Create(
+                            fieldName,
+                            referenceBeatmap.BeatmapInfo.DifficultyName,
+                            beatmap.Playable.BeatmapInfo.DifficultyName,
+                            referenceField,
+                            currentField
+                        );
+                    }
+                }
+
+                // Special handling for tags
+                if (referenceMetadata.Tags != currentMetadata.Tags)
+                {
+                    var differenceTags = referenceMetadata.Tags.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToHashSet();
+                    differenceTags.SymmetricExceptWith(currentMetadata.Tags.Split(' ', StringSplitOptions.RemoveEmptyEntries));
+
+                    string difference = string.Join(" ", differenceTags);
+
+                    if (!string.IsNullOrEmpty(difference))
+                    {
+                        yield return new IssueTemplateInconsistentTags(this).Create(
+                            referenceBeatmap.BeatmapInfo.DifficultyName,
+                            beatmap.Playable.BeatmapInfo.DifficultyName,
+                            difference
+                        );
+                    }
+                }
+            }
+        }
+
+        public class IssueTemplateInconsistentTags : IssueTemplate
+        {
+            public IssueTemplateInconsistentTags(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent tags between \"{0}\" and \"{1}\", difference being \"{2}\".")
+            {
+            }
+
+            public Issue Create(string referenceDifficulty, string currentDifficulty, string difference)
+                => new Issue(this, referenceDifficulty, currentDifficulty, difference);
+        }
+
+        public class IssueTemplateInconsistentOtherFields : IssueTemplate
+        {
+            public IssueTemplateInconsistentOtherFields(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent {0} fields between \"{1}\" and \"{2}\"; \"{3}\" and \"{4}\" respectively.")
+            {
+            }
+
+            public Issue Create(string fieldName, string referenceDifficulty, string currentDifficulty, string referenceValue, string currentValue)
+                => new Issue(this, fieldName, referenceDifficulty, currentDifficulty, referenceValue, currentValue);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckInconsistentSettings.cs b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentSettings.cs
new file mode 100644
index 0000000000..caab0c5ff4
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentSettings.cs
@@ -0,0 +1,81 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckInconsistentSettings : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Inconsistent settings", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateInconsistentSetting(this, IssueType.Warning),
+            new IssueTemplateInconsistentSetting(this, IssueType.Negligible)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.AllDifficulties.Count() <= 1)
+                return [];
+
+            var referenceBeatmap = context.CurrentDifficulty.Playable;
+
+            bool hasStoryboard = ResourcesCheckUtils.HasAnyStoryboardElementPresent(context.CurrentDifficulty.Working);
+
+            var issues = new List<Issue>();
+
+            // Define fields to check
+            checkIssue(IssueType.Warning, "Audio lead-in", b => b.AudioLeadIn);
+            checkIssue(IssueType.Warning, "Countdown", b => b.Countdown);
+            checkIssue(IssueType.Warning, "Countdown offset", b => b.CountdownOffset);
+            checkIssue(IssueType.Warning, "Epilepsy warning", b => b.EpilepsyWarning);
+            checkIssue(IssueType.Warning, "Letterbox during breaks", b => b.LetterboxInBreaks);
+            checkIssue(IssueType.Warning, "Samples match playback rate", b => b.SamplesMatchPlaybackRate);
+
+            if (hasStoryboard)
+                checkIssue(IssueType.Warning, "Widescreen support", b => b.WidescreenStoryboard);
+
+            checkIssue(IssueType.Negligible, "Tick Rate", b => b.Difficulty.SliderTickRate);
+            return issues;
+
+            void checkIssue<T>(IssueType issueType, string fieldName, Func<IBeatmap, T> fieldSelector)
+                where T : notnull // ideally this'd be `T : IEquatable<T>` but `Enum` doesn't implement it...
+            {
+                var referenceValue = fieldSelector(referenceBeatmap);
+
+                foreach (var beatmap in context.OtherDifficulties)
+                {
+                    var currentValue = fieldSelector(beatmap.Playable);
+
+                    if (!EqualityComparer<T>.Default.Equals(currentValue, referenceValue))
+                    {
+                        issues.Add(new IssueTemplateInconsistentSetting(this, issueType).Create(
+                            fieldName,
+                            referenceBeatmap.BeatmapInfo.DifficultyName,
+                            beatmap.Playable.BeatmapInfo.DifficultyName,
+                            referenceValue.ToString() ?? string.Empty,
+                            currentValue.ToString() ?? string.Empty
+                        ));
+                    }
+                }
+            }
+        }
+
+        public class IssueTemplateInconsistentSetting : IssueTemplate
+        {
+            public IssueTemplateInconsistentSetting(ICheck check, IssueType issueType)
+                : base(check, issueType, "Inconsistent \"{0}\" setting between \"{1}\" and \"{2}\"; \"{3}\" and \"{4}\" respectively.")
+            {
+            }
+
+            public Issue Create(string fieldName, string referenceDifficulty, string currentDifficulty, string referenceValue, string currentValue)
+                => new Issue(this, fieldName, referenceDifficulty, currentDifficulty, referenceValue, currentValue);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckInconsistentTimingControlPoints.cs b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentTimingControlPoints.cs
new file mode 100644
index 0000000000..d30f575fc7
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckInconsistentTimingControlPoints.cs
@@ -0,0 +1,144 @@
+// 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 osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckInconsistentTimingControlPoints : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Timing, "Inconsistent timing control points", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateMissingTimingPoint(this),
+            new IssueTemplateExtraTimingPoint(this),
+            new IssueTemplateMissingTimingPointMinor(this),
+            new IssueTemplateInconsistentMeter(this),
+            new IssueTemplateInconsistentBPM(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.AllDifficulties.Count() <= 1)
+                yield break;
+
+            // Use the current difficulty as reference
+            var referenceBeatmap = context.CurrentDifficulty.Playable;
+            var referenceTimingPoints = referenceBeatmap.ControlPointInfo.TimingPoints;
+
+            foreach (var beatmap in context.OtherDifficulties)
+            {
+                var timingPoints = beatmap.Playable.ControlPointInfo.TimingPoints;
+
+                // Check each timing point in the reference against this difficulty
+                foreach (var referencePoint in referenceTimingPoints)
+                {
+                    var matchingPoint = TimingCheckUtils.FindMatchingTimingPoint(timingPoints, referencePoint.Time);
+                    var exactMatchingPoint = TimingCheckUtils.FindExactMatchingTimingPoint(timingPoints, referencePoint.Time);
+
+                    string currentDifficultyName = beatmap.Playable.BeatmapInfo.DifficultyName;
+
+                    if (matchingPoint == null)
+                    {
+                        yield return new IssueTemplateMissingTimingPoint(this).Create(referencePoint.Time, currentDifficultyName);
+                    }
+                    else
+                    {
+                        // Check for meter signature inconsistency
+                        if (!referencePoint.TimeSignature.Equals(matchingPoint.TimeSignature))
+                        {
+                            yield return new IssueTemplateInconsistentMeter(this).Create(referencePoint.Time, currentDifficultyName);
+                        }
+
+                        // Check for BPM inconsistency
+                        if (Math.Abs(referencePoint.BeatLength - matchingPoint.BeatLength) > TimingCheckUtils.TIME_OFFSET_TOLERANCE_MS)
+                        {
+                            yield return new IssueTemplateInconsistentBPM(this).Create(referencePoint.Time, currentDifficultyName);
+                        }
+
+                        // Check for exact timing match (decimal precision)
+                        if (exactMatchingPoint == null)
+                        {
+                            yield return new IssueTemplateMissingTimingPointMinor(this).Create(referencePoint.Time, currentDifficultyName);
+                        }
+                    }
+                }
+
+                // Check timing points in this difficulty that aren't in the reference
+                foreach (var timingPoint in timingPoints)
+                {
+                    var matchingReferencePoint = TimingCheckUtils.FindMatchingTimingPoint(referenceTimingPoints, timingPoint.Time);
+                    var exactMatchingReferencePoint = TimingCheckUtils.FindExactMatchingTimingPoint(referenceTimingPoints, timingPoint.Time);
+
+                    if (matchingReferencePoint == null)
+                    {
+                        yield return new IssueTemplateExtraTimingPoint(this).Create(timingPoint.Time, beatmap.Playable.BeatmapInfo.DifficultyName);
+                    }
+                    else if (exactMatchingReferencePoint == null)
+                    {
+                        yield return new IssueTemplateMissingTimingPointMinor(this).Create(timingPoint.Time, beatmap.Playable.BeatmapInfo.DifficultyName);
+                    }
+                }
+            }
+        }
+
+        public class IssueTemplateMissingTimingPoint : IssueTemplate
+        {
+            public IssueTemplateMissingTimingPoint(ICheck check)
+                : base(check, IssueType.Problem, "Missing timing control point in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+
+        public class IssueTemplateExtraTimingPoint : IssueTemplate
+        {
+            public IssueTemplateExtraTimingPoint(ICheck check)
+                : base(check, IssueType.Problem, "Extra timing control point in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+
+        public class IssueTemplateMissingTimingPointMinor : IssueTemplate
+        {
+            public IssueTemplateMissingTimingPointMinor(ICheck check)
+                : base(check, IssueType.Negligible, "Timing control point has decimally different offset in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+
+        public class IssueTemplateInconsistentMeter : IssueTemplate
+        {
+            public IssueTemplateInconsistentMeter(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent time signature in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+
+        public class IssueTemplateInconsistentBPM : IssueTemplate
+        {
+            public IssueTemplateInconsistentBPM(ICheck check)
+                : base(check, IssueType.Problem, "Inconsistent BPM in {0}.")
+            {
+            }
+
+            public Issue Create(double time, string difficultyName)
+                => new Issue(time, this, difficultyName);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckLowestDiffDrainTime.cs b/osu.Game/Rulesets/Edit/Checks/CheckLowestDiffDrainTime.cs
new file mode 100644
index 0000000000..7a17eac3ea
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckLowestDiffDrainTime.cs
@@ -0,0 +1,89 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public abstract class CheckLowestDiffDrainTime : ICheck
+    {
+        /// <summary>
+        /// Defines the minimum drain time thresholds for different difficulty ratings.
+        /// </summary>
+        protected abstract IEnumerable<(DifficultyRating rating, double thresholdMs, string name)> GetThresholds();
+
+        private const double break_time_leniency = 30 * 1000;
+
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Spread, "Lowest difficulty too difficult for the given drain/play time(s)");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateTooShort(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            // Filter to only include difficulties with the same ruleset as the current one
+            var difficulties = context.AllDifficulties
+                                      .Where(d => d.Playable.BeatmapInfo.Ruleset.Equals(context.CurrentDifficulty.Playable.BeatmapInfo.Ruleset))
+                                      .ToList();
+
+            if (difficulties.Count == 0)
+                yield break;
+
+            var lowestDifficulty = difficulties.OrderBy(b => b.Playable.BeatmapInfo.StarRating).First();
+
+            // Get difficulty rating for the lowest difficulty
+            DifficultyRating lowestDifficultyRating = lowestDifficulty.Playable == context.CurrentDifficulty.Playable
+                ? context.InterpretedDifficulty
+                : StarDifficulty.GetDifficultyRating(lowestDifficulty.Playable.BeatmapInfo.StarRating);
+
+            double drainTime = context.CurrentDifficulty.Playable.CalculateDrainLength();
+            double playTime = context.CurrentDifficulty.Playable.CalculatePlayableLength();
+
+            bool isHighestDifficulty = difficulties.OrderByDescending(b => b.Playable.BeatmapInfo.StarRating).First() == context.CurrentDifficulty;
+
+            // Use play time unless it's the highest difficulty and has significant breaks
+            bool canUsePlayTime = !isHighestDifficulty || context.CurrentDifficulty.Playable.TotalBreakTime < break_time_leniency;
+
+            double effectiveTime = canUsePlayTime ? playTime : drainTime;
+            double thresholdReduction = canUsePlayTime ? 0 : break_time_leniency;
+
+            // Check against thresholds based on the lowest difficulty's rating in the beatmapset
+            // Find the most appropriate threshold (highest rating that applies)
+            var applicableThreshold = GetThresholds()
+                                      .Where(t => lowestDifficultyRating >= t.rating)
+                                      .OrderByDescending(t => t.rating)
+                                      .FirstOrDefault();
+
+            if (applicableThreshold != default && effectiveTime < applicableThreshold.thresholdMs - thresholdReduction)
+            {
+                yield return new IssueTemplateTooShort(this).Create(
+                    applicableThreshold.name,
+                    canUsePlayTime ? "play" : "drain",
+                    applicableThreshold.thresholdMs - thresholdReduction,
+                    effectiveTime
+                );
+            }
+        }
+
+        public class IssueTemplateTooShort : IssueTemplate
+        {
+            public IssueTemplateTooShort(ICheck check)
+                : base(check, IssueType.Problem, "With the lowest difficulty being \"{0}\", the {1} time of this difficulty must be at least {2}, currently {3}.")
+            {
+            }
+
+            public Issue Create(string lowestDiffLevel, string timeType, double requiredTime, double currentTime)
+                => new Issue(this,
+                    lowestDiffLevel,
+                    timeType,
+                    TimeSpan.FromMilliseconds(requiredTime).ToString(@"m\:ss"),
+                    TimeSpan.FromMilliseconds(currentTime).ToString(@"m\:ss"));
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckMissingGenreLanguage.cs b/osu.Game/Rulesets/Edit/Checks/CheckMissingGenreLanguage.cs
new file mode 100644
index 0000000000..e70aa3831b
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckMissingGenreLanguage.cs
@@ -0,0 +1,70 @@
+// 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 osu.Framework.Extensions;
+using osu.Game.Overlays.BeatmapListing;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckMissingGenreLanguage : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Metadata, "Missing Genre/Language Tags", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateMissingGenre(this),
+            new IssueTemplateMissingLanguage(this),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var metadata = context.CurrentDifficulty.Playable.BeatmapInfo.Metadata;
+
+            string tags = metadata.Tags.ToLowerInvariant();
+
+            if (!hasTags<SearchGenre>(tags))
+                yield return new IssueTemplateMissingGenre(this).Create();
+
+            if (!hasTags<SearchLanguage>(tags))
+                yield return new IssueTemplateMissingLanguage(this).Create();
+        }
+
+        private bool hasTags<T>(string tags)
+            where T : struct, Enum
+        {
+            foreach (var value in Enum.GetValues<T>())
+            {
+                string[] words = value.GetDescription().ToLowerInvariant().Split(' ');
+
+                if (words.All(tags.Contains))
+                    return true;
+            }
+
+            return false;
+        }
+
+        public class IssueTemplateMissingGenre : IssueTemplate
+        {
+            public IssueTemplateMissingGenre(ICheck check)
+                : base(check, IssueType.Problem, "Missing genre tag (\"rock\", \"pop\", \"electronic\", etc), ignore if none fit.")
+            {
+            }
+
+            public Issue Create() => new Issue(this);
+        }
+
+        public class IssueTemplateMissingLanguage : IssueTemplate
+        {
+            public IssueTemplateMissingLanguage(ICheck check)
+                : base(check, IssueType.Problem, "Missing language tag (\"english\", \"japanese\", \"instrumental\", etc), ignore if none fit.")
+            {
+            }
+
+            public Issue Create() => new Issue(this);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckMutedObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckMutedObjects.cs
index a2ae1764dd..60f159bc9c 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckMutedObjects.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckMutedObjects.cs
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            foreach (var hitObject in context.Beatmap.HitObjects)
+            foreach (var hitObject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 // Worth keeping in mind: The samples of an object always play at its end time.
                 // Objects like spinners have no sound at its start because of this, while hold notes have nested objects to accomplish this.
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckPreviewTime.cs b/osu.Game/Rulesets/Edit/Checks/CheckPreviewTime.cs
index d4f9c1feaf..8260f4c245 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckPreviewTime.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckPreviewTime.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Rulesets.Edit.Checks
@@ -19,19 +18,15 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var diffList = context.Beatmap.BeatmapInfo.BeatmapSet?.Beatmaps ?? new List<BeatmapInfo>();
-            int previewTime = context.Beatmap.BeatmapInfo.Metadata.PreviewTime;
+            int previewTime = context.CurrentDifficulty.Playable.BeatmapInfo.Metadata.PreviewTime;
 
             if (previewTime == -1)
                 yield return new IssueTemplateHasNoPreviewTime(this).Create();
 
-            foreach (var diff in diffList)
+            foreach (var beatmap in context.OtherDifficulties)
             {
-                if (diff.Equals(context.Beatmap.BeatmapInfo))
-                    continue;
-
-                if (diff.Metadata.PreviewTime != previewTime)
-                    yield return new IssueTemplatePreviewTimeConflict(this).Create(diff.DifficultyName, previewTime, diff.Metadata.PreviewTime);
+                if (beatmap.Playable.BeatmapInfo.Metadata.PreviewTime != previewTime)
+                    yield return new IssueTemplatePreviewTimeConflict(this).Create(beatmap.Playable.BeatmapInfo.DifficultyName, previewTime, beatmap.Playable.BeatmapInfo.Metadata.PreviewTime);
             }
         }
 
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs b/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
index dd01fe110a..3f3b95d95b 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckSongFormat.cs
@@ -2,19 +2,16 @@
 // 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
 {
     public class CheckSongFormat : ICheck
     {
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Checks for song formats.");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Checks for song formats.", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -30,34 +27,24 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
-            var audioFile = beatmapSet?.GetFile(context.Beatmap.Metadata.AudioFile);
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
+            var audioFile = beatmapSet?.GetFile(context.CurrentDifficulty.Playable.Metadata.AudioFile);
 
             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.CurrentDifficulty.Playable.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
@@ -73,7 +60,7 @@ namespace osu.Game.Rulesets.Edit.Checks
         public class IssueTemplateIncorrectFormat : IssueTemplate
         {
             public IssueTemplateIncorrectFormat(ICheck check)
-                : base(check, IssueType.Problem, "\"{0}\" is using a incorrect format. Use mp3 or ogg for the song's audio.")
+                : base(check, IssueType.Problem, "\"{0}\" is using an incorrect format. Use mp3 or ogg for the song's audio.")
             {
             }
 
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckTitleMarkers.cs b/osu.Game/Rulesets/Edit/Checks/CheckTitleMarkers.cs
index 9c702ad58a..58cfe558e5 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckTitleMarkers.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckTitleMarkers.cs
@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 {
     public class CheckTitleMarkers : ICheck
     {
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Metadata, "Checks for incorrect formats of (TV Size) / (Game Ver.) / (Short Ver.) / (Cut Ver.) / (Sped Up Ver.) / etc in title.");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Metadata, "Checks for incorrect formats of (TV Size) / (Game Ver.) / (Short Ver.) / (Cut Ver.) / (Sped Up Ver.) / etc in title.", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -31,8 +31,8 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            string romanisedTitle = context.Beatmap.Metadata.Title;
-            string unicodeTitle = context.Beatmap.Metadata.TitleUnicode;
+            string romanisedTitle = context.CurrentDifficulty.Playable.Metadata.Title;
+            string unicodeTitle = context.CurrentDifficulty.Playable.Metadata.TitleUnicode;
 
             foreach (var check in markerChecks)
             {
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckTooShortAudioFiles.cs b/osu.Game/Rulesets/Edit/Checks/CheckTooShortAudioFiles.cs
index 3f85926e04..563e18848b 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckTooShortAudioFiles.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckTooShortAudioFiles.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Edit.Checks
     {
         private const int ms_threshold = 25;
 
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Too short audio files");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Audio, "Too short audio files", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -23,13 +23,13 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
 
             if (beatmapSet != null)
             {
                 foreach (var file in beatmapSet.Files)
                 {
-                    using (Stream data = context.WorkingBeatmap.GetStream(file.File.GetStoragePath()))
+                    using (Stream data = context.CurrentDifficulty.Working.GetStream(file.File.GetStoragePath()))
                     {
                         if (data == null)
                             continue;
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckUnsnappedObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckUnsnappedObjects.cs
index ded1bb54ca..35900cdcd0 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckUnsnappedObjects.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckUnsnappedObjects.cs
@@ -23,9 +23,9 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var controlPointInfo = context.Beatmap.ControlPointInfo;
+            var controlPointInfo = context.CurrentDifficulty.Playable.ControlPointInfo;
 
-            foreach (var hitobject in context.Beatmap.HitObjects)
+            foreach (var hitobject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 double startUnsnap = hitobject.StartTime - controlPointInfo.GetClosestSnappedTime(hitobject.StartTime);
                 string startPostfix = hitobject is IHasDuration ? "start" : "";
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckUnusedAudioAtEnd.cs b/osu.Game/Rulesets/Edit/Checks/CheckUnusedAudioAtEnd.cs
index 2e97fbeb99..a69dd324f9 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckUnusedAudioAtEnd.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckUnusedAudioAtEnd.cs
@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit.Checks.Components;
-using osu.Game.Storyboards;
 
 namespace osu.Game.Rulesets.Edit.Checks
 {
@@ -22,8 +21,8 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            double mappedLength = context.Beatmap.HitObjects.Any() ? context.Beatmap.GetLastObjectTime() : 0;
-            double trackLength = context.WorkingBeatmap.Track.Length;
+            double mappedLength = context.CurrentDifficulty.Playable.HitObjects.Any() ? context.CurrentDifficulty.Playable.GetLastObjectTime() : 0;
+            double trackLength = context.CurrentDifficulty.Working.Track.Length;
 
             double mappedPercentage = Math.Round(mappedLength / trackLength * 100);
 
@@ -31,7 +30,7 @@ namespace osu.Game.Rulesets.Edit.Checks
             {
                 double percentageLeft = Math.Abs(mappedPercentage - 100);
 
-                bool storyboardIsPresent = isAnyStoryboardElementPresent(context.WorkingBeatmap.Storyboard);
+                bool storyboardIsPresent = ResourcesCheckUtils.HasAnyStoryboardElementPresent(context.CurrentDifficulty.Working);
 
                 if (storyboardIsPresent)
                 {
@@ -44,19 +43,6 @@ namespace osu.Game.Rulesets.Edit.Checks
             }
         }
 
-        private bool isAnyStoryboardElementPresent(Storyboard storyboard)
-        {
-            foreach (var layer in storyboard.Layers)
-            {
-                foreach (var _ in layer.Elements)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         public class IssueTemplateUnusedAudioAtEnd : IssueTemplate
         {
             public IssueTemplateUnusedAudioAtEnd(ICheck check)
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckVideoResolution.cs b/osu.Game/Rulesets/Edit/Checks/CheckVideoResolution.cs
index c050932aa6..7a1e87954b 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckVideoResolution.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckVideoResolution.cs
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         private const int max_video_height = 720;
 
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Resources, "Too high video resolution.");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Resources, "Too high video resolution.", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -30,8 +30,8 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
-            var videoPaths = getVideoPaths(context.WorkingBeatmap.Storyboard);
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
+            var videoPaths = getVideoPaths(context.CurrentDifficulty.Working.Storyboard);
 
             foreach (string filename in videoPaths)
             {
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
                 try
                 {
-                    using (Stream data = context.WorkingBeatmap.GetStream(storagePath))
+                    using (Stream data = context.CurrentDifficulty.Working.GetStream(storagePath))
                     using (File tagFile = TagLibUtils.GetTagLibFile(filename, data))
                     {
                         int height = tagFile.Properties.VideoHeight;
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckVideoUsage.cs b/osu.Game/Rulesets/Edit/Checks/CheckVideoUsage.cs
new file mode 100644
index 0000000000..1384ffe4d4
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/CheckVideoUsage.cs
@@ -0,0 +1,137 @@
+// 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 osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckVideoUsage : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Resources, "Inconsistent video usage", CheckScope.BeatmapSet);
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateDifferentVideo(this),
+            new IssueTemplateDifferentStartTime(this),
+            new IssueTemplateMissingVideo(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var currentVideo = ResourcesCheckUtils.GetDifficultyVideo(context.CurrentDifficulty.Working);
+
+            // If current difficulty has no video but any other does -> problem
+            if (currentVideo == null)
+            {
+                foreach (var otherDifficulty in context.OtherDifficulties)
+                {
+                    if (ResourcesCheckUtils.GetDifficultyVideo(otherDifficulty.Working) != null)
+                    {
+                        yield return new IssueTemplateMissingVideo(this).Create(context.CurrentDifficulty.Playable.BeatmapInfo.DifficultyName);
+
+                        break;
+                    }
+                }
+            }
+
+            // If current has a video, check for missing video on other difficulties and warn about different files vs current.
+            if (currentVideo != null)
+            {
+                string referencePath = currentVideo.Path;
+
+                foreach (var otherDifficulty in context.OtherDifficulties)
+                {
+                    var otherVideo = ResourcesCheckUtils.GetDifficultyVideo(otherDifficulty.Working);
+                    string difficultyName = otherDifficulty.Playable.BeatmapInfo.DifficultyName;
+
+                    // If other difficulty has no video -> problem
+                    if (otherVideo == null)
+                    {
+                        yield return new IssueTemplateMissingVideo(this).Create(difficultyName);
+
+                        continue;
+                    }
+
+                    // Different video used (relative to current) -> warning
+                    if (!string.Equals(otherVideo.Path, referencePath, StringComparison.OrdinalIgnoreCase))
+                    {
+                        yield return new IssueTemplateDifferentVideo(this).Create(difficultyName, referencePath, otherVideo.Path);
+                    }
+                }
+            }
+
+            // Pairwise check: for each video file used across all difficulties, ensure all start times match.
+            // Build a list of all difficulties with a video present (including current).
+            var allDifficultiesWithVideo = new List<(string DifficultyName, string Path, double StartTime)>();
+
+            if (currentVideo != null)
+                allDifficultiesWithVideo.Add((context.CurrentDifficulty.Playable.BeatmapInfo.DifficultyName, currentVideo.Path, currentVideo.StartTime));
+
+            foreach (var other in context.OtherDifficulties)
+            {
+                var video = ResourcesCheckUtils.GetDifficultyVideo(other.Working);
+
+                if (video != null)
+                {
+                    string name = other.Playable.BeatmapInfo.DifficultyName;
+                    allDifficultiesWithVideo.Add((name, video.Path, video.StartTime));
+                }
+            }
+
+            // Group by video path (case-insensitive) and compare start times pairwise within each group.
+            foreach (var groupedByVideoPath in allDifficultiesWithVideo.GroupBy(v => v.Path, StringComparer.OrdinalIgnoreCase))
+            {
+                var difficultiesWithSameVideo = groupedByVideoPath.ToList();
+
+                for (int i = 0; i < difficultiesWithSameVideo.Count; i++)
+                {
+                    for (int j = i + 1; j < difficultiesWithSameVideo.Count; j++)
+                    {
+                        if (!difficultiesWithSameVideo[i].StartTime.Equals(difficultiesWithSameVideo[j].StartTime))
+                        {
+                            yield return new IssueTemplateDifferentStartTime(this).Create(
+                                groupedByVideoPath.Key,
+                                difficultiesWithSameVideo[i].DifficultyName, difficultiesWithSameVideo[i].StartTime,
+                                difficultiesWithSameVideo[j].DifficultyName, difficultiesWithSameVideo[j].StartTime);
+                        }
+                    }
+                }
+            }
+        }
+
+        public class IssueTemplateDifferentVideo : IssueTemplate
+        {
+            public IssueTemplateDifferentVideo(ICheck check)
+                : base(check, IssueType.Warning, "Video file differs from current difficulty in \"{0}\" (current: \"{1}\", other: \"{2}\"). Ensure this makes sense.")
+            {
+            }
+
+            public Issue Create(string otherDifficulty, string currentPath, string otherPath)
+                => new Issue(this, otherDifficulty, currentPath, otherPath);
+        }
+
+        public class IssueTemplateDifferentStartTime : IssueTemplate
+        {
+            public IssueTemplateDifferentStartTime(ICheck check)
+                : base(check, IssueType.Problem, "Video start time differs for \"{0}\" between \"{1}\" ({2:0} ms) and \"{3}\" ({4:0} ms).")
+            {
+            }
+
+            public Issue Create(string path, string difficultyA, double startA, string difficultyB, double startB)
+                => new Issue(this, path, difficultyA, startA, difficultyB, startB);
+        }
+
+        public class IssueTemplateMissingVideo : IssueTemplate
+        {
+            public IssueTemplateMissingVideo(ICheck check)
+                : base(check, IssueType.Problem, "Video is missing in \"{0}\".")
+            {
+            }
+
+            public Issue Create(string otherDifficulty) => new Issue(this, otherDifficulty);
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckZeroByteFiles.cs b/osu.Game/Rulesets/Edit/Checks/CheckZeroByteFiles.cs
index 75cb08002f..d9de49a910 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckZeroByteFiles.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckZeroByteFiles.cs
@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 {
     public class CheckZeroByteFiles : ICheck
     {
-        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Files, "Zero-byte files");
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Files, "Zero-byte files", CheckScope.BeatmapSet);
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
         {
@@ -19,13 +19,13 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var beatmapSet = context.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
 
             if (beatmapSet != null)
             {
                 foreach (var file in beatmapSet.Files)
                 {
-                    using (Stream data = context.WorkingBeatmap.GetStream(file.File.GetStoragePath()))
+                    using (Stream data = context.CurrentDifficulty.Working.GetStream(file.File.GetStoragePath()))
                     {
                         if (data?.Length == 0)
                             yield return new IssueTemplateZeroBytes(this).Create(file.Filename);
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckZeroLengthObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckZeroLengthObjects.cs
index b9be94736b..a10dd43e74 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckZeroLengthObjects.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckZeroLengthObjects.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Edit.Checks
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)
         {
-            foreach (var hitObject in context.Beatmap.HitObjects)
+            foreach (var hitObject in context.CurrentDifficulty.Playable.HitObjects)
             {
                 if (!(hitObject is IHasDuration hasDuration))
                     continue;
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs b/osu.Game/Rulesets/Edit/Checks/Components/AudioCheckUtils.cs
index 8a35b84170..746f2bf256 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.CurrentDifficulty.Playable.BeatmapInfo.BeatmapSet;
+            var audioFile = beatmapSet?.GetFile(filename);
+
+            if (beatmapSet == null || audioFile == null)
+                return ChannelType.Unknown;
+
+            using (Stream data = context.CurrentDifficulty.Working.GetStream(audioFile.File.GetStoragePath()))
+                return GetAudioFormat(data);
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/CheckMetadata.cs b/osu.Game/Rulesets/Edit/Checks/Components/CheckMetadata.cs
index cebb2f5455..cbc07f1fa3 100644
--- a/osu.Game/Rulesets/Edit/Checks/Components/CheckMetadata.cs
+++ b/osu.Game/Rulesets/Edit/Checks/Components/CheckMetadata.cs
@@ -15,10 +15,16 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
         /// </summary>
         public readonly string Description;
 
-        public CheckMetadata(CheckCategory category, string description)
+        /// <summary>
+        /// Specifies whether this check is difficulty-specific or applies to the entire beatmapset. Set to <see cref="CheckScope.Difficulty"/> by default.
+        /// </summary>
+        public readonly CheckScope Scope;
+
+        public CheckMetadata(CheckCategory category, string description, CheckScope scope = CheckScope.Difficulty)
         {
             Category = category;
             Description = description;
+            Scope = scope;
         }
     }
 }
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/CheckScope.cs b/osu.Game/Rulesets/Edit/Checks/Components/CheckScope.cs
new file mode 100644
index 0000000000..7dcc4d87f2
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/Components/CheckScope.cs
@@ -0,0 +1,23 @@
+// 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.Localisation;
+using osu.Game.Localisation;
+
+namespace osu.Game.Rulesets.Edit.Checks.Components
+{
+    public enum CheckScope
+    {
+        /// <summary>
+        /// Run checks that apply to the current difficulty.
+        /// </summary>
+        [LocalisableDescription(typeof(EditorStrings), nameof(EditorStrings.CheckCurrentDifficulty))]
+        Difficulty,
+
+        /// <summary>
+        /// Run checks that apply to the beatmap set as a whole.
+        /// </summary>
+        [LocalisableDescription(typeof(EditorStrings), nameof(EditorStrings.CheckEntireBeatmapSet))]
+        BeatmapSet,
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/ResourcesCheckUtils.cs b/osu.Game/Rulesets/Edit/Checks/Components/ResourcesCheckUtils.cs
new file mode 100644
index 0000000000..96bd11f1fc
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/Components/ResourcesCheckUtils.cs
@@ -0,0 +1,50 @@
+// 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.Storyboards;
+
+namespace osu.Game.Rulesets.Edit.Checks.Components
+{
+    public static class ResourcesCheckUtils
+    {
+        /// <summary>
+        /// Checks if any storyboard element is present in the working beatmap.
+        /// </summary>
+        /// <param name="workingBeatmap">The working beatmap to check.</param>
+        /// <returns>True if any storyboard element is present, false otherwise.</returns>
+        public static bool HasAnyStoryboardElementPresent(IWorkingBeatmap workingBeatmap)
+        {
+            foreach (var layer in workingBeatmap.Storyboard.Layers)
+            {
+                foreach (var _ in layer.Elements)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Retrieves the first storyboard video entry for the provided working beatmap, if any.
+        /// </summary>
+        /// <param name="workingBeatmap">The working beatmap to inspect.</param>
+        /// <returns>
+        /// The first <see cref="StoryboardVideo"/> found, or null if none exists.
+        /// </returns>
+        public static StoryboardVideo? GetDifficultyVideo(IWorkingBeatmap workingBeatmap)
+        {
+            foreach (var layer in workingBeatmap.Storyboard.Layers)
+            {
+                foreach (var element in layer.Elements)
+                {
+                    if (element is StoryboardVideo video)
+                        return video;
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/Checks/Components/TimingCheckUtils.cs b/osu.Game/Rulesets/Edit/Checks/Components/TimingCheckUtils.cs
new file mode 100644
index 0000000000..f56f27813d
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/Checks/Components/TimingCheckUtils.cs
@@ -0,0 +1,38 @@
+// 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.Utils;
+using osu.Game.Beatmaps.ControlPoints;
+
+namespace osu.Game.Rulesets.Edit.Checks.Components
+{
+    public static class TimingCheckUtils
+    {
+        // Tolerance for exact time offset matching (in milliseconds)
+        public const double TIME_OFFSET_TOLERANCE_MS = 0.01;
+
+        /// <summary>
+        /// Finds a timing control point that starts at approximately the same time (within 1ms after rounding).
+        /// </summary>
+        /// <param name="timingPoints">The collection of timing points to search.</param>
+        /// <param name="time">The time to match against.</param>
+        /// <returns>The matching timing control point, or null if none found.</returns>
+        public static TimingControlPoint? FindMatchingTimingPoint(IEnumerable<TimingControlPoint> timingPoints, double time)
+        {
+            return timingPoints.FirstOrDefault(tp => (int)tp.Time == (int)time);
+        }
+
+        /// <summary>
+        /// Finds a timing control point that starts at precisely the same time (within timing tolerance).
+        /// </summary>
+        /// <param name="timingPoints">The collection of timing points to search.</param>
+        /// <param name="time">The time to match against.</param>
+        /// <returns>The exact matching timing control point, or null if none found.</returns>
+        public static TimingControlPoint? FindExactMatchingTimingPoint(IEnumerable<TimingControlPoint> timingPoints, double time)
+        {
+            return timingPoints.FirstOrDefault(tp => Precision.AlmostEquals(tp.Time, time, TIME_OFFSET_TOLERANCE_MS));
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Mods/Mod.cs b/osu.Game/Rulesets/Mods/Mod.cs
index 727db913e2..477372b97d 100644
--- a/osu.Game/Rulesets/Mods/Mod.cs
+++ b/osu.Game/Rulesets/Mods/Mod.cs
@@ -56,6 +56,9 @@ namespace osu.Game.Rulesets.Mods
                 {
                     var bindable = (IBindable)property.GetValue(this)!;
 
+                    if (bindable.IsDefault)
+                        continue;
+
                     string valueText;
 
                     switch (bindable)
@@ -69,8 +72,7 @@ namespace osu.Game.Rulesets.Mods
                             break;
                     }
 
-                    if (!bindable.IsDefault)
-                        yield return (attr.Label, valueText);
+                    yield return (attr.Label, valueText);
                 }
             }
         }
diff --git a/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs b/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
index db16e771d3..f26a1bd477 100644
--- a/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
+++ b/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
@@ -6,8 +6,10 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Localisation.HUD;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Scoring;
@@ -24,6 +26,8 @@ namespace osu.Game.Rulesets.Mods
 
         public override LocalisableString Description => "Fail if your accuracy drops too low!";
 
+        public override IconUsage? Icon => OsuIcon.ModAccuracyChallenge;
+
         public override ModType Type => ModType.DifficultyIncrease;
 
         public override double ScoreMultiplier => 1.0;
diff --git a/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs b/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
index 83a48599ca..63d2f7d7f3 100644
--- a/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
+++ b/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
@@ -6,10 +6,12 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
@@ -27,6 +29,8 @@ namespace osu.Game.Rulesets.Mods
 
         public override LocalisableString Description => "Let track speed adapt to you.";
 
+        public override IconUsage? Icon => OsuIcon.ModAdaptiveSpeed;
+
         public override ModType Type => ModType.Fun;
 
         public override double ScoreMultiplier => 0.5;
diff --git a/osu.Game/Rulesets/Mods/ModAutoplay.cs b/osu.Game/Rulesets/Mods/ModAutoplay.cs
index 302cdf69c0..01e01a0d9a 100644
--- a/osu.Game/Rulesets/Mods/ModAutoplay.cs
+++ b/osu.Game/Rulesets/Mods/ModAutoplay.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Autoplay";
         public override string Acronym => "AT";
-        public override IconUsage? Icon => OsuIcon.ModAuto;
+        public override IconUsage? Icon => OsuIcon.ModAutoplay;
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => "Watch a perfect automated play through the song.";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
index ceaa9aa6e5..98a7999065 100644
--- a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
+++ b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
@@ -6,8 +6,10 @@ using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -36,6 +38,7 @@ namespace osu.Game.Rulesets.Mods
 
         public override string Name => "Barrel Roll";
         public override string Acronym => "BR";
+        public override IconUsage? Icon => OsuIcon.ModBarrelRoll;
         public override LocalisableString Description => "The whole playfield is on a wheel!";
         public override double ScoreMultiplier => 1;
 
@@ -43,8 +46,10 @@ namespace osu.Game.Rulesets.Mods
         {
             get
             {
-                yield return ("Roll speed", $"{SpinSpeed.Value:N2} rpm");
-                yield return ("Direction", Direction.Value.GetDescription());
+                if (!SpinSpeed.IsDefault)
+                    yield return ("Roll speed", $"{SpinSpeed.Value:N2} rpm");
+                if (!Direction.IsDefault)
+                    yield return ("Direction", Direction.Value.GetDescription());
             }
         }
 
@@ -52,7 +57,8 @@ namespace osu.Game.Rulesets.Mods
 
         public virtual void Update(Playfield playfield)
         {
-            playfieldAdjustmentContainer.Rotation = CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
+            playfieldAdjustmentContainer.Rotation =
+                CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
         }
 
         public void ApplyToDrawableRuleset(DrawableRuleset<TObject> drawableRuleset)
diff --git a/osu.Game/Rulesets/Mods/ModClassic.cs b/osu.Game/Rulesets/Mods/ModClassic.cs
index 66d6ea2e66..e8c6bd09c1 100644
--- a/osu.Game/Rulesets/Mods/ModClassic.cs
+++ b/osu.Game/Rulesets/Mods/ModClassic.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
 
         public override double ScoreMultiplier => 0.96;
 
-        public override IconUsage? Icon => FontAwesome.Solid.History;
+        public override IconUsage? Icon => OsuIcon.ModClassic;
 
         public override LocalisableString Description => "Feeling nostalgic?";
 
diff --git a/osu.Game/Rulesets/Mods/ModDaycore.cs b/osu.Game/Rulesets/Mods/ModDaycore.cs
index 359f8a950c..98ecf0d46a 100644
--- a/osu.Game/Rulesets/Mods/ModDaycore.cs
+++ b/osu.Game/Rulesets/Mods/ModDaycore.cs
@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Rulesets.Mods
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Daycore";
         public override string Acronym => "DC";
-        public override IconUsage? Icon => null;
+        public override IconUsage? Icon => OsuIcon.ModDaycore;
         public override ModType Type => ModType.DifficultyReduction;
         public override LocalisableString Description => "Whoaaaaa...";
         public override bool Ranked => UsesDefaultConfiguration;
diff --git a/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs b/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
index dbc690bd15..da5f5df200 100644
--- a/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
+++ b/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
@@ -9,6 +9,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Extensions;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Mods
 
         public override ModType Type => ModType.Conversion;
 
-        public override IconUsage? Icon => FontAwesome.Solid.Hammer;
+        public override IconUsage? Icon => OsuIcon.ModDifficultyAdjust;
 
         public override double ScoreMultiplier => 0.5;
 
diff --git a/osu.Game/Rulesets/Mods/ModFlashlight.cs b/osu.Game/Rulesets/Mods/ModFlashlight.cs
index a88d714dce..884066d7ab 100644
--- a/osu.Game/Rulesets/Mods/ModFlashlight.cs
+++ b/osu.Game/Rulesets/Mods/ModFlashlight.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.Runtime.InteropServices;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -14,8 +13,8 @@ using osu.Framework.Graphics.Rendering.Vertices;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Shaders.Types;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Layout;
 using osu.Framework.Localisation;
-using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.OpenGL.Vertices;
@@ -85,7 +84,11 @@ namespace osu.Game.Rulesets.Mods
             flashlight.Colour = Color4.Black;
 
             flashlight.Combo.BindTo(Combo);
-            flashlight.GetPlayfieldScale = () => drawableRuleset.PlayfieldAdjustmentContainer.Scale;
+
+            var playfieldDrawInfoTracker = new PlayfieldDrawInfoTracker();
+
+            drawableRuleset.PlayfieldAdjustmentContainer.Add(playfieldDrawInfoTracker);
+            flashlight.PlayfieldDrawInfoTracker = playfieldDrawInfoTracker;
 
             drawableRuleset.Overlays.Add(new Container
             {
@@ -111,7 +114,9 @@ namespace osu.Game.Rulesets.Mods
 
             public override bool RemoveCompletedTransforms => false;
 
-            internal Func<Vector2>? GetPlayfieldScale;
+            internal PlayfieldDrawInfoTracker PlayfieldDrawInfoTracker { get; set; } = null!;
+
+            private DrawInfo playfieldDrawInfo => PlayfieldDrawInfoTracker.DrawInfo;
 
             private readonly float defaultFlashlightSize;
             private readonly float sizeMultiplier;
@@ -146,6 +151,8 @@ namespace osu.Game.Rulesets.Mods
                     isBreakTime.BindTo(player.IsBreakTime);
                     isBreakTime.BindValueChanged(_ => UpdateFlashlightSize(GetSize()), true);
                 }
+
+                PlayfieldDrawInfoTracker.OnDrawInfoInvalidate += () => Invalidate(Invalidation.DrawNode);
             }
 
             protected abstract void UpdateFlashlightSize(float size);
@@ -156,15 +163,6 @@ namespace osu.Game.Rulesets.Mods
             {
                 float size = defaultFlashlightSize * sizeMultiplier;
 
-                if (GetPlayfieldScale != null)
-                {
-                    Vector2 playfieldScale = GetPlayfieldScale();
-
-                    Debug.Assert(Precision.AlmostEquals(Math.Abs(playfieldScale.X), Math.Abs(playfieldScale.Y)),
-                        @"Playfield has non-proportional scaling. Flashlight implementations should be revisited with regard to balance.");
-                    size *= Math.Abs(playfieldScale.X);
-                }
-
                 if (isBreakTime.Value)
                     size *= 2.5f;
                 else if (comboBasedSize)
@@ -265,7 +263,11 @@ namespace osu.Game.Rulesets.Mods
                     shader = Source.shader;
                     screenSpaceDrawQuad = Source.ScreenSpaceDrawQuad;
                     flashlightPosition = Vector2Extensions.Transform(Source.FlashlightPosition, DrawInfo.Matrix);
-                    flashlightSize = Source.FlashlightSize * DrawInfo.Matrix.ExtractScale().Xy;
+
+                    // scale the flashlight based on the playfield to match gameplay components scale.
+                    Vector2 drawInfoScale = Source.playfieldDrawInfo.Matrix.ExtractScale().Xy;
+                    flashlightSize = Source.FlashlightSize * drawInfoScale;
+
                     flashlightDim = Source.FlashlightDim;
                     flashlightSmoothness = Source.flashlightSmoothness;
                 }
@@ -321,5 +323,33 @@ namespace osu.Game.Rulesets.Mods
                 }
             }
         }
+
+        /// <summary>
+        /// The purpose of this component is to track any changes to <c>Playfield.Parent.DrawInfo</c>
+        /// (by being added to the content of <see cref="PlayfieldAdjustmentContainer"/>).
+        /// All in order for the flashlight to invalidate its draw node and read any changes in the playfield's scaling.
+        /// </summary>
+        internal partial class PlayfieldDrawInfoTracker : Component
+        {
+            private readonly LayoutValue drawInfoLayout = new LayoutValue(Invalidation.DrawInfo);
+
+            public Action? OnDrawInfoInvalidate;
+
+            public PlayfieldDrawInfoTracker()
+            {
+                AddLayout(drawInfoLayout);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!drawInfoLayout.IsValid)
+                {
+                    OnDrawInfoInvalidate?.Invoke();
+                    drawInfoLayout.Validate();
+                }
+            }
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModHalfTime.cs b/osu.Game/Rulesets/Mods/ModHalfTime.cs
index e2790e9c22..c91c8b2718 100644
--- a/osu.Game/Rulesets/Mods/ModHalfTime.cs
+++ b/osu.Game/Rulesets/Mods/ModHalfTime.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Half Time";
         public override string Acronym => "HT";
-        public override IconUsage? Icon => OsuIcon.ModHalftime;
+        public override IconUsage? Icon => OsuIcon.ModHalfTime;
         public override ModType Type => ModType.DifficultyReduction;
         public override LocalisableString Description => "Less zoom...";
         public override bool Ranked => SpeedChange.IsDefault;
diff --git a/osu.Game/Rulesets/Mods/ModMirror.cs b/osu.Game/Rulesets/Mods/ModMirror.cs
index 3c4b7d0c60..c2e21c6770 100644
--- a/osu.Game/Rulesets/Mods/ModMirror.cs
+++ b/osu.Game/Rulesets/Mods/ModMirror.cs
@@ -1,12 +1,16 @@
 // 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.Graphics.Sprites;
+using osu.Game.Graphics;
+
 namespace osu.Game.Rulesets.Mods
 {
     public abstract class ModMirror : Mod
     {
         public override string Name => "Mirror";
         public override string Acronym => "MR";
+        public override IconUsage? Icon => OsuIcon.ModMirror;
         public override ModType Type => ModType.Conversion;
         public override double ScoreMultiplier => 1;
     }
diff --git a/osu.Game/Rulesets/Mods/ModMuted.cs b/osu.Game/Rulesets/Mods/ModMuted.cs
index 2eb243d565..933e7f4093 100644
--- a/osu.Game/Rulesets/Mods/ModMuted.cs
+++ b/osu.Game/Rulesets/Mods/ModMuted.cs
@@ -8,6 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Objects;
@@ -21,7 +22,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Muted";
         public override string Acronym => "MU";
-        public override IconUsage? Icon => FontAwesome.Solid.VolumeMute;
+        public override IconUsage? Icon => OsuIcon.ModMuted;
         public override LocalisableString Description => "Can you still feel the rhythm without music?";
         public override ModType Type => ModType.Fun;
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game/Rulesets/Mods/ModNoMod.cs b/osu.Game/Rulesets/Mods/ModNoMod.cs
index 5dd4b317e7..0f55ab126f 100644
--- a/osu.Game/Rulesets/Mods/ModNoMod.cs
+++ b/osu.Game/Rulesets/Mods/ModNoMod.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -15,7 +16,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "NM";
         public override LocalisableString Description => "No mods applied.";
         public override double ScoreMultiplier => 1;
-        public override IconUsage? Icon => FontAwesome.Solid.Ban;
+        public override IconUsage? Icon => OsuIcon.ModNoMod;
         public override ModType Type => ModType.System;
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModNoScope.cs b/osu.Game/Rulesets/Mods/ModNoScope.cs
index dd1bd9a719..d0c9da669b 100644
--- a/osu.Game/Rulesets/Mods/ModNoScope.cs
+++ b/osu.Game/Rulesets/Mods/ModNoScope.cs
@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Scoring;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "No Scope";
         public override string Acronym => "NS";
         public override ModType Type => ModType.Fun;
-        public override IconUsage? Icon => FontAwesome.Solid.EyeSlash;
+        public override IconUsage? Icon => OsuIcon.ModNoScope;
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
 
diff --git a/osu.Game/Rulesets/Mods/ModRandom.cs b/osu.Game/Rulesets/Mods/ModRandom.cs
index 178b9fb619..684caa2a3f 100644
--- a/osu.Game/Rulesets/Mods/ModRandom.cs
+++ b/osu.Game/Rulesets/Mods/ModRandom.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Random";
         public override string Acronym => "RD";
         public override ModType Type => ModType.Conversion;
-        public override IconUsage? Icon => OsuIcon.Dice;
+        public override IconUsage? Icon => OsuIcon.ModRandom;
         public override double ScoreMultiplier => 1;
 
         [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]
diff --git a/osu.Game/Rulesets/Mods/ModScoreV2.cs b/osu.Game/Rulesets/Mods/ModScoreV2.cs
index 854f3916a1..dce6e146df 100644
--- a/osu.Game/Rulesets/Mods/ModScoreV2.cs
+++ b/osu.Game/Rulesets/Mods/ModScoreV2.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -13,6 +15,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Score V2";
         public override string Acronym => @"SV2";
+        public override IconUsage? Icon => OsuIcon.ModScoreV2;
         public override ModType Type => ModType.System;
         public override LocalisableString Description => "Score set on earlier osu! versions with the V2 scoring algorithm active.";
         public override double ScoreMultiplier => 1;
diff --git a/osu.Game/Rulesets/Mods/ModSynesthesia.cs b/osu.Game/Rulesets/Mods/ModSynesthesia.cs
index 9084127f33..31ff7ca3fe 100644
--- a/osu.Game/Rulesets/Mods/ModSynesthesia.cs
+++ b/osu.Game/Rulesets/Mods/ModSynesthesia.cs
@@ -1,7 +1,9 @@
 // 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.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -14,6 +16,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "SY";
         public override LocalisableString Description => "Colours hit objects based on the rhythm.";
         public override double ScoreMultiplier => 0.8;
+        public override IconUsage? Icon => OsuIcon.ModSynesthesia;
         public override ModType Type => ModType.Fun;
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModTimeRamp.cs b/osu.Game/Rulesets/Mods/ModTimeRamp.cs
index 8dfe8444e8..049b8f9b7f 100644
--- a/osu.Game/Rulesets/Mods/ModTimeRamp.cs
+++ b/osu.Game/Rulesets/Mods/ModTimeRamp.cs
@@ -41,7 +41,8 @@ namespace osu.Game.Rulesets.Mods
         {
             get
             {
-                yield return ("Speed change", $"{InitialRate.Value:N2}x to {FinalRate.Value:N2}x");
+                if (!InitialRate.IsDefault || !FinalRate.IsDefault)
+                    yield return ("Speed change", $"{InitialRate.Value:N2}x to {FinalRate.Value:N2}x");
 
                 if (!AdjustPitch.IsDefault)
                     yield return ("Adjust pitch", AdjustPitch.Value ? "On" : "Off");
diff --git a/osu.Game/Rulesets/Mods/ModTouchDevice.cs b/osu.Game/Rulesets/Mods/ModTouchDevice.cs
index e91a398700..f5e6fc03bf 100644
--- a/osu.Game/Rulesets/Mods/ModTouchDevice.cs
+++ b/osu.Game/Rulesets/Mods/ModTouchDevice.cs
@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public sealed override string Name => "Touch Device";
         public sealed override string Acronym => "TD";
-        public sealed override IconUsage? Icon => OsuIcon.PlayStyleTouch;
+        public sealed override IconUsage? Icon => OsuIcon.ModTouchDevice;
         public sealed override LocalisableString Description => "Automatically applied to plays on devices with a touchscreen.";
         public sealed override double ScoreMultiplier => 1;
         public sealed override ModType Type => ModType.System;
diff --git a/osu.Game/Rulesets/Mods/ModWindDown.cs b/osu.Game/Rulesets/Mods/ModWindDown.cs
index 35a673093b..cad16ab3bb 100644
--- a/osu.Game/Rulesets/Mods/ModWindDown.cs
+++ b/osu.Game/Rulesets/Mods/ModWindDown.cs
@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Wind Down";
         public override string Acronym => "WD";
         public override LocalisableString Description => "Sloooow doooown...";
-        public override IconUsage? Icon => FontAwesome.Solid.ChevronCircleDown;
+        public override IconUsage? Icon => OsuIcon.ModWindDown;
 
         public override BindableNumber<double> InitialRate { get; } = new BindableDouble(1)
         {
diff --git a/osu.Game/Rulesets/Mods/ModWindUp.cs b/osu.Game/Rulesets/Mods/ModWindUp.cs
index bbc8382055..42555137b5 100644
--- a/osu.Game/Rulesets/Mods/ModWindUp.cs
+++ b/osu.Game/Rulesets/Mods/ModWindUp.cs
@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -14,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Wind Up";
         public override string Acronym => "WU";
         public override LocalisableString Description => "Can you keep up?";
-        public override IconUsage? Icon => FontAwesome.Solid.ChevronCircleUp;
+        public override IconUsage? Icon => OsuIcon.ModWindUp;
 
         public override BindableNumber<double> InitialRate { get; } = new BindableDouble(1)
         {
diff --git a/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs b/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
index efc10f26e1..e01df1428c 100644
--- a/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
+++ b/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
@@ -160,8 +160,8 @@ namespace osu.Game.Rulesets.Objects.Pooling
             if (!IsPresent)
                 return false;
 
-            bool aliveChanged = base.CheckChildrenLife();
-            aliveChanged |= lifetimeManager.Update(Time.Current - PastLifetimeExtension, Time.Current + FutureLifetimeExtension);
+            bool aliveChanged = lifetimeManager.Update(Time.Current - PastLifetimeExtension, Time.Current + FutureLifetimeExtension);
+            aliveChanged |= base.CheckChildrenLife();
             return aliveChanged;
         }
     }
diff --git a/osu.Game/Rulesets/Ruleset.cs b/osu.Game/Rulesets/Ruleset.cs
index bd1f273b49..0dbe6e8845 100644
--- a/osu.Game/Rulesets/Ruleset.cs
+++ b/osu.Game/Rulesets/Ruleset.cs
@@ -17,6 +17,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
 using osu.Game.Extensions;
+using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
@@ -380,15 +381,39 @@ 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="beatmapInfo">The <see cref="IBeatmapInfo"/> for which to display the adjusted difficulty.</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(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(beatmapInfo.Difficulty);
+
+            foreach (var mod in mods.OfType<IApplicableToDifficulty>())
+                mod.ApplyToDifficulty(adjustedDifficulty);
+
+            return adjustedDifficulty;
+        }
+
+        /// <summary>
+        /// Returns a list of <see cref="RulesetBeatmapAttribute"/>s to be displayed wherever it is wanted to display a given beatmap's difficulty information.
+        /// The returned data includes both material changes to difficulty from <see cref="IApplicableToDifficulty"/> mods,
+        /// as well as "effective" adjustments coming from <see cref="GetAdjustedDisplayDifficulty"/>.
+        /// </summary>
+        public virtual IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisplay(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var originalDifficulty = beatmapInfo.Difficulty;
+            var adjustedDifficulty = GetAdjustedDisplayDifficulty(beatmapInfo, mods);
+
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.CircleSize, @"CS", originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.ApproachRate, @"AR", originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate, 10);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.Accuracy, @"OD", originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10);
+            yield return new RulesetBeatmapAttribute(SongSelectStrings.HPDrain, @"HP", originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10);
+        }
 
         /// <summary>
         /// Creates ruleset-specific beatmap filter criteria to be used on the song select screen.
diff --git a/osu.Game/Rulesets/Scoring/HealthProcessor.cs b/osu.Game/Rulesets/Scoring/HealthProcessor.cs
index 2799cd4b36..d61e41f867 100644
--- a/osu.Game/Rulesets/Scoring/HealthProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/HealthProcessor.cs
@@ -59,9 +59,12 @@ namespace osu.Game.Rulesets.Scoring
 
         protected override void RevertResultInternal(JudgementResult result)
         {
-            Health.Value = result.HealthAtJudgement;
+            HasFailed = result.FailedAtJudgement;
 
-            // Todo: Revert HasFailed state with proper player support
+            if (HasFailed)
+                return;
+
+            Health.Value = result.HealthAtJudgement;
         }
 
         /// <summary>
diff --git a/osu.Game/Rulesets/UI/DrawableRuleset.cs b/osu.Game/Rulesets/UI/DrawableRuleset.cs
index 6b2387eb9b..31ff81456c 100644
--- a/osu.Game/Rulesets/UI/DrawableRuleset.cs
+++ b/osu.Game/Rulesets/UI/DrawableRuleset.cs
@@ -102,19 +102,6 @@ namespace osu.Game.Rulesets.UI
         private FrameStabilityContainer frameStabilityContainer;
         private DrawableRulesetDependencies dependencies;
 
-        private bool allowBackwardsSeeks;
-
-        public override bool AllowBackwardsSeeks
-        {
-            get => allowBackwardsSeeks;
-            set
-            {
-                allowBackwardsSeeks = value;
-                if (frameStabilityContainer != null)
-                    frameStabilityContainer.AllowBackwardsSeeks = value;
-            }
-        }
-
         private bool frameStablePlayback = true;
 
         internal override bool FrameStablePlayback
@@ -190,7 +177,6 @@ namespace osu.Game.Rulesets.UI
             InternalChild = frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime)
             {
                 FrameStablePlayback = FrameStablePlayback,
-                AllowBackwardsSeeks = AllowBackwardsSeeks,
                 Children = new Drawable[]
                 {
                     FrameStableComponents,
@@ -481,12 +467,6 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         internal abstract bool FrameStablePlayback { get; set; }
 
-        /// <summary>
-        /// When a replay is not attached, we usually block any backwards seeks.
-        /// This will bypass the check. Should only be used for tests.
-        /// </summary>
-        public abstract bool AllowBackwardsSeeks { get; set; }
-
         /// <summary>
         /// The mods which are to be applied.
         /// </summary>
diff --git a/osu.Game/Rulesets/UI/FrameStabilityContainer.cs b/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
index 50111e64a8..990c1c839b 100644
--- a/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
+++ b/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
@@ -6,6 +6,7 @@ using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
@@ -25,8 +26,7 @@ namespace osu.Game.Rulesets.UI
     {
         public ReplayInputHandler? ReplayInputHandler { get; set; }
 
-        public bool AllowBackwardsSeeks { get; set; }
-        private double? lastBackwardsSeekLogTime;
+        private int invalidBassTimeLogCount;
 
         /// <summary>
         /// The number of CPU milliseconds to spend at most during seek catch-up.
@@ -63,6 +63,9 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         private readonly FramedClock framedClock;
 
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         private readonly Stopwatch stopwatch = new Stopwatch();
 
         /// <summary>
@@ -154,23 +157,31 @@ namespace osu.Game.Rulesets.UI
                     state = PlaybackState.NotValid;
             }
 
-            // This is a hotfix for https://github.com/ppy/osu/issues/26879 while we figure how the hell time is seeking
-            // backwards by 11,850 ms for some users during gameplay.
+            // TODO: replace IsDebugBuild with a framework flag which asserts we are in a test scene, interactively or otherwise.
+            bool allowReferenceClockSeeks = hasReplayAttached || DebugUtils.IsNUnitRunning || DebugUtils.IsDebugBuild || !FrameStablePlayback;
+
+            // This is a hotfix for ongoing bass issues we are trying to resolve (see https://www.un4seen.com/forum/?topic=20482.msg145474#msg145474)
             //
-            // It basically says that "while we're running in frame stable mode, and don't have a replay attached,
-            // time should never go backwards". If it does, we stop running gameplay until it returns to normal.
-            if (!hasReplayAttached && FrameStablePlayback && proposedTime > referenceClock.CurrentTime && !AllowBackwardsSeeks)
+            // In testing this triggers *very* rarely even when set to super low values (10 ms). The cases we're worried about involve multi-second jumps.
+            // A difference of more than 500 ms seems like a sane number we should never exceed.
+            //
+            // Double-checking against the parent clock ensures we don't accidentally freeze time when the game stutters due to a long running frame.
+            if (!allowReferenceClockSeeks && Math.Abs(proposedTime - referenceClock.CurrentTime) > 500 && game?.Clock.ElapsedFrameTime <= 500)
             {
-                if (lastBackwardsSeekLogTime == null || Math.Abs(Clock.CurrentTime - lastBackwardsSeekLogTime.Value) > 1000)
+                if (invalidBassTimeLogCount < 10)
                 {
-                    lastBackwardsSeekLogTime = Clock.CurrentTime;
-                    Logger.Log($"Denying backwards seek during gameplay (reference: {referenceClock.CurrentTime:N2} stable: {proposedTime:N2})");
+                    invalidBassTimeLogCount++;
+                    Logger.Log("Ignoring likely invalid time value provided by BASS during gameplay");
+                    Logger.Log($"- provided: {referenceClock.CurrentTime:N2}");
+                    Logger.Log($"- expected: {proposedTime:N2}");
                 }
 
                 state = PlaybackState.NotValid;
                 return;
             }
 
+            invalidBassTimeLogCount = 0;
+
             // if the proposed time is the same as the current time, assume that the clock will continue progressing in the same direction as previously.
             // this avoids spurious flips in direction from -1 to 1 during rewinds.
             if (state == PlaybackState.Valid && proposedTime != manualClock.CurrentTime)
diff --git a/osu.Game/Rulesets/UI/ModIcon.cs b/osu.Game/Rulesets/UI/ModIcon.cs
index 9ed4f7135f..79cf073a42 100644
--- a/osu.Game/Rulesets/UI/ModIcon.cs
+++ b/osu.Game/Rulesets/UI/ModIcon.cs
@@ -167,7 +167,13 @@ namespace osu.Game.Rulesets.UI
                         {
                             Origin = Anchor.Centre,
                             Anchor = Anchor.Centre,
-                            Size = new Vector2(45),
+                            RelativeSizeAxes = Axes.Both,
+                            // the mod icon assets in `osu-resources` are sized such that they are flush with the hexagonal background with no shadow baked in.
+                            // the `Icons/BeatmapDetails/mod-icon` asset (of size 135x100) has a shadow and some extra transparent pixels baked in.
+                            // the hexagonal background on that asset, excluding its shadow and the transparent pixels, is 131px wide and 92px high.
+                            // height is divided by 135 rather than by 100, because this entire component is square-sized.
+                            Width = 131 / 135f,
+                            Height = 92 / 135f,
                             Icon = FontAwesome.Solid.Question
                         },
                         adjustmentMarker = new Container
diff --git a/osu.Game/Rulesets/UI/ModSwitchSmall.cs b/osu.Game/Rulesets/UI/ModSwitchSmall.cs
index 6e96cc8e6f..c471a7f3f2 100644
--- a/osu.Game/Rulesets/UI/ModSwitchSmall.cs
+++ b/osu.Game/Rulesets/UI/ModSwitchSmall.cs
@@ -61,7 +61,6 @@ namespace osu.Game.Rulesets.UI
                     AutoSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Spacing = new Vector2(0, 4),
                     Direction = FillDirection.Vertical,
                     Child = tinySwitch = new ModSwitchTiny(mod)
                     {
@@ -79,7 +78,9 @@ namespace osu.Game.Rulesets.UI
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
-                    Size = new Vector2(21),
+                    Size = new Vector2(37, 26),
+                    // arbitrary adjustment for better vertical alignment
+                    Margin = new MarginPadding { Top = -1 },
                     Icon = mod.Icon.Value
                 });
                 tinySwitch.Scale = new Vector2(0.3f);
diff --git a/osu.Game/Scoring/Legacy/LegacyReplaySoloScoreInfo.cs b/osu.Game/Scoring/Legacy/LegacyReplaySoloScoreInfo.cs
index c99f104418..8247dc60cb 100644
--- a/osu.Game/Scoring/Legacy/LegacyReplaySoloScoreInfo.cs
+++ b/osu.Game/Scoring/Legacy/LegacyReplaySoloScoreInfo.cs
@@ -49,6 +49,9 @@ namespace osu.Game.Scoring.Legacy
         [JsonProperty("total_score_without_mods")]
         public long? TotalScoreWithoutMods { get; set; }
 
+        [JsonProperty("pauses")]
+        public int[] Pauses { get; set; } = [];
+
         public static LegacyReplaySoloScoreInfo FromScore(ScoreInfo score) => new LegacyReplaySoloScoreInfo
         {
             OnlineID = score.OnlineID,
@@ -59,6 +62,7 @@ namespace osu.Game.Scoring.Legacy
             Rank = score.Rank,
             UserID = score.User.OnlineID,
             TotalScoreWithoutMods = score.TotalScoreWithoutMods > 0 ? score.TotalScoreWithoutMods : null,
+            Pauses = score.Pauses.ToArray(),
         };
     }
 }
diff --git a/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs b/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
index ec2b567a7b..393df65cc8 100644
--- a/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
+++ b/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.IO.Legacy;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Replays;
@@ -142,6 +143,8 @@ namespace osu.Game.Scoring.Legacy
                             score.ScoreInfo.TotalScoreWithoutMods = totalScoreWithoutMods;
                         else
                             PopulateTotalScoreWithoutMods(score.ScoreInfo);
+
+                        score.ScoreInfo.Pauses.AddRange(readScore.Pauses);
                     });
                 }
             }
diff --git a/osu.Game/Scoring/ScoreInfo.cs b/osu.Game/Scoring/ScoreInfo.cs
index a3dabc7945..9e10b93168 100644
--- a/osu.Game/Scoring/ScoreInfo.cs
+++ b/osu.Game/Scoring/ScoreInfo.cs
@@ -155,6 +155,8 @@ namespace osu.Game.Scoring
         [MapTo("MaximumStatistics")]
         public string MaximumStatisticsJson { get; set; } = string.Empty;
 
+        public IList<int> Pauses { get; } = null!;
+
         public ScoreInfo(BeatmapInfo? beatmap = null, RulesetInfo? ruleset = null, RealmUser? realmUser = null)
         {
             Ruleset = ruleset ?? new RulesetInfo();
diff --git a/osu.Game/Scoring/ScoreInfoExtensions.cs b/osu.Game/Scoring/ScoreInfoExtensions.cs
index 6e57a9fd0b..2eec0399d6 100644
--- a/osu.Game/Scoring/ScoreInfoExtensions.cs
+++ b/osu.Game/Scoring/ScoreInfoExtensions.cs
@@ -1,10 +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 System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Models;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Select.Leaderboards;
+using Realms;
 
 namespace osu.Game.Scoring
 {
@@ -26,11 +31,59 @@ namespace osu.Game.Scoring
                      // Local scores may not have an online ID. Fall back to date in these cases.
                      .ThenBy(s => s.Date);
 
+        /// <summary>
+        /// Orders an array of <see cref="ScoreInfo"/>s by the selected <see cref="LeaderboardSortMode"/>.
+        /// </summary>
+        /// <param name="scores">The array of <see cref="ScoreInfo"/>s to reorder.</param>
+        /// <param name="leaderboardSortMode">The attribute to sort the scores by.</param>
+        /// <returns>The given <paramref name="scores"/> ordered by the selected mode.</returns>
+        public static IEnumerable<ScoreInfo> OrderByCriteria(this IEnumerable<ScoreInfo> scores, LeaderboardSortMode leaderboardSortMode)
+        {
+            switch (leaderboardSortMode)
+            {
+                case LeaderboardSortMode.Score:
+                    return scores.OrderByDescending(s => s.TotalScore);
+
+                case LeaderboardSortMode.Accuracy:
+                    return scores.OrderByDescending(s => s.Accuracy).ThenByDescending(s => s.TotalScore);
+
+                case LeaderboardSortMode.MaxCombo:
+                    return scores.OrderByDescending(s => s.MaxCombo).ThenByDescending(s => s.TotalScore);
+
+                case LeaderboardSortMode.Misses:
+                    return scores.OrderBy(s => s.Statistics.GetValueOrDefault(HitResult.Miss, 0)).ThenByDescending(s => s.TotalScore);
+
+                case LeaderboardSortMode.Date:
+                    return scores.OrderByDescending(s => s.Date);
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(leaderboardSortMode), leaderboardSortMode, null);
+            }
+        }
+
         /// <summary>
         /// Retrieves the maximum achievable combo for the provided score.
         /// </summary>
         /// <param name="score">The <see cref="ScoreInfo"/> to compute the maximum achievable combo for.</param>
         /// <returns>The maximum achievable combo.</returns>
         public static int GetMaximumAchievableCombo(this ScoreInfo score) => score.MaximumStatistics.Where(kvp => kvp.Key.AffectsCombo()).Sum(kvp => kvp.Value);
+
+        /// <summary>
+        /// Performs a realm filter that returns all scores that belong to the user with the given <paramref name="userId"/>.
+        /// <see langword="null"/> <paramref name="userId"/> (for guests) is supported.
+        /// </summary>
+        /// <remarks>
+        /// All guest scores (with user ID of <see cref="APIUser.SYSTEM_USER_ID"/>),
+        /// as well as scores of unknown provenance (with default user ID of 1, see <see cref="APIUser.OnlineID"/>),
+        /// will be treated as if they belong to the local user.
+        /// This may not be necessarily considered fully correct in some circumstances, but in most cases it is the desired effect.
+        /// </remarks>
+        public static IQueryable<ScoreInfo> GetAllLocalScoresForUser(this Realm realm, int? userId)
+        {
+            return realm.All<ScoreInfo>()
+                        .Filter($@"({nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0 || {nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} <= 1)"
+                                + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
+                                + $@" && {nameof(ScoreInfo.DeletePending)} == false", userId);
+        }
     }
 }
diff --git a/osu.Game/Screens/Backgrounds/EditorBackgroundScreen.cs b/osu.Game/Screens/Backgrounds/EditorBackgroundScreen.cs
index 9982357157..24b582b71b 100644
--- a/osu.Game/Screens/Backgrounds/EditorBackgroundScreen.cs
+++ b/osu.Game/Screens/Backgrounds/EditorBackgroundScreen.cs
@@ -19,7 +19,6 @@ namespace osu.Game.Screens.Backgrounds
 {
     public partial class EditorBackgroundScreen : BackgroundScreen
     {
-        private readonly WorkingBeatmap beatmap;
         private readonly Container dimContainer;
 
         private CancellationTokenSource? cancellationTokenSource;
@@ -31,10 +30,14 @@ namespace osu.Game.Screens.Backgrounds
 
         private IFrameBasedClock? clockSource;
 
-        public EditorBackgroundScreen(WorkingBeatmap beatmap)
-        {
-            this.beatmap = beatmap;
+        // We retrieve IBindable<WorkingBeatmap> from our dependency cache instead of passing WorkingBeatmap directly into EditorBackgroundScreen.
+        // Otherwise, DummyWorkingBeatmap will be erroneously passed in whenever creating a new beatmap (since the Schedule() in the Editor that populates
+        // a new WorkingBeatmap with correct values generally runs after EditorBackgroundScreen is created), which causes any background changes to not be displayed.
+        [Resolved]
+        private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
 
+        public EditorBackgroundScreen()
+        {
             InternalChild = dimContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
@@ -54,14 +57,14 @@ namespace osu.Game.Screens.Backgrounds
 
         private IEnumerable<Drawable> createContent() =>
         [
-            new BeatmapBackground(beatmap) { RelativeSizeAxes = Axes.Both, },
+            new BeatmapBackground(beatmap.Value) { RelativeSizeAxes = Axes.Both, },
             // this kooky container nesting is here because the storyboard needs a custom clock
             // but also needs it on an isolated-enough level that doesn't break screen stack expiry logic (which happens if the clock was put on `this`),
             // or doesn't make it literally impossible to fade the storyboard in/out in real time (which happens if the fade transforms were to be applied directly to the storyboard).
             new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Child = new DrawableStoryboard(beatmap.Storyboard)
+                Child = new DrawableStoryboard(beatmap.Value.Storyboard)
                 {
                     Clock = clockSource ?? Clock,
                 }
@@ -82,7 +85,7 @@ namespace osu.Game.Screens.Backgrounds
             storyboardContainer.FadeTo(showStoryboard.Value ? 1 : 0, duration, Easing.OutQuint);
             // yes, this causes overdraw, but is also a (crude) fix for bad-looking transitions on screen entry
             // caused by the previous background on the background stack poking out from under this one and then instantly fading out
-            background.FadeColour(beatmap.Storyboard.ReplacesBackground && showStoryboard.Value ? Colour4.Black : Colour4.White, duration, Easing.OutQuint);
+            background.FadeColour(beatmap.Value.Storyboard.ReplacesBackground && showStoryboard.Value ? Colour4.Black : Colour4.White, duration, Easing.OutQuint);
         }
 
         public void ChangeClockSource(IFrameBasedClock frameBasedClock)
@@ -103,7 +106,7 @@ namespace osu.Game.Screens.Backgrounds
                 background = dimContainer.OfType<BeatmapBackground>().Single();
                 storyboardContainer = dimContainer.OfType<Container>().Single();
                 updateState(0);
-            }, (cancellationTokenSource ??= new CancellationTokenSource()).Token);
+            }, (cancellationTokenSource = new CancellationTokenSource()).Token);
         }
 
         public override bool Equals(BackgroundScreen? other)
diff --git a/osu.Game/Screens/Edit/BindableBeatDivisor.cs b/osu.Game/Screens/Edit/BindableBeatDivisor.cs
index bd9c9bab9a..83acc2622f 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;
@@ -129,6 +129,11 @@ namespace osu.Game.Screens.Edit
                 case 12:
                     return colours.YellowDarker;
 
+                case 5:
+                case 7:
+                case 9:
+                    return colours.GreenLight;
+
                 default:
                     return Color4.Red;
             }
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs
index 21b3b38388..afe14de3ea 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs
@@ -4,11 +4,9 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.Threading;
-using osu.Game.Overlays;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
@@ -26,7 +24,14 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
         [BackgroundDependencyLoader]
         private void load()
         {
-            Add(marker = new MarkerVisualisation());
+            Add(marker = new CentreMarker
+            {
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.Centre,
+                RelativePositionAxes = Axes.X,
+                Width = 10,
+                TriangleHeightRatio = 0.5f
+            });
         }
 
         protected override bool OnDragStart(DragStartEvent e) => true;
@@ -68,44 +73,5 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
         {
             // block base call so we don't clear our marker (can be reused on beatmap change).
         }
-
-        private partial class MarkerVisualisation : CompositeDrawable
-        {
-            public MarkerVisualisation()
-            {
-                Anchor = Anchor.CentreLeft;
-                Origin = Anchor.Centre;
-                RelativePositionAxes = Axes.X;
-                RelativeSizeAxes = Axes.Y;
-                AutoSizeAxes = Axes.X;
-                InternalChildren = new Drawable[]
-                {
-                    new Triangle
-                    {
-                        Anchor = Anchor.TopCentre,
-                        Origin = Anchor.BottomCentre,
-                        Scale = new Vector2(1, -1),
-                        Size = new Vector2(10, 5),
-                    },
-                    new Triangle
-                    {
-                        Anchor = Anchor.BottomCentre,
-                        Origin = Anchor.BottomCentre,
-                        Size = new Vector2(10, 5),
-                    },
-                    new Box
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Y,
-                        Width = 1.4f,
-                        EdgeSmoothness = new Vector2(1, 0)
-                    }
-                };
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colours) => Colour = colours.Highlight1;
-        }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
index c63dfdfb55..145049e1dd 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
@@ -4,7 +4,10 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Overlays;
 using osuTK;
 
@@ -12,47 +15,118 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
     public partial class CentreMarker : CompositeDrawable
     {
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colours)
+        public float TriangleHeightRatio
         {
-            const float triangle_width = 8;
-            const float bar_width = 2f;
+            get => triangles.TriangleHeightRatio;
+            set => triangles.TriangleHeightRatio = value;
+        }
 
+        private readonly VerticalTriangles triangles;
+
+        public CentreMarker()
+        {
             RelativeSizeAxes = Axes.Y;
-
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
-            Size = new Vector2(triangle_width, 1);
-
+            Masking = true;
             InternalChildren = new Drawable[]
             {
-                new Circle
+                new Box
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Y,
-                    Width = bar_width,
-                    Colour = colours.Colour2,
+                    Width = 1.4f,
+                    EdgeSmoothness = new Vector2(1, 0)
                 },
-                new Triangle
+                triangles = new VerticalTriangles
                 {
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.BottomCentre,
-                    Size = new Vector2(triangle_width, triangle_width * 0.8f),
-                    Scale = new Vector2(1, -1),
-                    EdgeSmoothness = new Vector2(1, 0),
-                    Colour = colours.Colour2,
-                },
-                new Triangle
-                {
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.BottomCentre,
-                    Size = new Vector2(triangle_width, triangle_width * 0.8f),
-                    Scale = new Vector2(1, 1),
-                    Colour = colours.Colour2,
-                },
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    EdgeSmoothness = Vector2.One
+                }
             };
         }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colours) => Colour = colours.Highlight1;
+
+        /// <summary>
+        /// Triangles drawn at the top and bottom of <see cref="CentreMarker"/>.
+        /// </summary>
+        /// <remarks>
+        /// Since framework-side triangles don't support antialiasing we are using custom implementation involving rotated smoothened boxes to avoid
+        /// mismatch in antialiasing between top and bottom triangles when drawable moves across the screen.
+        /// To "trim" boxes we must enable masking at the top level.
+        /// </remarks>
+        private partial class VerticalTriangles : Sprite
+        {
+            private float triangleHeightRatio = 1f;
+
+            public float TriangleHeightRatio
+            {
+                get => triangleHeightRatio;
+                set
+                {
+                    triangleHeightRatio = value;
+                    Invalidate(Invalidation.DrawNode);
+                }
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(IRenderer renderer)
+            {
+                Texture = renderer.WhitePixel;
+            }
+
+            protected override DrawNode CreateDrawNode() => new VerticalTrianglesDrawNode(this);
+
+            private class VerticalTrianglesDrawNode : SpriteDrawNode
+            {
+                public new VerticalTriangles Source => (VerticalTriangles)base.Source;
+
+                public VerticalTrianglesDrawNode(VerticalTriangles source)
+                    : base(source)
+                {
+                }
+
+                private float triangleScreenSpaceHeight;
+
+                public override void ApplyState()
+                {
+                    base.ApplyState();
+
+                    triangleScreenSpaceHeight = ScreenSpaceDrawQuad.Width * Source.TriangleHeightRatio;
+                }
+
+                protected override void Blit(IRenderer renderer)
+                {
+                    if (triangleScreenSpaceHeight == 0 || DrawRectangle.Width == 0 || DrawRectangle.Height == 0)
+                        return;
+
+                    Vector2 inflation = new Vector2(InflationAmount.X / DrawRectangle.Width, InflationAmount.Y / (DrawRectangle.Width * Source.TriangleHeightRatio));
+
+                    Quad topTriangle = new Quad
+                    (
+                        ScreenSpaceDrawQuad.TopLeft,
+                        ScreenSpaceDrawQuad.TopLeft + new Vector2(ScreenSpaceDrawQuad.Width * 0.5f, -triangleScreenSpaceHeight),
+                        ScreenSpaceDrawQuad.TopLeft + new Vector2(ScreenSpaceDrawQuad.Width * 0.5f, triangleScreenSpaceHeight),
+                        ScreenSpaceDrawQuad.TopRight
+                    );
+
+                    Quad bottomTriangle = new Quad
+                    (
+                        ScreenSpaceDrawQuad.BottomLeft,
+                        ScreenSpaceDrawQuad.BottomLeft + new Vector2(ScreenSpaceDrawQuad.Width * 0.5f, -triangleScreenSpaceHeight),
+                        ScreenSpaceDrawQuad.BottomLeft + new Vector2(ScreenSpaceDrawQuad.Width * 0.5f, triangleScreenSpaceHeight),
+                        ScreenSpaceDrawQuad.BottomRight
+                    );
+
+                    renderer.DrawQuad(Texture, topTriangle, DrawColourInfo.Colour, inflationPercentage: inflation);
+                    renderer.DrawQuad(Texture, bottomTriangle, DrawColourInfo.Colour, inflationPercentage: inflation);
+                }
+
+                protected override bool CanDrawOpaqueInterior => false;
+            }
+        }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
index 5e8637c1ac..cdd2f52dab 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
@@ -16,7 +16,6 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Audio;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
@@ -57,9 +56,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         protected virtual double GetTime() => HitObject is IHasRepeats r ? HitObject.StartTime + r.Duration / r.SpanCount() / 2 : HitObject.StartTime;
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
         {
-            HitObject.DefaultsApplied += _ => updateText();
             Label.AllowMultiline = false;
             LabelContainer.AutoSizeAxes = Axes.None;
             updateText();
@@ -74,6 +72,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             base.LoadComplete();
 
+            HitObject.DefaultsApplied += onDefaultsApplied;
+
             if (timelineBlueprintContainer != null)
                 contracted.BindTo(timelineBlueprintContainer.SamplePointContracted);
 
@@ -96,12 +96,19 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             FinishTransforms();
         }
 
+        private void onDefaultsApplied(HitObject hitObject)
+        {
+            updateText();
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
             if (editor != null)
                 editor.ShowSampleEditPopoverRequested -= onShowSampleEditPopoverRequested;
+
+            HitObject.DefaultsApplied -= onDefaultsApplied;
         }
 
         private void onShowSampleEditPopoverRequested(double time)
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
index cbf49e62e7..cbafea7600 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
@@ -107,7 +107,14 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             CentreMarker centreMarker;
 
             // We don't want the centre marker to scroll
-            AddInternal(centreMarker = new CentreMarker());
+            AddInternal(centreMarker = new CentreMarker
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                Width = 8,
+                TriangleHeightRatio = 0.8f,
+                Colour = colourProvider.Colour2
+            });
 
             AddRange(new Drawable[]
             {
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 365a59b033..05f74c8514 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -480,7 +480,7 @@ namespace osu.Game.Screens.Edit
         [Resolved]
         private MusicController musicController { get; set; }
 
-        protected override BackgroundScreen CreateBackground() => new EditorBackgroundScreen(Beatmap.Value);
+        protected override BackgroundScreen CreateBackground() => new EditorBackgroundScreen();
 
         protected override void LoadComplete()
         {
diff --git a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
index 02eb38ffa6..eedde8b7a4 100644
--- a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
+++ b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
@@ -55,12 +55,25 @@ namespace osu.Game.Screens.Edit.GameplayTest
             return masterGameplayClockContainer;
         }
 
+        protected override void LoadAsyncComplete()
+        {
+            base.LoadAsyncComplete();
+
+            if (!LoadedBeatmapSuccessfully)
+                return;
+
+            // This hack needs to be called to install its hooks before drawable hit objects get the chance to run update logic,
+            // because it will not work otherwise due to being too late (various effects of the objects getting missed will have already taken place).
+            preventMissOnPreviousHitObjects();
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            // this will notify components such as the skin's combo counter, which needs to happen on the update thread
+            // and therefore can't happen alongside `preventMissOnPreviousHitObjects()` in `LoadAsyncComplete()`
             markPreviousObjectsHit();
-            markVisibleDrawableObjectsHit();
 
             ScoreProcessor.HasCompleted.BindValueChanged(completed =>
             {
@@ -111,38 +124,45 @@ namespace osu.Game.Screens.Edit.GameplayTest
             }
         }
 
-        private void markVisibleDrawableObjectsHit()
+        private void preventMissOnPreviousHitObjects()
         {
-            if (!DrawableRuleset.Playfield.IsLoaded)
+            void preventMiss(HitObject hitObject)
             {
-                Schedule(markVisibleDrawableObjectsHit);
-                return;
+                var drawableObject = DrawableRuleset.Playfield.HitObjectContainer
+                                                    .AliveObjects
+                                                    .SingleOrDefault(it => it.HitObject == hitObject);
+
+                if (drawableObject != null)
+                    preventMissOnDrawable(drawableObject);
             }
 
-            foreach (var drawableObject in enumerateDrawableObjects(DrawableRuleset.Playfield.AllHitObjects, editorState.Time))
+            void preventMissOnDrawable(DrawableHitObject drawableObject)
             {
-                if (drawableObject.Entry == null)
-                    continue;
+                foreach (var nested in drawableObject.NestedHitObjects)
+                    preventMissOnDrawable(nested);
 
-                var result = drawableObject.CreateResult(drawableObject.HitObject.Judgement);
-                result.Type = result.Judgement.MaxResult;
-                drawableObject.Entry.Result = result;
-            }
-
-            static IEnumerable<DrawableHitObject> enumerateDrawableObjects(IEnumerable<DrawableHitObject> drawableObjects, double cutoffTime)
-            {
-                foreach (var drawableObject in drawableObjects)
+                if (drawableObject.Entry != null && drawableObject.HitObject.GetEndTime() < editorState.Time)
                 {
-                    foreach (var nested in enumerateDrawableObjects(drawableObject.NestedHitObjects, cutoffTime))
-                    {
-                        if (nested.HitObject.GetEndTime() < cutoffTime)
-                            yield return nested;
-                    }
-
-                    if (drawableObject.HitObject.GetEndTime() < cutoffTime)
-                        yield return drawableObject;
+                    var result = drawableObject.CreateResult(drawableObject.HitObject.Judgement);
+                    result.Type = result.Judgement.MaxResult;
+                    drawableObject.Entry.Result = result;
                 }
             }
+
+            void removeListener()
+            {
+                if (!DrawableRuleset.Playfield.IsLoaded)
+                {
+                    Schedule(removeListener);
+                    return;
+                }
+
+                DrawableRuleset.Playfield.HitObjectUsageBegan -= preventMiss;
+            }
+
+            DrawableRuleset.Playfield.HitObjectUsageBegan += preventMiss;
+
+            Schedule(removeListener);
         }
 
         protected override void PrepareReplay()
diff --git a/osu.Game/Screens/Edit/Setup/MetadataSection.cs b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
index 288dc5cad6..56b5d8aaaf 100644
--- a/osu.Game/Screens/Edit/Setup/MetadataSection.cs
+++ b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
@@ -116,7 +116,7 @@ namespace osu.Game.Screens.Edit.Setup
             ArtistTextBox.Current.Value = !string.IsNullOrEmpty(metadata.ArtistUnicode) ? metadata.ArtistUnicode : metadata.Artist;
             RomanisedArtistTextBox.Current.Value = !string.IsNullOrEmpty(metadata.Artist) ? metadata.Artist : MetadataUtils.StripNonRomanisedCharacters(metadata.ArtistUnicode);
             TitleTextBox.Current.Value = !string.IsNullOrEmpty(metadata.TitleUnicode) ? metadata.TitleUnicode : metadata.Title;
-            RomanisedTitleTextBox.Current.Value = !string.IsNullOrEmpty(metadata.Title) ? metadata.Title : MetadataUtils.StripNonRomanisedCharacters(metadata.ArtistUnicode);
+            RomanisedTitleTextBox.Current.Value = !string.IsNullOrEmpty(metadata.Title) ? metadata.Title : MetadataUtils.StripNonRomanisedCharacters(metadata.TitleUnicode);
             creatorTextBox.Current.Value = metadata.Author.Username;
             difficultyTextBox.Current.Value = Beatmap.BeatmapInfo.DifficultyName;
             sourceTextBox.Current.Value = metadata.Source;
diff --git a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
index 03ab23d8e4..78066edc7e 100644
--- a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
+++ b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
@@ -200,6 +200,13 @@ namespace osu.Game.Screens.Edit.Submission
             }
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            configManager.BindWith(OsuSetting.EditorSubmissionNotifyOnDiscussionReplies, settings.NotifyOnDiscussionReplies);
+        }
+
         private void createBeatmapSet()
         {
             bool beatmapHasOnlineId = Beatmap.Value.BeatmapSetInfo.OnlineID > 0;
diff --git a/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs b/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
index 7b80fdee7d..26b99d4e4d 100644
--- a/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
+++ b/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
@@ -23,7 +23,6 @@ namespace osu.Game.Screens.Edit.Submission
     [LocalisableDescription(typeof(BeatmapSubmissionStrings), nameof(BeatmapSubmissionStrings.SubmissionSettings))]
     public partial class ScreenSubmissionSettings : WizardScreen
     {
-        private readonly BindableBool notifyOnDiscussionReplies = new BindableBool();
         private readonly BindableBool loadInBrowserAfterSubmission = new BindableBool();
 
         public override LocalisableString? NextStepText => BeatmapSubmissionStrings.ConfirmSubmission;
@@ -34,7 +33,6 @@ namespace osu.Game.Screens.Edit.Submission
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager configManager, OsuColour colours)
         {
-            configManager.BindWith(OsuSetting.EditorSubmissionNotifyOnDiscussionReplies, settings.NotifyOnDiscussionReplies);
             configManager.BindWith(OsuSetting.EditorSubmissionLoadInBrowserAfterSubmission, loadInBrowserAfterSubmission);
 
             Content.Add(new FillFlowContainer
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/Edit/Verify/IssueList.cs b/osu.Game/Screens/Edit/Verify/IssueList.cs
index de7b760bcd..8222e5633e 100644
--- a/osu.Game/Screens/Edit/Verify/IssueList.cs
+++ b/osu.Game/Screens/Edit/Verify/IssueList.cs
@@ -33,6 +33,9 @@ namespace osu.Game.Screens.Edit.Verify
         [Resolved]
         private VerifyScreen verify { get; set; }
 
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; }
+
         private IBeatmapVerifier rulesetVerifier;
         private BeatmapVerifier generalVerifier;
         private BeatmapVerifierContext context;
@@ -43,7 +46,13 @@ namespace osu.Game.Screens.Edit.Verify
             generalVerifier = new BeatmapVerifier();
             rulesetVerifier = beatmap.BeatmapInfo.Ruleset.CreateInstance().CreateBeatmapVerifier();
 
-            context = new BeatmapVerifierContext(beatmap, workingBeatmap.Value, verify.InterpretedDifficulty.Value);
+            context = BeatmapVerifierContext.Create(
+                beatmap,
+                workingBeatmap.Value,
+                verify.InterpretedDifficulty.Value,
+                beatmapManager
+            );
+
             verify.InterpretedDifficulty.BindValueChanged(difficulty => context.InterpretedDifficulty = difficulty.NewValue);
 
             RelativeSizeAxes = Axes.Both;
@@ -85,6 +94,7 @@ namespace osu.Game.Screens.Edit.Verify
             base.LoadComplete();
 
             verify.InterpretedDifficulty.BindValueChanged(_ => Refresh());
+            verify.VerifyChecksScope.BindValueChanged(_ => Refresh());
             verify.HiddenIssueTypes.BindCollectionChanged((_, _) => Refresh());
 
             Refresh();
@@ -107,7 +117,9 @@ namespace osu.Game.Screens.Edit.Verify
 
         private IEnumerable<Issue> filter(IEnumerable<Issue> issues)
         {
-            return issues.Where(issue => !verify.HiddenIssueTypes.Contains(issue.Template.Type));
+            return issues.Where(issue =>
+                !verify.HiddenIssueTypes.Contains(issue.Template.Type) &&
+                issue.Check.Metadata.Scope == verify.VerifyChecksScope.Value);
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Verify/IssueSettings.cs b/osu.Game/Screens/Edit/Verify/IssueSettings.cs
index 6d3c0520a2..01b41e622a 100644
--- a/osu.Game/Screens/Edit/Verify/IssueSettings.cs
+++ b/osu.Game/Screens/Edit/Verify/IssueSettings.cs
@@ -10,6 +10,7 @@ namespace osu.Game.Screens.Edit.Verify
     {
         protected override IReadOnlyList<Drawable> CreateSections() => new Drawable[]
         {
+            new ScopeSection(),
             new InterpretationSection(),
             new VisibilitySection()
         };
diff --git a/osu.Game/Screens/Edit/Verify/ScopeSection.cs b/osu.Game/Screens/Edit/Verify/ScopeSection.cs
new file mode 100644
index 0000000000..51807d5a8f
--- /dev/null
+++ b/osu.Game/Screens/Edit/Verify/ScopeSection.cs
@@ -0,0 +1,27 @@
+// 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.Graphics;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Screens.Edit.Verify
+{
+    internal partial class ScopeSection : EditorRoundedScreenSettingsSection
+    {
+        protected override string HeaderText => "Scope";
+
+        [BackgroundDependencyLoader]
+        private void load(VerifyScreen verify)
+        {
+            Flow.Add(new SettingsEnumDropdown<CheckScope>
+            {
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                TooltipText = "Select which type of checks to display",
+                Current = verify.VerifyChecksScope.GetBoundCopy()
+            });
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Verify/VerifyScreen.cs b/osu.Game/Screens/Edit/Verify/VerifyScreen.cs
index fe508860e0..208b33770f 100644
--- a/osu.Game/Screens/Edit/Verify/VerifyScreen.cs
+++ b/osu.Game/Screens/Edit/Verify/VerifyScreen.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Screens.Edit.Verify
 
         public readonly Bindable<DifficultyRating> InterpretedDifficulty = new Bindable<DifficultyRating>();
 
+        public readonly Bindable<CheckScope> VerifyChecksScope = new Bindable<CheckScope>();
+
         public readonly BindableList<IssueType> HiddenIssueTypes = new BindableList<IssueType> { IssueType.Negligible };
 
         public IssueList IssueList { get; private set; }
diff --git a/osu.Game/Screens/Footer/ScreenFooter.cs b/osu.Game/Screens/Footer/ScreenFooter.cs
index 6d7a32d57a..777ec1790c 100644
--- a/osu.Game/Screens/Footer/ScreenFooter.cs
+++ b/osu.Game/Screens/Footer/ScreenFooter.cs
@@ -165,12 +165,18 @@ namespace osu.Game.Screens.Footer
 
         protected override void PopIn()
         {
+            buttonsFlow.FadeIn(transition_duration / 4, Easing.OutQuint);
+
             this.MoveToY(0, transition_duration, Easing.OutQuint)
                 .FadeIn();
         }
 
         protected override void PopOut()
         {
+            // Really we shouldn't need to do this, but some buttons protrude vertically more than expected
+            // (see FooterButtonMods).
+            buttonsFlow.FadeOut(transition_duration, Easing.OutQuint);
+
             this.MoveToY(ScreenFooterButton.HEIGHT, transition_duration, Easing.OutQuint)
                 .Then()
                 .FadeOut();
diff --git a/osu.Game/Screens/Import/FileImportScreen.cs b/osu.Game/Screens/Import/FileImportScreen.cs
index 1bdacae87f..bd35b8131e 100644
--- a/osu.Game/Screens/Import/FileImportScreen.cs
+++ b/osu.Game/Screens/Import/FileImportScreen.cs
@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -29,6 +30,7 @@ namespace osu.Game.Screens.Import
         private TextFlowContainer currentFileText;
 
         private RoundedButton importButton;
+        private RoundedButton importAllButton;
 
         private const float duration = 300;
         private const float button_height = 50;
@@ -74,7 +76,7 @@ namespace osu.Game.Screens.Import
                             new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Bottom = button_height + button_vertical_margin * 2 },
+                                Padding = new MarginPadding { Bottom = button_height * 2 + button_vertical_margin * 3 },
                                 Child = new OsuScrollContainer
                                 {
                                     RelativeSizeAxes = Axes.Both,
@@ -97,14 +99,27 @@ namespace osu.Game.Screens.Import
                             },
                             importButton = new RoundedButton
                             {
-                                Text = "Import",
+                                Text = "Import selected file",
                                 Anchor = Anchor.BottomCentre,
                                 Origin = Anchor.BottomCentre,
                                 RelativeSizeAxes = Axes.X,
                                 Height = button_height,
                                 Width = 0.9f,
-                                Margin = new MarginPadding { Vertical = button_vertical_margin },
+                                Margin = new MarginPadding { Bottom = button_height + button_vertical_margin * 2 },
                                 Action = () => startImport(fileSelector.CurrentFile.Value?.FullName)
+                            },
+
+                            importAllButton = new RoundedButton
+                            {
+                                Text = "Import all files from directory",
+                                Anchor = Anchor.BottomCentre,
+                                Origin = Anchor.BottomCentre,
+                                RelativeSizeAxes = Axes.X,
+                                Height = button_height,
+                                Width = 0.9f,
+                                TooltipText = "Imports all osu files from selected directory",
+                                Margin = new MarginPadding { Vertical = button_vertical_margin },
+                                Action = () => startDirectoryImport(fileSelector.CurrentPath.Value?.FullName)
                             }
                         }
                     }
@@ -131,10 +146,20 @@ namespace osu.Game.Screens.Import
             return base.OnExiting(e);
         }
 
-        private void directoryChanged(ValueChangedEvent<DirectoryInfo> _)
+        private void directoryChanged(ValueChangedEvent<DirectoryInfo> directoryChangedEvent)
         {
             // this should probably be done by the selector itself, but let's do it here for now.
             fileSelector.CurrentFile.Value = null;
+
+            DirectoryInfo newDirectory = directoryChangedEvent.NewValue;
+            importAllButton.Enabled.Value =
+                // this will be `null` if the user clicked the "Computer" option (showing drives)
+                // handling that is difficult due to platform differences, and nobody sane wants that to work with the "import all" button anyway
+                newDirectory != null
+                // extra safety against various I/O errors (lack of access, deleted directory, etc.)
+                && newDirectory.Exists
+                // there must be at least one file in the current directory for the game to import (non-recursive)
+                && newDirectory.EnumerateFiles().Any(file => game.HandledExtensions.Contains(file.Extension));
         }
 
         private void fileChanged(ValueChangedEvent<FileInfo> selectedFile)
@@ -143,14 +168,14 @@ namespace osu.Game.Screens.Import
             currentFileText.Text = selectedFile.NewValue?.Name ?? "Select a file";
         }
 
-        private void startImport(string path)
+        private void startImport(params string[] paths)
         {
-            if (string.IsNullOrEmpty(path))
+            if (paths.Length == 0)
                 return;
 
             Task.Factory.StartNew(async () =>
             {
-                await game.Import(path).ConfigureAwait(false);
+                await game.Import(paths).ConfigureAwait(false);
 
                 // some files will be deleted after successful import, so we want to refresh the view.
                 Schedule(() =>
@@ -160,5 +185,19 @@ namespace osu.Game.Screens.Import
                 });
             }, TaskCreationOptions.LongRunning);
         }
+
+        private void startDirectoryImport(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+                return;
+
+            // get only files that match extensions handled by the game
+            IEnumerable<string> filesToImport = Directory.EnumerateFiles(path)
+                                                         .Where(file => game.HandledExtensions.Contains(Path.GetExtension(file)));
+            if (!filesToImport.Any())
+                return;
+
+            startImport(filesToImport.ToArray());
+        }
     }
 }
diff --git a/osu.Game/Screens/Menu/MenuTipDisplay.cs b/osu.Game/Screens/Menu/MenuTipDisplay.cs
index d9e38e8aa0..d9c90b069d 100644
--- a/osu.Game/Screens/Menu/MenuTipDisplay.cs
+++ b/osu.Game/Screens/Menu/MenuTipDisplay.cs
@@ -4,6 +4,8 @@
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -16,7 +18,6 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osuTK;
-using osuTK.Graphics;
 using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Menu
@@ -26,6 +27,9 @@ namespace osu.Game.Screens.Menu
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
 
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
         private LinkFlowContainer textFlow = null!;
 
         private Bindable<bool> showMenuTips = null!;
@@ -45,14 +49,14 @@ namespace osu.Game.Screens.Menu
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     CornerExponent = 2.5f,
-                    CornerRadius = 15,
+                    CornerRadius = 10,
                     Children = new Drawable[]
                     {
                         new Box
                         {
-                            Colour = Color4.Black,
+                            Colour = Color4Extensions.FromHex("#171A1C"),
                             RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.4f,
+                            Alpha = 0.75f,
                         },
                     }
                 },
@@ -84,12 +88,23 @@ namespace osu.Game.Screens.Menu
             }
 
             static void formatRegular(SpriteText t) => t.Font = OsuFont.GetFont(size: 16, weight: FontWeight.Regular);
-            static void formatSemiBold(SpriteText t) => t.Font = OsuFont.GetFont(size: 16, weight: FontWeight.SemiBold);
+
+            void formatSemiBold(SpriteText t)
+            {
+                t.Font = OsuFont.GetFont(Typeface.TorusAlternate, 16, weight: FontWeight.SemiBold);
+                t.Colour = colours.Pink0;
+            }
 
             var tip = getRandomTip();
 
             textFlow.Clear();
-            textFlow.AddParagraph(MenuTipStrings.MenuTipTitle, formatSemiBold);
+            textFlow.AddIcon(FontAwesome.Solid.Lightbulb, icon =>
+            {
+                icon.Colour = colours.Pink0;
+                icon.Size = new Vector2(16);
+            });
+            textFlow.AddText(" ");
+            textFlow.AddText(MenuTipStrings.MenuTipTitle.ToSentence(), formatSemiBold);
             textFlow.AddParagraph(tip, formatRegular);
 
             this
@@ -103,7 +118,7 @@ namespace osu.Game.Screens.Menu
                 .FadeOutFromOne(2000, Easing.OutQuint);
         }
 
-        private const int available_tips = 29;
+        private const int available_tips = 30;
 
         private LocalisableString getRandomTip()
         {
@@ -112,10 +127,12 @@ namespace osu.Game.Screens.Menu
             switch (tipIndex)
             {
                 case 0:
-                    return MenuTipStrings.ToggleToolbarShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleToolbar).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+                    return MenuTipStrings.ToggleToolbarShortcut(
+                        keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleToolbar).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
 
                 case 1:
-                    return MenuTipStrings.GameSettingsShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleSettings).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+                    return MenuTipStrings.GameSettingsShortcut(
+                        keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleSettings).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
 
                 case 2:
                     return MenuTipStrings.DynamicSettings;
@@ -130,7 +147,8 @@ namespace osu.Game.Screens.Menu
                     return MenuTipStrings.ScreenScalingSettings;
 
                 case 6:
-                    return MenuTipStrings.FreeOsuDirect(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleBeatmapListing).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+                    return MenuTipStrings.FreeOsuDirect(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleBeatmapListing).FirstOrDefault()
+                                                        ?? InputSettingsStrings.ActionHasNoKeyBinding);
 
                 case 7:
                     return MenuTipStrings.ReplaySeeking;
@@ -184,7 +202,8 @@ namespace osu.Game.Screens.Menu
                     return MenuTipStrings.RandomSkinShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.RandomSkin).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
 
                 case 24:
-                    return MenuTipStrings.ToggleReplaySettingsShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleReplaySettings).FirstOrDefault() ?? InputSettingsStrings.ActionHasNoKeyBinding);
+                    return MenuTipStrings.ToggleReplaySettingsShortcut(keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.ToggleReplaySettings).FirstOrDefault()
+                                                                       ?? InputSettingsStrings.ActionHasNoKeyBinding);
 
                 case 25:
                     return MenuTipStrings.CopyModsFromScore;
@@ -197,6 +216,9 @@ namespace osu.Game.Screens.Menu
 
                 case 28:
                     return MenuTipStrings.RightMouseAbsoluteScroll;
+
+                case 29:
+                    return MenuTipStrings.ShiftClickInBeatmapOverlay;
             }
 
             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/Components/StarRatingRangeDisplay.cs b/osu.Game/Screens/OnlinePlay/Components/StarRatingRangeDisplay.cs
index e2aecb6781..f5b2bd018d 100644
--- a/osu.Game/Screens/OnlinePlay/Components/StarRatingRangeDisplay.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/StarRatingRangeDisplay.cs
@@ -2,6 +2,7 @@
 // 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.Allocation;
@@ -115,7 +116,14 @@ namespace osu.Game.Screens.OnlinePlay.Components
             else
             {
                 // When Playlist is not empty (in room) we compute actual range
-                var orderedDifficulties = room.Playlist.Select(p => p.Beatmap).OrderBy(b => b.StarRating).ToArray();
+                IReadOnlyList<PlaylistItem> difficultyRangeSource = room.Playlist.Where(item => !item.Expired).ToList();
+
+                if (difficultyRangeSource.Count == 0)
+                    difficultyRangeSource = room.Playlist;
+
+                var orderedDifficulties = difficultyRangeSource.Select(item => item.Beatmap)
+                                                               .OrderBy(b => b.StarRating)
+                                                               .ToArray();
 
                 minDifficulty = new StarDifficulty(orderedDifficulties.Length > 0 ? orderedDifficulties[0].StarRating : 0, 0);
                 maxDifficulty = new StarDifficulty(orderedDifficulties.Length > 0 ? orderedDifficulties[^1].StarRating : 0, 0);
diff --git a/osu.Game/Screens/OnlinePlay/Header.cs b/osu.Game/Screens/OnlinePlay/Header.cs
index 860042fd37..825f809397 100644
--- a/osu.Game/Screens/OnlinePlay/Header.cs
+++ b/osu.Game/Screens/OnlinePlay/Header.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.OnlinePlay
 {
     public partial class Header : Container
     {
-        public const float HEIGHT = 80;
+        public const float HEIGHT = 50;
 
         private readonly ScreenStack? stack;
         private readonly MultiHeaderTitle title;
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
index 5bcc974c26..135b2b4db2 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
@@ -23,10 +23,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 {
     public partial class DrawableRoomParticipantsList : CompositeDrawable
     {
-        public const float SHEAR_WIDTH = 12f;
-        private const float avatar_size = 36;
-        private const float height = 60f;
-        private static readonly Vector2 shear = new Vector2(SHEAR_WIDTH / height, 0);
+        private const float avatar_size = 30;
+        private const float height = 40f;
 
         private readonly Room room;
 
@@ -54,7 +52,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     CornerRadius = 10,
-                    Shear = shear,
+                    Shear = OsuGame.SHEAR,
                     Child = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
@@ -71,10 +69,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         {
                             RelativeSizeAxes = Axes.Y,
                             AutoSizeAxes = Axes.X,
-                            Spacing = new Vector2(8),
+                            Spacing = new Vector2(4),
                             Padding = new MarginPadding
                             {
-                                Left = 8,
+                                Left = 4,
                                 Right = 16
                             },
                             Children = new Drawable[]
@@ -84,7 +82,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
                                 },
-                                hostText = new LinkFlowContainer
+                                hostText = new LinkFlowContainer(s => s.Font = OsuFont.Style.Caption2)
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
@@ -103,7 +101,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     RelativeSizeAxes = Axes.Both,
                                     Masking = true,
                                     CornerRadius = 10,
-                                    Shear = shear,
+                                    Shear = OsuGame.SHEAR,
                                     Child = new Box
                                     {
                                         RelativeSizeAxes = Axes.Both,
@@ -128,12 +126,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                         {
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
-                                            Size = new Vector2(16),
+                                            Size = new Vector2(12),
                                             Icon = FontAwesome.Solid.User,
                                         },
                                         totalCount = new OsuSpriteText
                                         {
-                                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
+                                            Font = OsuFont.Style.Caption2.With(weight: FontWeight.Bold),
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
                                         },
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
index 14edd13ec5..f04de97f9b 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
@@ -45,8 +45,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         private readonly ScrollContainer<Drawable> scroll;
         private readonly FillFlowContainer<LoungeRoomPanel> roomFlow;
 
-        private const float display_scale = 0.8f;
-
         // handle deselection
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
@@ -58,7 +56,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.TopCentre,
                 Origin = Anchor.TopCentre,
-                Width = display_scale,
+                Width = 0.8f,
                 ScrollbarOverlapsContent = false,
                 Padding = new MarginPadding { Right = 5 },
                 Child = new OsuContextMenuContainer
@@ -188,14 +186,11 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     SelectedRoom = selectedRoom,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Scale = new Vector2(display_scale),
-                    Width = 1 / display_scale,
                 };
 
                 roomFlow.Add(drawableRoom);
 
-                // Always show spotlight playlists at the top of the listing.
-                roomFlow.SetLayoutPosition(drawableRoom, room.Category > RoomCategory.Normal ? float.MinValue : -(room.RoomID ?? 0));
+                roomFlow.SetLayoutPosition(drawableRoom, room.Pinned ? float.MinValue : -(room.RoomID ?? 0));
             }
 
             applyFilterCriteria(Filter.Value);
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
index 3610995b2c..fe03fca4b8 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
@@ -31,7 +31,6 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Components;
 using osuTK;
-using osuTK.Graphics;
 using Container = osu.Framework.Graphics.Containers.Container;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge.Components
@@ -39,7 +38,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
     public abstract partial class RoomPanel : CompositeDrawable, IHasContextMenu
     {
         protected const float CORNER_RADIUS = 10;
-        private const float height = 100;
+        private const float height = 80;
 
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
@@ -59,7 +58,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
         private DrawableRoomParticipantsList? drawableRoomParticipantsList;
         private RoomSpecialCategoryPill? specialCategoryPill;
-        private PasswordProtectedIcon? passwordIcon;
+        private CornerIcon? passwordIcon;
+        private CornerIcon? pinnedIcon;
         private EndDateInfo? endDateInfo;
         private RoomNameLine? roomName;
         private DelayedLoadWrapper wrapper = null!;
@@ -79,16 +79,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
             Masking = true;
             CornerRadius = CORNER_RADIUS;
-            EdgeEffect = new EdgeEffectParameters
-            {
-                Type = EdgeEffectType.Shadow,
-                Colour = Color4.Black.Opacity(40),
-                Radius = 5,
-            };
         }
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colours)
+        private void load(OverlayColourProvider colourProvider, OsuColour colours)
         {
             ButtonsContainer = new Container
             {
@@ -98,13 +92,20 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 AutoSizeAxes = Axes.X
             };
 
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Shadow,
+                Colour = colourProvider.Background6.Opacity(0.4f),
+                Radius = 4,
+            };
+
             InternalChildren = new Drawable[]
             {
                 // This resolves internal 1px gaps due to applying the (parenting) corner radius and masking across multiple filling background sprites.
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = colours.Background5,
+                    Colour = colourProvider.Background5,
                 },
                 CreateBackground().With(d =>
                 {
@@ -117,7 +118,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         Name = @"Room content",
                         RelativeSizeAxes = Axes.Both,
                         // This negative padding resolves 1px gaps between this background and the background above.
-                        Padding = new MarginPadding { Left = 20, Vertical = -0.5f },
+                        Padding = new MarginPadding { Left = 10, Vertical = -0.5f },
                         Child = new Container
                         {
                             RelativeSizeAxes = Axes.Both,
@@ -128,7 +129,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                 new Box
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Colour = colours.Background5,
+                                    Colour = colourProvider.Background5,
                                     Width = 0.2f,
                                 },
                                 new Box
@@ -136,7 +137,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     Anchor = Anchor.TopRight,
                                     Origin = Anchor.TopRight,
                                     RelativeSizeAxes = Axes.Both,
-                                    Colour = ColourInfo.GradientHorizontal(colours.Background5, colours.Background5.Opacity(0.3f)),
+                                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background5, colourProvider.Background5.Opacity(0.3f)),
                                     Width = 0.8f,
                                 },
                                 new GridContainer
@@ -157,8 +158,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                                 RelativeSizeAxes = Axes.Both,
                                                 Padding = new MarginPadding
                                                 {
-                                                    Left = 20,
-                                                    Right = DrawableRoomParticipantsList.SHEAR_WIDTH,
+                                                    Left = 10,
+                                                    Right = 10,
                                                     Vertical = 5
                                                 },
                                                 Children = new Drawable[]
@@ -254,7 +255,28 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                         }
                                     }
                                 },
-                                passwordIcon = new PasswordProtectedIcon { Alpha = 0 }
+                                passwordIcon = new CornerIcon
+                                {
+                                    Alpha = 0,
+                                    Background = { Colour = colours.Gray8, },
+                                    Icon =
+                                    {
+                                        Icon = FontAwesome.Solid.Lock,
+                                        Colour = colours.Gray3,
+                                        Rotation = 45,
+                                    },
+                                },
+                                pinnedIcon = new CornerIcon
+                                {
+                                    Alpha = 0,
+                                    Background = { Colour = colours.Orange2 },
+                                    Icon =
+                                    {
+                                        Icon = FontAwesome.Solid.Thumbtack,
+                                        Colour = colours.Gray3,
+                                        Rotation = 45,
+                                    },
+                                }
                             },
                         },
                     }, 0)
@@ -283,6 +305,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 updateRoomCategory();
                 updateRoomType();
                 updateRoomHasPassword();
+                updateRoomPinned();
             };
 
             SelectedItem.BindValueChanged(onSelectedItemChanged, true);
@@ -311,6 +334,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 case nameof(Room.HasPassword):
                     updateRoomHasPassword();
                     break;
+
+                case nameof(Room.Pinned):
+                    updateRoomPinned();
+                    break;
             }
         }
 
@@ -371,6 +398,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 passwordIcon.Alpha = Room.HasPassword ? 1 : 0;
         }
 
+        private void updateRoomPinned()
+        {
+            if (pinnedIcon != null)
+                pinnedIcon.Alpha = Room.Pinned ? 1 : 0;
+        }
+
         private int numberOfAvatars = 7;
 
         public int NumberOfAvatars
@@ -483,12 +516,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         {
                             statusText = new OsuSpriteText
                             {
-                                Font = OsuFont.Default.With(size: 16),
+                                Font = OsuFont.Style.Caption2,
                                 Colour = colours.Lime1
                             },
                             beatmapText = new LinkFlowContainer(s =>
                             {
-                                s.Font = OsuFont.Default.With(size: 16);
+                                s.Font = OsuFont.Style.Caption2;
                                 s.Colour = colours.Lime1;
                             })
                             {
@@ -534,10 +567,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
-        public partial class PasswordProtectedIcon : CompositeDrawable
+        public partial class CornerIcon : CompositeDrawable
         {
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
+            public SpriteIcon Icon { get; }
+            public Box Background { get; }
+
+            public CornerIcon()
             {
                 Anchor = Anchor.TopRight;
                 Origin = Anchor.TopRight;
@@ -546,20 +581,19 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
                 InternalChildren = new Drawable[]
                 {
-                    new Box
+                    Background = new Box
                     {
                         Anchor = Anchor.TopRight,
                         Origin = Anchor.TopCentre,
-                        Colour = colours.Gray5,
                         Rotation = 45,
                         RelativeSizeAxes = Axes.Both,
                         Width = 2,
                     },
-                    new SpriteIcon
+                    Icon = new SpriteIcon
                     {
-                        Icon = FontAwesome.Solid.Lock,
                         Anchor = Anchor.TopRight,
-                        Origin = Anchor.TopRight,
+                        Origin = Anchor.Centre,
+                        Position = new Vector2(-13, 13),
                         Margin = new MarginPadding(6),
                         Size = new Vector2(14),
                     }
@@ -602,7 +636,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
-                        Font = OsuFont.GetFont(size: 28),
+                        Font = OsuFont.Style.Heading2,
                     },
                     linkButton = new ExternalLinkButton
                     {
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
index a4e808ff76..b4b039501f 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
@@ -173,7 +173,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                                         {
                                             d.Anchor = Anchor.BottomLeft;
                                             d.Origin = Anchor.BottomLeft;
-                                            d.Size = new Vector2(150, 37.5f);
+                                            d.Size = new Vector2(150, 30f);
                                             d.Action = () => Open();
                                         })),
                                         new FillFlowContainer
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index db1b8262b7..bbac86fd2d 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!;
 
@@ -265,7 +280,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                                                                             new AddItemButton
                                                                             {
                                                                                 RelativeSizeAxes = Axes.X,
-                                                                                Height = 40,
+                                                                                Height = 30,
                                                                                 Text = "Add item",
                                                                                 Action = () => ShowSongSelect()
                                                                             },
@@ -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/MultiplayerPlayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
index 0e114b752e..a001863780 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
@@ -56,7 +56,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             {
                 AllowPause = false,
                 AllowRestart = false,
-                AllowFailAnimation = false,
                 AllowSkipping = room.AutoSkip,
                 AutomaticallySkipIntro = room.AutoSkip,
                 ShowLeaderboard = true,
@@ -71,6 +70,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             if (!LoadedBeatmapSuccessfully)
                 return;
 
+            // also applied in `MultiSpectatorPlayer.load()`
             ScoreProcessor.ApplyNewJudgementsWhenFailed = true;
 
             LoadComponentAsync(new FillFlowContainer
@@ -168,6 +168,16 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             GameplayClockContainer.Reset();
         }
 
+        protected override void PerformFail()
+        {
+            // base logic intentionally suppressed - failing in multiplayer only marks the score with F rank
+            // see also: `MultiSpectatorPlayer.PerformFail()`
+            ScoreProcessor.FailScore(Score.ScoreInfo);
+        }
+
+        protected override void ConcludeFailedScore(Score score)
+            => throw new NotSupportedException($"{nameof(MultiplayerPlayer)} should never be calling {nameof(ConcludeFailedScore)}. Failing in multiplayer only marks the score with F rank.");
+
         private void failAndBail(string? message = null)
         {
             if (!string.IsNullOrEmpty(message))
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
index b553fcc9cd..7429fc817c 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
         private MultiplayerClient client { get; set; } = null!;
 
         public ParticipantsList()
-            : base(ParticipantPanel.HEIGHT, initialPoolSize: 20)
+            : base(ParticipantPanel.HEIGHT + 1, initialPoolSize: 20)
         {
         }
 
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs
index 8526e11e12..0dd547bfbb 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.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.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -42,6 +43,12 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             if (cancellationToken.IsCancellationRequested)
                 return;
 
+            if (!LoadedBeatmapSuccessfully)
+                return;
+
+            // also applied in `MultiplayerPlayer.load()`
+            ScoreProcessor.ApplyNewJudgementsWhenFailed = true;
+
             HUDOverlay.PlayerSettingsOverlay.Expire();
             HUDOverlay.HoldToQuit.Expire();
         }
@@ -76,5 +83,15 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         }
 
         protected override ResultsScreen CreateResults(ScoreInfo score) => new MultiSpectatorResultsScreen(score);
+
+        protected override void PerformFail()
+        {
+            // base logic intentionally suppressed - failing in multiplayer only marks the score with F rank
+            // see also: `MultiplayerPlayer.PerformFail()`
+            ScoreProcessor.FailScore(Score.ScoreInfo);
+        }
+
+        protected override void ConcludeFailedScore(Score score)
+            => throw new NotSupportedException($"{nameof(MultiSpectatorPlayer)} should never be calling {nameof(ConcludeFailedScore)}. Failing in multiplayer only marks the score with F rank.");
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
index 7ad8bdf454..200e6a715d 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)
@@ -177,17 +178,31 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         {
             base.Update();
 
-            if (!isCandidateAudioSource(currentAudioSource?.SpectatorPlayerClock))
-            {
-                currentAudioSource = instances.Where(i => isCandidateAudioSource(i.SpectatorPlayerClock)).MinBy(i => Math.Abs(i.SpectatorPlayerClock.CurrentTime - syncManager.CurrentMasterTime));
+            checkAudioSource();
+        }
 
-                // Only bind adjustments if there's actually a valid source, else just use the previous ones to ensure no sudden changes to audio.
-                if (currentAudioSource != null)
-                    bindAudioAdjustments(currentAudioSource);
+        private void checkAudioSource()
+        {
+            // always use the maximised player instance as the current audio source if there is one
+            if (grid.MaximisedCell?.Content is PlayerArea maximisedPlayer && maximisedPlayer == currentAudioSource)
+                return;
 
-                foreach (var instance in instances)
-                    instance.Mute = instance != currentAudioSource;
-            }
+            // if there is no maximised player instance and the previous audio source is still good to use, keep using it
+            if (grid.MaximisedCell == null && isCandidateAudioSource(currentAudioSource?.SpectatorPlayerClock))
+                return;
+
+            // at this point we're in one of the following scenarios:
+            // - the maximised player instance is not the current audio source => we want to switch to the maximised player instance
+            // - there is no maximised player instance, and the previous audio source is stopped => find another running audio source
+            currentAudioSource = grid.MaximisedCell?.Content as PlayerArea
+                                 ?? instances.Where(i => isCandidateAudioSource(i.SpectatorPlayerClock)).MinBy(i => Math.Abs(i.SpectatorPlayerClock.CurrentTime - syncManager.CurrentMasterTime));
+
+            // Only bind adjustments if there's actually a valid source, else just use the previous ones to ensure no sudden changes to audio.
+            if (currentAudioSource != null)
+                bindAudioAdjustments(currentAudioSource);
+
+            foreach (var instance in instances)
+                instance.Mute = instance != currentAudioSource;
         }
 
         private void bindAudioAdjustments(PlayerArea first)
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
index 6e71c010e5..c3ad14dba2 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
@@ -31,6 +31,11 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         /// </summary>
         public Facade MaximisedFacade { get; }
 
+        /// <summary>
+        /// The currently-maximised cell.
+        /// </summary>
+        public Cell? MaximisedCell { get; private set; }
+
         private readonly Container paddingContainer;
         private readonly FillFlowContainer<Facade> facadeContainer;
         private readonly Container<Cell> cellContainer;
@@ -99,7 +104,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         private void toggleMaximisationState(Cell target)
         {
             // in the case the target is the already maximised cell (or there is only one cell), no cell should be maximised.
-            bool hasMaximised = !target.IsMaximised && cellContainer.Count > 1;
+            bool hasMaximised = target != MaximisedCell && cellContainer.Count > 1;
+            MaximisedCell = hasMaximised ? target : null;
 
             // Iterate through all cells to ensure only one is maximised at any time.
             foreach (var cell in cellContainer.ToList())
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs
index bc31299615..d1ba214117 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         /// <summary>
         /// A cell of the grid. Contains the content and tracks to the linked facade.
         /// </summary>
-        private partial class Cell : CompositeDrawable
+        public partial class Cell : CompositeDrawable
         {
             /// <summary>
             /// The index of the original facade of this cell.
@@ -33,11 +33,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             /// </summary>
             public Action<Cell>? ToggleMaximisationState;
 
-            /// <summary>
-            /// Whether this cell is currently maximised.
-            /// </summary>
-            public bool IsMaximised { get; private set; }
-
             private Facade facade;
 
             private bool isAnimating;
@@ -83,7 +78,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             public void SetFacade(Facade newFacade, bool isMaximised)
             {
                 facade = newFacade;
-                IsMaximised = isMaximised;
                 isAnimating = true;
 
                 TweenEdgeEffectTo(new EdgeEffectParameters
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..fdda6f6c85 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -13,6 +13,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
@@ -164,225 +165,229 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             InternalChild = new OsuContextMenuContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                Child = new PopoverContainer
                 {
-                    roomUpdater = new PlaylistsRoomUpdater(room),
-                    beatmapAvailabilityTracker,
-                    new MultiplayerRoomSounds(),
-                    new Container
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding
+                        roomUpdater = new PlaylistsRoomUpdater(room),
+                        beatmapAvailabilityTracker,
+                        new MultiplayerRoomSounds(),
+                        new Container
                         {
-                            Horizontal = WaveOverlayContainer.WIDTH_PADDING,
-                            Bottom = footer_height + footer_padding
-                        },
-                        Children = new[]
-                        {
-                            roomContent = new GridContainer
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                RowDimensions = new[]
+                                Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                                Bottom = footer_height + footer_padding
+                            },
+                            Children = new[]
+                            {
+                                roomContent = new GridContainer
                                 {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(GridSizeMode.Absolute, row_padding),
-                                },
-                                Content = new[]
-                                {
-                                    new Drawable[]
+                                    RelativeSizeAxes = Axes.Both,
+                                    RowDimensions = new[]
                                     {
-                                        new PlaylistsRoomPanel(room)
-                                        {
-                                            SelectedItem = SelectedItem
-                                        }
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(GridSizeMode.Absolute, row_padding),
                                     },
-                                    null,
-                                    new Drawable[]
+                                    Content = new[]
                                     {
-                                        new Container
+                                        new Drawable[]
                                         {
-                                            RelativeSizeAxes = Axes.Both,
-                                            Masking = true,
-                                            CornerRadius = 10,
-                                            Children = new Drawable[]
+                                            new PlaylistsRoomPanel(room)
                                             {
-                                                new Box
+                                                SelectedItem = SelectedItem
+                                            }
+                                        },
+                                        null,
+                                        new Drawable[]
+                                        {
+                                            new Container
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                                Masking = true,
+                                                CornerRadius = 10,
+                                                Children = new Drawable[]
                                                 {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
-                                                },
-                                                new GridContainer
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Padding = new MarginPadding(content_padding),
-                                                    ColumnDimensions = new[]
+                                                    new Box
                                                     {
-                                                        new Dimension(),
-                                                        new Dimension(GridSizeMode.Absolute, column_padding),
-                                                        new Dimension(),
-                                                        new Dimension(GridSizeMode.Absolute, column_padding),
-                                                        new Dimension(),
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
                                                     },
-                                                    Content = new[]
+                                                    new GridContainer
                                                     {
-                                                        new Drawable?[]
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Padding = new MarginPadding(content_padding),
+                                                        ColumnDimensions = new[]
                                                         {
-                                                            new GridContainer
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                        },
+                                                        Content = new[]
+                                                        {
+                                                            new Drawable?[]
                                                             {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
+                                                                new GridContainer
                                                                 {
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                },
-                                                                Content = new[]
-                                                                {
-                                                                    new Drawable[]
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
                                                                     {
-                                                                        new OverlinedPlaylistHeader(room),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(),
+                                                                        new Dimension(GridSizeMode.AutoSize),
                                                                     },
-                                                                    new Drawable[]
+                                                                    Content = new[]
                                                                     {
-                                                                        drawablePlaylist = new DrawableRoomPlaylist
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.Both,
-                                                                            SelectedItem = { BindTarget = SelectedItem },
-                                                                            AllowSelection = true,
-                                                                            AllowShowingResults = true,
-                                                                            RequestResults = showResults
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new AddPlaylistToCollectionButton(room)
+                                                                            new OverlinedPlaylistHeader(room),
+                                                                        },
+                                                                        new Drawable[]
                                                                         {
-                                                                            Margin = new MarginPadding { Top = 5 },
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            Size = new Vector2(1, 40)
+                                                                            drawablePlaylist = new DrawableRoomPlaylist
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both,
+                                                                                SelectedItem = { BindTarget = SelectedItem },
+                                                                                AllowSelection = true,
+                                                                                AllowShowingResults = true,
+                                                                                RequestResults = showResults
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new AddPlaylistToCollectionButton(room)
+                                                                            {
+                                                                                Margin = new MarginPadding { Top = 5 },
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                Size = new Vector2(1, 40)
+                                                                            }
                                                                         }
                                                                     }
-                                                                }
-                                                            },
-                                                            null,
-                                                            new GridContainer
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
-                                                                {
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
                                                                 },
-                                                                Content = new[]
+                                                                null,
+                                                                new GridContainer
                                                                 {
-                                                                    new Drawable[]
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
                                                                     {
-                                                                        userModsSection = new FillFlowContainer
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Children = new Drawable[]
+                                                                            userModsSection = new FillFlowContainer
                                                                             {
-                                                                                new OverlinedHeader("Extra mods"),
-                                                                                new FillFlowContainer
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
                                                                                 {
-                                                                                    AutoSizeAxes = Axes.Both,
-                                                                                    Direction = FillDirection.Horizontal,
-                                                                                    Spacing = new Vector2(10, 0),
-                                                                                    Children = new Drawable[]
+                                                                                    new OverlinedHeader("Extra mods"),
+                                                                                    new FillFlowContainer
                                                                                     {
-                                                                                        new UserModSelectButton
+                                                                                        AutoSizeAxes = Axes.Both,
+                                                                                        Direction = FillDirection.Horizontal,
+                                                                                        Spacing = new Vector2(10, 0),
+                                                                                        Children = new Drawable[]
                                                                                         {
-                                                                                            Anchor = Anchor.CentreLeft,
-                                                                                            Origin = Anchor.CentreLeft,
-                                                                                            Width = 90,
-                                                                                            Height = 30,
-                                                                                            Text = "Select",
-                                                                                            Action = showUserModSelect,
-                                                                                        },
-                                                                                        new ModDisplay
-                                                                                        {
-                                                                                            Anchor = Anchor.CentreLeft,
-                                                                                            Origin = Anchor.CentreLeft,
-                                                                                            Current = UserMods,
-                                                                                            Scale = new Vector2(0.8f),
+                                                                                            new UserModSelectButton
+                                                                                            {
+                                                                                                Anchor = Anchor.CentreLeft,
+                                                                                                Origin = Anchor.CentreLeft,
+                                                                                                Width = 90,
+                                                                                                Height = 30,
+                                                                                                Text = "Select",
+                                                                                                Action = showUserModSelect,
+                                                                                            },
+                                                                                            new ModDisplay
+                                                                                            {
+                                                                                                Anchor = Anchor.CentreLeft,
+                                                                                                Origin = Anchor.CentreLeft,
+                                                                                                Current = UserMods,
+                                                                                                Scale = new Vector2(0.8f),
+                                                                                            }
                                                                                         }
                                                                                     }
                                                                                 }
                                                                             }
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        userStyleSection = new FillFlowContainer
+                                                                        },
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Children = new Drawable[]
+                                                                            userStyleSection = new FillFlowContainer
                                                                             {
-                                                                                new OverlinedHeader("Difficulty"),
-                                                                                userStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
                                                                                 {
-                                                                                    RelativeSizeAxes = Axes.X,
-                                                                                    AutoSizeAxes = Axes.Y
+                                                                                    new OverlinedHeader("Difficulty"),
+                                                                                    userStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
+                                                                                    {
+                                                                                        RelativeSizeAxes = Axes.X,
+                                                                                        AutoSizeAxes = Axes.Y
+                                                                                    }
                                                                                 }
                                                                             }
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        progressSection = new FillFlowContainer
-                                                                        {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Direction = FillDirection.Vertical,
-                                                                            Children = new Drawable[]
-                                                                            {
-                                                                                new OverlinedHeader("Progress"),
-                                                                                new RoomLocalUserInfo(room),
-                                                                            }
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new OverlinedHeader("Leaderboard")
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        leaderboard = new MatchLeaderboard(room)
-                                                                        {
-                                                                            RelativeSizeAxes = Axes.Both
                                                                         },
-                                                                    }
-                                                                }
-                                                            },
-                                                            null,
-                                                            new GridContainer
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
-                                                                {
-                                                                    new Dimension(GridSizeMode.AutoSize)
-                                                                },
-                                                                Content = new[]
-                                                                {
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new OverlinedHeader("Chat")
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new MatchChatDisplay(room)
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.Both
+                                                                            progressSection = new FillFlowContainer
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Direction = FillDirection.Vertical,
+                                                                                Children = new Drawable[]
+                                                                                {
+                                                                                    new OverlinedHeader("Progress"),
+                                                                                    new RoomLocalUserInfo(room),
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new OverlinedHeader("Leaderboard")
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            leaderboard = new MatchLeaderboard(room)
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both
+                                                                            },
+                                                                        }
+                                                                    }
+                                                                },
+                                                                null,
+                                                                new GridContainer
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
+                                                                    {
+                                                                        new Dimension(GridSizeMode.AutoSize)
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new OverlinedHeader("Chat")
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new MatchChatDisplay(room)
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both
+                                                                            }
                                                                         }
                                                                     }
                                                                 }
@@ -393,39 +398,39 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                             }
                                         }
                                     }
-                                }
-                            },
-                            settingsOverlay = new PlaylistsRoomSettingsOverlay(room)
-                            {
-                                EditPlaylist = () =>
+                                },
+                                settingsOverlay = new PlaylistsRoomSettingsOverlay(room)
                                 {
-                                    if (this.IsCurrentScreen())
-                                        this.Push(new PlaylistsSongSelect(room));
+                                    EditPlaylist = () =>
+                                    {
+                                        if (this.IsCurrentScreen())
+                                            this.Push(new PlaylistsSongSelect(room));
+                                    }
                                 }
                             }
-                        }
-                    },
-                    new Container
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        RelativeSizeAxes = Axes.X,
-                        Height = footer_height,
-                        Children = new Drawable[]
+                        },
+                        new Container
                         {
-                            new Box
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Height = footer_height,
+                            Children = new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
-                            },
-                            new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding(5),
-                                Child = new PlaylistsRoomFooter(room)
+                                new Box
                                 {
-                                    OnStart = startPlay,
-                                    OnClose = closePlaylist
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding(5),
+                                    Child = new PlaylistsRoomFooter(room)
+                                    {
+                                        OnStart = startPlay,
+                                        OnClose = closePlaylist
+                                    }
                                 }
                             }
                         }
@@ -630,17 +635,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/ArgonCounterTextComponent.cs b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
index bd8f17185b..3789fb1645 100644
--- a/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
@@ -15,6 +15,7 @@ using osu.Framework.Text;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -26,6 +27,8 @@ namespace osu.Game.Screens.Play.HUD
 
         public IBindable<float> WireframeOpacity { get; } = new BindableFloat();
         public Bindable<bool> ShowLabel { get; } = new BindableBool();
+        public Bindable<Color4> LabelColour { get; } = new Bindable<Color4>(Color4.White);
+        public Bindable<Color4> TextColour { get; } = new Bindable<Color4>(Color4.White);
 
         public Container NumberContainer { get; private set; }
 
@@ -58,7 +61,6 @@ namespace osu.Game.Screens.Play.HUD
                 labelText = new OsuSpriteText
                 {
                     Alpha = 0,
-                    BypassAutoSizeAxes = Axes.X,
                     Text = label.GetValueOrDefault(),
                     Font = OsuFont.Torus.With(size: 12, weight: FontWeight.Bold),
                     Margin = new MarginPadding { Left = 2.5f },
@@ -110,7 +112,7 @@ namespace osu.Game.Screens.Play.HUD
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            labelText.Colour = colours.Blue0;
+            LabelColour.Value = colours.Blue0;
         }
 
         protected override void LoadComplete()
@@ -122,6 +124,12 @@ namespace osu.Game.Screens.Play.HUD
                 labelText.Alpha = s.NewValue ? 1 : 0;
                 NumberContainer.Y = s.NewValue ? 12 : 0;
             }, true);
+            LabelColour.BindValueChanged(c => labelText.Colour = c.NewValue, true);
+            TextColour.BindValueChanged(c =>
+            {
+                textPart.Colour = c.NewValue;
+                wireframesPart.Colour = c.NewValue;
+            }, true);
         }
 
         private partial class ArgonCounterSpriteText : OsuSpriteText
diff --git a/osu.Game/Screens/Play/HUD/ArgonUnstableRateCounter.cs b/osu.Game/Screens/Play/HUD/ArgonUnstableRateCounter.cs
new file mode 100644
index 0000000000..d6e6bc2111
--- /dev/null
+++ b/osu.Game/Screens/Play/HUD/ArgonUnstableRateCounter.cs
@@ -0,0 +1,74 @@
+// 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.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Localisation.SkinComponents;
+using osu.Game.Skinning;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public partial class ArgonUnstableRateCounter : UnstableRateCounter, ISerialisableDrawable
+    {
+        private ArgonCounterTextComponent text = null!;
+
+        protected override double RollingDuration => 250;
+
+        private const float alpha_when_invalid = 0.3f;
+
+        [SettingSource("Wireframe opacity", "Controls the opacity of the wireframes behind the digits.")]
+        public BindableFloat WireframeOpacity { get; } = new BindableFloat(0.25f)
+        {
+            Precision = 0.01f,
+            MinValue = 0,
+            MaxValue = 1,
+        };
+
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
+        public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            IsValid.BindValueChanged(v => text.FadeTo(v.NewValue ? 1 : alpha_when_invalid, 1000, Easing.OutQuint), true);
+            FinishTransforms(true);
+        }
+
+        public override int DisplayedCount
+        {
+            get => base.DisplayedCount;
+            set
+            {
+                base.DisplayedCount = value;
+                updateWireframe();
+            }
+        }
+
+        private void updateWireframe()
+        {
+            int digitsRequiredForDisplayCount = Math.Max(3, getDigitsRequiredForDisplayCount());
+
+            if (digitsRequiredForDisplayCount != text.WireframeTemplate.Length)
+                text.WireframeTemplate = new string('#', digitsRequiredForDisplayCount);
+        }
+
+        private int getDigitsRequiredForDisplayCount()
+        {
+            int digitsRequired = 1;
+            long c = DisplayedCount;
+            while ((c /= 10) > 0)
+                digitsRequired++;
+            return digitsRequired;
+        }
+
+        protected override IHasText CreateText() => text = new ArgonCounterTextComponent(Anchor.TopRight, "UR")
+        {
+            WireframeOpacity = { BindTarget = WireframeOpacity },
+            ShowLabel = { BindTarget = ShowLabel },
+        };
+    }
+}
diff --git a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
index f184ad6a03..5ea0e75956 100644
--- a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
@@ -19,22 +19,25 @@ namespace osu.Game.Screens.Play.HUD
 {
     public partial class DefaultRankDisplay : CompositeDrawable, ISerialisableDrawable
     {
+        public bool UsesFixedAnchor { get; set; }
+
         [Resolved]
         private ScoreProcessor scoreProcessor { get; set; } = null!;
 
         [SettingSource(typeof(DefaultRankDisplayStrings), nameof(DefaultRankDisplayStrings.PlaySamplesOnRankChange))]
         public BindableBool PlaySamples { get; set; } = new BindableBool(true);
 
-        public bool UsesFixedAnchor { get; set; }
-
         private UpdateableRank rankDisplay = null!;
 
         private SkinnableSound rankDownSample = null!;
         private SkinnableSound rankUpSample = null!;
 
-        private Bindable<double?> lastSamplePlaybackTime = null!;
+        private Bindable<double?> lastSamplePlayback = null!;
+        private double timeSinceChange;
 
-        private IBindable<ScoreRank> rank = null!;
+        private ScoreRank? displayedRank;
+
+        private const int time_before_commit = 1500;
 
         public DefaultRankDisplay()
         {
@@ -48,7 +51,7 @@ namespace osu.Game.Screens.Play.HUD
             {
                 rankDownSample = new SkinnableSound(new SampleInfo("Gameplay/rank-down")),
                 rankUpSample = new SkinnableSound(new SampleInfo("Gameplay/rank-up")),
-                rankDisplay = new UpdateableRank(ScoreRank.X)
+                rankDisplay = new UpdateableRank
                 {
                     RelativeSizeAxes = Axes.Both
                 },
@@ -57,31 +60,52 @@ namespace osu.Game.Screens.Play.HUD
             if (skinEditor != null)
                 PlaySamples.Value = false;
 
-            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
+            lastSamplePlayback = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            rank = scoreProcessor.Rank.GetBoundCopy();
-            rank.BindValueChanged(r =>
+            updateRank(scoreProcessor.Rank.Value);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var currentRank = scoreProcessor.Rank.Value;
+
+            if (currentRank == displayedRank)
             {
-                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+                timeSinceChange = 0;
+                return;
+            }
 
-                // Don't play rank-down sfx on quit/retry
-                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F && PlaySamples.Value && enoughTimeElapsed)
-                {
-                    if (r.NewValue > rankDisplay.Rank)
-                        rankUpSample.Play();
-                    else
-                        rankDownSample.Play();
+            if ((timeSinceChange += Time.Elapsed) >= time_before_commit || scoreProcessor.HasCompleted.Value || currentRank == ScoreRank.F)
+                updateRank(currentRank);
+        }
 
-                    lastSamplePlaybackTime.Value = Time.Current;
-                }
+        private void updateRank(ScoreRank rank)
+        {
+            rankDisplay.Rank = rank;
 
-                rankDisplay.Rank = r.NewValue;
-            }, true);
+            // Check sample time separately to ensure two copies of the rank display don't both play samples on a change.
+            bool enoughSampleTimeElapsed = !lastSamplePlayback.Value.HasValue || Time.Current - lastSamplePlayback.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+
+            // Also don't play rank-down sfx on quit/retry/initial update.
+            if (displayedRank != null && rank > ScoreRank.F && PlaySamples.Value && enoughSampleTimeElapsed)
+            {
+                if (rank > displayedRank)
+                    rankUpSample.Play();
+                else
+                    rankDownSample.Play();
+
+                lastSamplePlayback.Value = Time.Current;
+            }
+
+            displayedRank = rank;
+            timeSinceChange = 0;
         }
     }
 }
diff --git a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
index dd55e5f926..ddb926ebf1 100644
--- a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
@@ -28,9 +28,13 @@ 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);
 
+        private readonly Bindable<bool> expanded = new BindableBool();
+
         [Resolved]
         private Player? player { get; set; }
 
@@ -42,14 +46,15 @@ namespace osu.Game.Screens.Play.HUD
         private readonly IBindable<LocalUserPlayingState> userPlayingState = new Bindable<LocalUserPlayingState>();
         private readonly IBindable<bool> holdingForHUD = new Bindable<bool>();
 
-        private readonly Bindable<bool> expanded = new Bindable<bool>();
-
         /// <summary>
         /// Create a new leaderboard.
         /// </summary>
         public DrawableGameplayLeaderboard()
         {
-            Width = DrawableGameplayLeaderboardScore.EXTENDED_WIDTH + DrawableGameplayLeaderboardScore.SHEAR_WIDTH;
+            // Extra lenience is applied so the scores don't get cut off from the left due to elastic easing transforms.
+            float xOffset = DrawableGameplayLeaderboardScore.SHEAR_WIDTH + DrawableGameplayLeaderboardScore.ELASTIC_WIDTH_LENIENCE;
+
+            Width = 260 + xOffset;
             Height = 300;
 
             InternalChildren = new Drawable[]
@@ -60,8 +65,9 @@ namespace osu.Game.Screens.Play.HUD
                     RelativeSizeAxes = Axes.Both,
                     Child = Flow = new FillFlowContainer<DrawableGameplayLeaderboardScore>
                     {
+                        Alpha = 0f,
                         RelativeSizeAxes = Axes.X,
-                        X = DrawableGameplayLeaderboardScore.SHEAR_WIDTH,
+                        X = xOffset,
                         AutoSizeAxes = Axes.Y,
                         Direction = FillDirection.Vertical,
                         Spacing = new Vector2(2.5f),
@@ -109,7 +115,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;
         }
 
@@ -149,6 +155,10 @@ namespace osu.Game.Screens.Play.HUD
         {
             base.Update();
 
+            // limit leaderboard dimensions to a sane minimum.
+            Width = Math.Max(Width, Flow.X + DrawableGameplayLeaderboardScore.MIN_WIDTH);
+            Height = Math.Max(Height, DrawableGameplayLeaderboardScore.PANEL_HEIGHT);
+
             requiresScroll = Flow.DrawHeight > Height;
 
             if (requiresScroll && TrackedScore != null)
diff --git a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
index e4f2cc0d68..e4f8d5ebc3 100644
--- a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
@@ -7,8 +7,10 @@ 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;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Layout;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -25,32 +27,31 @@ namespace osu.Game.Screens.Play.HUD
 {
     public partial class DrawableGameplayLeaderboardScore : CompositeDrawable
     {
-        public const float EXTENDED_WIDTH = regular_width + top_player_left_width_extension;
+        public const float MIN_WIDTH = extended_left_panel_width + avatar_size / 2 + 5;
 
-        private const float regular_width = 235f;
+        private const float left_panel_extension_width = 20;
 
-        // a bit hand-wavy, but there's a lot of hard-coded paddings in each of the grid's internals.
-        private const float compact_width = 77.5f;
+        private const float regular_left_panel_width = avatar_size + avatar_size / 2;
+        private const float extended_left_panel_width = regular_left_panel_width + left_panel_extension_width;
 
-        private const float top_player_left_width_extension = 20f;
+        private const float accuracy_combo_width_cutoff = 150;
+        private const float username_score_width_cutoff = 50;
 
-        public const float PANEL_HEIGHT = 35f;
+        private const float avatar_size = PANEL_HEIGHT;
 
-        public const float SHEAR_WIDTH = PANEL_HEIGHT * panel_shear;
+        public const float PANEL_HEIGHT = 38f;
 
-        private const float panel_shear = 0.15f;
+        public static readonly float SHEAR_WIDTH = PANEL_HEIGHT * OsuGame.SHEAR.X;
 
-        private const float rank_text_width = 35f;
-
-        private const float avatar_size = 25f;
+        /// <summary>
+        /// Extra width lenience to account for the out-of-range values produced by elastic easing when the score panel becomes extended (due to earning first score position or is a tracked score).
+        /// </summary>
+        public const float ELASTIC_WIDTH_LENIENCE = 10f;
 
         private const double panel_transition_duration = 500;
-
         private const double text_transition_duration = 200;
 
-        public Bindable<bool> Expanded = new Bindable<bool>();
-
-        private OsuSpriteText positionText = null!, scoreText = null!, accuracyText = null!, comboText = null!, usernameText = null!;
+        public Bindable<bool> Expanded { get; } = new BindableBool();
 
         public BindableLong TotalScore { get; } = new BindableLong();
         public BindableDouble Accuracy { get; } = new BindableDouble(1);
@@ -66,9 +67,7 @@ namespace osu.Game.Screens.Play.HUD
             set => getDisplayScoreFunction = value;
         }
 
-        public Color4? BackgroundColour { get; set; }
-
-        public Color4? TextColour { get; set; }
+        public Color4? BackgroundColour { get; }
 
         public IUser? User { get; }
 
@@ -77,20 +76,33 @@ namespace osu.Game.Screens.Play.HUD
         /// </summary>
         public readonly bool Tracked;
 
-        private Container mainFillContainer = null!;
-
-        private Box centralFill = null!;
-
-        private Container backgroundPaddingAdjustContainer = null!;
-
-        private GridContainer gridContainer = null!;
-
+        private FillFlowContainer scorePanel = null!;
+        private Container leftLayer = null!;
+        private Box leftLayerGradient = null!;
+        private Container rightLayer = null!;
+        private Box rightLayerGradient = null!;
         private Container scoreComponents = null!;
+        private OsuSpriteText usernameText = null!;
+        private OsuSpriteText positionText = null!;
+        private OsuSpriteText accuracyText = null!;
+        private OsuSpriteText scoreText = null!;
+        private OsuSpriteText comboText = null!;
 
         private IBindable<ScoringMode> scoreDisplayMode = null!;
 
         private bool isFriend;
 
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        private readonly LayoutValue drawSizeLayout = new LayoutValue(Invalidation.DrawSize);
+
         /// <summary>
         /// Creates a new <see cref="DrawableGameplayLeaderboardScore"/>.
         /// </summary>
@@ -107,324 +119,334 @@ namespace osu.Game.Screens.Play.HUD
             GetDisplayScore = score.GetDisplayScore;
 
             if (score.TeamColour != null)
-            {
                 BackgroundColour = score.TeamColour.Value;
-                TextColour = Color4.White;
-            }
 
-            AutoSizeAxes = Axes.X;
+            RelativeSizeAxes = Axes.X;
             Height = PANEL_HEIGHT;
+
+            Shear = OsuGame.SHEAR;
+
+            AddLayout(drawSizeLayout);
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, OsuConfigManager osuConfigManager, IAPIProvider api)
+        private void load()
         {
-            Container avatarContainer;
+            const float corner_radius = 10;
 
-            InternalChildren = new Drawable[]
+            Container avatarLayer;
+
+            InternalChild = scorePanel = new FillFlowContainer
             {
-                new Container
+                CornerRadius = corner_radius,
+                BorderThickness = 2f,
+                Masking = true,
+                AutoSizeAxes = Axes.X,
+                RelativeSizeAxes = Axes.Y,
+                Children = new[]
                 {
-                    AutoSizeAxes = Axes.X,
-                    RelativeSizeAxes = Axes.Y,
-                    Margin = new MarginPadding { Left = top_player_left_width_extension },
-                    Children = new Drawable[]
+                    // Apparently this whole dual layer thing is here because the design apparently called
+                    // for a different colour to the left opposed to the right.
+                    //
+                    // I don't know this makes much visual sense. If it ever becomes an issue, rip it out
+                    // and replace with a single gradient instead.
+                    leftLayer = new Container
                     {
-                        backgroundPaddingAdjustContainer = new Container
+                        Width = regular_left_panel_width,
+                        RelativeSizeAxes = Axes.Y,
+                        Children = new Drawable[]
+                        {
+                            leftLayerGradient = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            new Container
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                Width = regular_left_panel_width,
+                                // This may not be mathematically accurate but the position text looks best aligned with it.
+                                Padding = new MarginPadding { Right = avatar_size / 2 - SHEAR_WIDTH / 2 },
+                                RelativeSizeAxes = Axes.Y,
+                                Child = positionText = new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                    Shear = -OsuGame.SHEAR,
+                                }
+                            }
+                        },
+                    },
+                    // this is placed here between the left and right layer for layout purposes,
+                    // but it's proxied below to render in front of them.
+                    avatarLayer = new Container
+                    {
+                        Size = new Vector2(avatar_size),
+                        // precise padding so the avatar's top and bottom sides land as close to the panel borders as possible.
+                        Padding = new MarginPadding(1.3f),
+                        // negative left margin to place the avatar's center directly at the edge of the left layer.
+                        Margin = new MarginPadding { Left = -avatar_size / 2 },
+                        Child = new Container
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Children = new Drawable[]
+                            CornerRadius = corner_radius,
+                            Masking = true,
+                            Child = new ScoreAvatar(User)
                             {
-                                mainFillContainer = new Container
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                                Shear = -OsuGame.SHEAR,
+                                // extra scaling to cover the entire sheared area.
+                                Scale = new Vector2(1.1f),
+                            },
+                        },
+                    },
+                    rightLayer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Y,
+                        // negative left margin to make the X position of the right layer directly at the avatar center (rendered behind it).
+                        Margin = new MarginPadding { Left = -avatar_size / 2 },
+                        Children = new Drawable[]
+                        {
+                            rightLayerGradient = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            scoreComponents = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Left = avatar_size / 2 + 4, Right = 20, Vertical = 5 },
+                                Shear = -OsuGame.SHEAR,
+                                Children = new Drawable[]
                                 {
-                                    Anchor = Anchor.TopRight,
-                                    Origin = Anchor.TopRight,
-                                    RelativeSizeAxes = Axes.Both,
-                                    Masking = true,
-                                    CornerRadius = 5f,
-                                    Shear = new Vector2(panel_shear, 0f),
-                                    Children = new Drawable[]
+                                    new GridContainer
                                     {
-                                        new Box
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                        ColumnDimensions = new[]
                                         {
-                                            Alpha = 0.5f,
-                                            RelativeSizeAxes = Axes.Both,
+                                            new Dimension(),
+                                            new Dimension(GridSizeMode.AutoSize),
+                                        },
+                                        RowDimensions = new[]
+                                        {
+                                            new Dimension(GridSizeMode.AutoSize),
+                                        },
+                                        Content = new[]
+                                        {
+                                            new[]
+                                            {
+                                                usernameText = new TruncatingSpriteText
+                                                {
+                                                    Anchor = Anchor.BottomLeft,
+                                                    Origin = Anchor.BottomLeft,
+                                                    Text = User?.Username ?? string.Empty,
+                                                    Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                                    RelativeSizeAxes = Axes.X,
+                                                },
+                                                accuracyText = new OsuSpriteText
+                                                {
+                                                    Anchor = Anchor.BottomLeft,
+                                                    Origin = Anchor.BottomLeft,
+                                                    Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold),
+                                                },
+                                            }
+                                        },
+                                    },
+                                    new GridContainer
+                                    {
+                                        Anchor = Anchor.BottomLeft,
+                                        Origin = Anchor.BottomLeft,
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                        ColumnDimensions = new[]
+                                        {
+                                            new Dimension(),
+                                            new Dimension(GridSizeMode.AutoSize),
+                                        },
+                                        RowDimensions = new[]
+                                        {
+                                            new Dimension(GridSizeMode.AutoSize),
+                                        },
+                                        Content = new[]
+                                        {
+                                            new[]
+                                            {
+                                                scoreText = new TruncatingSpriteText
+                                                {
+                                                    Anchor = Anchor.BottomLeft,
+                                                    Origin = Anchor.BottomLeft,
+                                                    Font = OsuFont.Style.Body.With(weight: FontWeight.Regular),
+                                                    RelativeSizeAxes = Axes.X,
+                                                },
+                                                comboText = new OsuSpriteText
+                                                {
+                                                    Anchor = Anchor.BottomRight,
+                                                    Origin = Anchor.BottomRight,
+                                                    Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold),
+                                                },
+                                            }
                                         },
                                     },
                                 },
                             }
-                        },
-                        gridContainer = new GridContainer
-                        {
-                            RelativeSizeAxes = Axes.Y,
-                            Width = compact_width, // will be updated by expanded state.
-                            Anchor = Anchor.TopRight,
-                            Origin = Anchor.TopRight,
-                            ColumnDimensions = new[]
-                            {
-                                new Dimension(GridSizeMode.Absolute, rank_text_width),
-                                new Dimension(),
-                                new Dimension(GridSizeMode.AutoSize),
-                            },
-                            Content = new[]
-                            {
-                                new Drawable[]
-                                {
-                                    positionText = new OsuSpriteText
-                                    {
-                                        Padding = new MarginPadding { Right = SHEAR_WIDTH / 2 },
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                        Colour = Color4.White,
-                                        Font = OsuFont.Torus.With(size: 14, weight: FontWeight.Bold),
-                                        Shadow = false,
-                                    },
-                                    new Container
-                                    {
-                                        Padding = new MarginPadding { Horizontal = SHEAR_WIDTH / 3 },
-                                        RelativeSizeAxes = Axes.Both,
-                                        Children = new Drawable[]
-                                        {
-                                            new Container
-                                            {
-                                                Masking = true,
-                                                CornerRadius = 5f,
-                                                Shear = new Vector2(panel_shear, 0f),
-                                                RelativeSizeAxes = Axes.Both,
-                                                Children = new[]
-                                                {
-                                                    centralFill = new Box
-                                                    {
-                                                        Alpha = 0.5f,
-                                                        RelativeSizeAxes = Axes.Both,
-                                                        Colour = Color4Extensions.FromHex("3399cc"),
-                                                    },
-                                                }
-                                            },
-                                            new FillFlowContainer
-                                            {
-                                                Padding = new MarginPadding { Left = SHEAR_WIDTH },
-                                                Anchor = Anchor.CentreLeft,
-                                                Origin = Anchor.CentreLeft,
-                                                RelativeSizeAxes = Axes.Both,
-                                                Direction = FillDirection.Horizontal,
-                                                Spacing = new Vector2(4f, 0f),
-                                                Children = new Drawable[]
-                                                {
-                                                    avatarContainer = new CircularContainer
-                                                    {
-                                                        Masking = true,
-                                                        Anchor = Anchor.CentreLeft,
-                                                        Origin = Anchor.CentreLeft,
-                                                        Size = new Vector2(avatar_size),
-                                                        Children = new Drawable[]
-                                                        {
-                                                            new Box
-                                                            {
-                                                                Name = "Placeholder while avatar loads",
-                                                                Alpha = 0.3f,
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                Colour = colours.Gray4,
-                                                            }
-                                                        }
-                                                    },
-                                                    usernameText = new TruncatingSpriteText
-                                                    {
-                                                        RelativeSizeAxes = Axes.X,
-                                                        Width = 0.6f,
-                                                        Anchor = Anchor.CentreLeft,
-                                                        Origin = Anchor.CentreLeft,
-                                                        Colour = Color4.White,
-                                                        Font = OsuFont.Torus.With(size: 14, weight: FontWeight.SemiBold),
-                                                        Text = User?.Username ?? string.Empty,
-                                                        Shadow = false,
-                                                    }
-                                                }
-                                            },
-                                        }
-                                    },
-                                    scoreComponents = new Container
-                                    {
-                                        Padding = new MarginPadding { Top = 2f, Right = 17.5f, Bottom = 5f },
-                                        AlwaysPresent = true, // required to smoothly animate autosize after hidden early.
-                                        Masking = true,
-                                        RelativeSizeAxes = Axes.Y,
-                                        Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.CentreLeft,
-                                        Colour = Color4.White,
-                                        Children = new Drawable[]
-                                        {
-                                            scoreText = new OsuSpriteText
-                                            {
-                                                Spacing = new Vector2(-1f, 0f),
-                                                Font = OsuFont.Torus.With(size: 16, weight: FontWeight.SemiBold, fixedWidth: true),
-                                                Shadow = false,
-                                            },
-                                            accuracyText = new OsuSpriteText
-                                            {
-                                                Anchor = Anchor.BottomLeft,
-                                                Origin = Anchor.BottomLeft,
-                                                Font = OsuFont.Torus.With(size: 12, weight: FontWeight.SemiBold, fixedWidth: true),
-                                                Spacing = new Vector2(-1f, 0f),
-                                                Shadow = false,
-                                            },
-                                            comboText = new OsuSpriteText
-                                            {
-                                                Anchor = Anchor.BottomRight,
-                                                Origin = Anchor.BottomRight,
-                                                Spacing = new Vector2(-1f, 0f),
-                                                Font = OsuFont.Torus.With(size: 12, weight: FontWeight.SemiBold, fixedWidth: true),
-                                                Shadow = false,
-                                            },
-                                        },
-                                    }
-                                }
-                            }
                         }
-                    }
-                },
+                    },
+                    avatarLayer.CreateProxy(),
+                }
             };
-
-            LoadComponentAsync(new DrawableAvatar(User), avatarContainer.Add);
-
-            scoreDisplayMode = osuConfigManager.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
-            scoreDisplayMode.BindValueChanged(_ => updateScore());
-            TotalScore.BindValueChanged(_ => updateScore(), true);
-
-            Accuracy.BindValueChanged(v =>
-            {
-                accuracyText.Text = v.NewValue.FormatAccuracy();
-                updateDetailsWidth();
-            }, true);
-
-            Combo.BindValueChanged(v =>
-            {
-                comboText.Text = $"{v.NewValue}x";
-                updateDetailsWidth();
-            }, true);
-
-            HasQuit.BindValueChanged(_ => updateState());
-
-            isFriend = User != null && api.Friends.Any(u => User.OnlineID == u.TargetID);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            updateState();
-            Expanded.BindValueChanged(changeExpandedState, true);
-            ScorePosition.BindValueChanged(_ => updateState(), true);
+            isFriend = User != null && api.Friends.Any(u => User.OnlineID == u.TargetID);
+
+            scoreDisplayMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
+            scoreDisplayMode.BindValueChanged(_ => updateScore());
+            TotalScore.BindValueChanged(_ => updateScore(), true);
+
+            Accuracy.BindValueChanged(v => accuracyText.Text = v.NewValue.FormatAccuracy(), true);
+
+            Combo.BindValueChanged(v => comboText.Text = $@"{v.NewValue}x", true);
+
+            Expanded.BindValueChanged(onExpanded, true);
+
+            HasQuit.BindValueChanged(_ => updatePanelState());
+            ScorePosition.BindValueChanged(_ => updatePanelState(), true);
 
             FinishTransforms(true);
         }
 
         private void updateScore() => scoreText.Text = (getDisplayScoreFunction?.Invoke(scoreDisplayMode.Value) ?? TotalScore.Value).ToString("N0");
 
-        private void changeExpandedState(ValueChangedEvent<bool> expanded)
+        private void onExpanded(ValueChangedEvent<bool> expanded)
         {
             if (expanded.NewValue)
             {
-                gridContainer.ResizeWidthTo(regular_width, panel_transition_duration, Easing.OutQuint);
-
+                rightLayer.ResizeWidthTo(computeRightLayerWidth(), panel_transition_duration, Easing.OutQuint);
                 scoreComponents.FadeIn(panel_transition_duration, Easing.OutQuint);
-
-                usernameText.FadeIn(panel_transition_duration, Easing.OutQuint);
             }
             else
             {
-                gridContainer.ResizeWidthTo(compact_width, panel_transition_duration, Easing.OutQuint);
-
+                rightLayer.ResizeWidthTo(avatar_size / 2, panel_transition_duration, Easing.OutQuint);
                 scoreComponents.FadeOut(text_transition_duration, Easing.OutQuint);
-
-                usernameText.FadeOut(text_transition_duration, Easing.OutQuint);
             }
-
-            updateDetailsWidth();
         }
 
-        private float? scoreComponentsTargetWidth;
-
-        private void updateDetailsWidth()
+        private void updatePanelState()
         {
-            const float score_components_min_width = 88f;
+            positionText.Text = ScorePosition.Value.HasValue ? $"#{ScorePosition.Value.Value.FormatRank()}" : "-";
 
-            float newWidth = Expanded.Value
-                ? Math.Max(score_components_min_width, comboText.DrawWidth + accuracyText.DrawWidth + 25)
-                : 0;
-
-            if (scoreComponentsTargetWidth == newWidth)
-                return;
-
-            scoreComponentsTargetWidth = newWidth;
-            scoreComponents.ResizeWidthTo(newWidth, panel_transition_duration, Easing.OutQuint);
-        }
-
-        private void updateState()
-        {
+            Color4 usernameColour = Color4.White;
             bool widthExtension = false;
 
             if (HasQuit.Value)
             {
-                // we will probably want to display this in a better way once we have a design.
-                // and also show states other than quit.
-                panelColour = Color4.Gray;
-                textColour = Color4.White;
-                return;
+                setPanelColour(Color4.Gray);
+                usernameColour = colours.Red2;
             }
-
-            positionText.Text = ScorePosition.Value.HasValue ? $"#{ScorePosition.Value.Value.FormatRank()}" : "-";
-
-            if (ScorePosition.Value == 1)
+            else if (ScorePosition.Value == 1)
             {
                 widthExtension = true;
-                panelColour = BackgroundColour ?? Color4Extensions.FromHex("7fcc33");
-                textColour = TextColour ?? Color4.White;
+                setPanelColour(BackgroundColour ?? colours.Lime2);
             }
             else if (Tracked)
             {
                 widthExtension = true;
-                panelColour = BackgroundColour ?? Color4Extensions.FromHex("ffd966");
-                textColour = TextColour ?? Color4Extensions.FromHex("2e576b");
+                setPanelColourAsTracked();
             }
             else if (isFriend)
             {
-                panelColour = BackgroundColour ?? Color4Extensions.FromHex("ff549a");
-                textColour = TextColour ?? Color4.White;
+                setPanelColour(BackgroundColour ?? colours.Pink1);
+                usernameColour = colours.Pink1;
             }
             else
+                setPanelColour(BackgroundColour ?? colours.Blue4);
+
+            usernameText.FadeColour(usernameColour, text_transition_duration, Easing.OutQuint);
+
+            scorePanel.MoveToX(widthExtension ? 0 : left_panel_extension_width, panel_transition_duration, Easing.OutElastic);
+            leftLayer.ResizeWidthTo(widthExtension ? extended_left_panel_width : regular_left_panel_width, panel_transition_duration, Easing.OutElastic);
+        }
+
+        private void setPanelColour(Color4 baseColour)
+        {
+            leftLayerGradient.Colour = ColourInfo.GradientVertical(baseColour.Opacity(0.2f), baseColour.Opacity(0.5f));
+            rightLayerGradient.Colour = ColourInfo.GradientVertical(baseColour.Opacity(0.1f), baseColour.Opacity(0.3f));
+            scorePanel.BorderColour = ColourInfo.GradientVertical(baseColour.Opacity(0.2f), baseColour);
+        }
+
+        private void setPanelColourAsTracked()
+        {
+            leftLayerGradient.Colour = ColourInfo.GradientVertical(colours.Blue2.Opacity(0.3f), colours.Blue2);
+            rightLayerGradient.Colour = ColourInfo.GradientVertical(colours.Blue4.Opacity(0.25f), colours.Blue3.Opacity(0.6f));
+            scorePanel.BorderColour = ColourInfo.GradientVertical(colours.Blue1.Opacity(0.2f), colours.Blue1);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!drawSizeLayout.IsValid)
             {
-                panelColour = BackgroundColour ?? Color4Extensions.FromHex("3399cc");
-                textColour = TextColour ?? Color4.White;
+                if (Expanded.Value)
+                {
+                    rightLayer.ClearTransforms(targetMember: nameof(Width));
+                    rightLayer.Width = computeRightLayerWidth();
+                }
+
+                drawSizeLayout.Validate();
             }
 
-            this.TransformTo(nameof(SizeContainerLeftPadding), widthExtension ? -top_player_left_width_extension : 0, panel_transition_duration, Easing.OutElastic);
+            bool showAccuracyAndCombo = rightLayer.Width >= accuracy_combo_width_cutoff;
+
+            accuracyText.Alpha = showAccuracyAndCombo ? 1 : 0;
+            comboText.Alpha = showAccuracyAndCombo ? 1 : 0;
+
+            bool showUsernameAndScore = rightLayer.Width >= username_score_width_cutoff;
+
+            usernameText.Alpha = showUsernameAndScore ? 1 : 0;
+            scoreText.Alpha = showUsernameAndScore ? 1 : 0;
         }
 
-        public float SizeContainerLeftPadding
-        {
-            get => backgroundPaddingAdjustContainer.Padding.Left;
-            set => backgroundPaddingAdjustContainer.Padding = new MarginPadding { Left = value };
-        }
+        private float computeRightLayerWidth() => Math.Max(0, DrawWidth - extended_left_panel_width - avatar_size / 2);
 
-        private Color4 panelColour
+        private partial class ScoreAvatar : CompositeDrawable
         {
-            set
+            private readonly IUser? user;
+
+            private Box placeholder = null!;
+
+            public ScoreAvatar(IUser? user)
             {
-                mainFillContainer.FadeColour(value, panel_transition_duration, Easing.OutQuint);
-                centralFill.FadeColour(value, panel_transition_duration, Easing.OutQuint);
+                this.user = user;
+
+                RelativeSizeAxes = Axes.Both;
             }
-        }
 
-        private Color4 textColour
-        {
-            set
+            [BackgroundDependencyLoader]
+            private void load()
             {
-                scoreText.FadeColour(value, text_transition_duration, Easing.OutQuint);
-                accuracyText.FadeColour(value, text_transition_duration, Easing.OutQuint);
-                comboText.FadeColour(value, text_transition_duration, Easing.OutQuint);
-                usernameText.FadeColour(value, text_transition_duration, Easing.OutQuint);
-                positionText.FadeColour(value, text_transition_duration, Easing.OutQuint);
+                InternalChild = placeholder = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = OsuColour.Gray(0.1f),
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                LoadComponentAsync(new DrawableAvatar(user), a =>
+                {
+                    placeholder.FadeOut(300, Easing.InQuint);
+                    AddInternal(a);
+                });
             }
         }
     }
diff --git a/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs b/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
index a856a09388..b8ac6e00c6 100644
--- a/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
+++ b/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
@@ -5,46 +5,29 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Skinning;
-using osuTK;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public partial class UnstableRateCounter : RollingCounter<int>, ISerialisableDrawable
+    public abstract partial class UnstableRateCounter : RollingCounter<int>
     {
         public bool UsesFixedAnchor { get; set; }
 
         protected override double RollingDuration => 375;
 
-        private const float alpha_when_invalid = 0.3f;
-        private readonly Bindable<bool> valid = new Bindable<bool>();
-
         private HitEventExtensions.UnstableRateCalculationResult? unstableRateResult;
 
         [Resolved]
         private ScoreProcessor scoreProcessor { get; set; } = null!;
 
-        public UnstableRateCounter()
+        protected UnstableRateCounter()
         {
             Current.Value = 0;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            Colour = colours.BlueLighter;
-            valid.BindValueChanged(e =>
-                DrawableCount.FadeTo(e.NewValue ? 1 : alpha_when_invalid, 1000, Easing.OutQuint));
-        }
+        public Bindable<bool> IsValid { get; } = new Bindable<bool>();
 
         protected override void LoadComplete()
         {
@@ -67,17 +50,12 @@ namespace osu.Game.Screens.Play.HUD
 
             double? unstableRate = unstableRateResult?.Result;
 
-            valid.Value = unstableRate != null;
+            IsValid.Value = unstableRate != null;
 
             if (unstableRate != null)
                 Current.Value = (int)Math.Round(unstableRate.Value);
         }
 
-        protected override IHasText CreateText() => new TextComponent
-        {
-            Alpha = alpha_when_invalid,
-        };
-
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
@@ -88,44 +66,5 @@ namespace osu.Game.Screens.Play.HUD
                 scoreProcessor.JudgementReverted -= updateDisplay;
             }
         }
-
-        private partial class TextComponent : CompositeDrawable, IHasText
-        {
-            public LocalisableString Text
-            {
-                get => text.Text;
-                set => text.Text = value;
-            }
-
-            private readonly OsuSpriteText text;
-
-            public TextComponent()
-            {
-                AutoSizeAxes = Axes.Both;
-
-                InternalChild = new FillFlowContainer
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Spacing = new Vector2(2),
-                    Children = new Drawable[]
-                    {
-                        text = new OsuSpriteText
-                        {
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
-                            Font = OsuFont.Numeric.With(size: 16, fixedWidth: true)
-                        },
-                        new OsuSpriteText
-                        {
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
-                            Font = OsuFont.Numeric.With(size: 8, fixedWidth: true),
-                            Text = @"UR",
-                            Padding = new MarginPadding { Bottom = 1.5f }, // align baseline better
-                        }
-                    }
-                };
-            }
-        }
     }
 }
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 6ee3ed13a0..22fb8a3463 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -932,13 +932,6 @@ namespace osu.Game.Screens.Play
 
         #region Fail Logic
 
-        /// <summary>
-        /// Invoked when gameplay has permanently failed.
-        /// </summary>
-        protected virtual void OnFail()
-        {
-        }
-
         protected FailOverlay FailOverlay { get; private set; }
 
         private FailAnimationContainer failAnimationContainer;
@@ -952,50 +945,57 @@ namespace osu.Game.Screens.Play
             if (!CheckModsAllowFailure())
                 return false;
 
-            if (Configuration.AllowFailAnimation)
-            {
-                Debug.Assert(!GameplayState.HasFailed);
-                Debug.Assert(!GameplayState.HasPassed);
-                Debug.Assert(!GameplayState.HasQuit);
-
-                GameplayState.HasFailed = true;
-
-                updateGameplayState();
-
-                // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
-                // could process an extra frame after the GameplayClock is stopped.
-                // In such cases we want the fail state to precede a user triggered pause.
-                if (PauseOverlay.State.Value == Visibility.Visible)
-                    PauseOverlay.Hide();
-
-                bool restartOnFail = GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail);
-                if (!restartOnFail)
-                    failAnimationContainer.Start();
-
-                // Failures can be triggered either by a judgement, or by a mod.
-                //
-                // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
-                // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
-                //
-                // A schedule here ensures that any lingering judgements from the current frame are applied before we
-                // finalise the score as "failed".
-                Schedule(() =>
-                {
-                    ScoreProcessor.FailScore(Score.ScoreInfo);
-                    OnFail();
-
-                    if (restartOnFail)
-                        Restart(true);
-                });
-            }
-            else
-            {
-                ScoreProcessor.FailScore(Score.ScoreInfo);
-            }
-
+            PerformFail();
             return true;
         }
 
+        /// <summary>
+        /// Called when the player is determined to have failed.
+        /// </summary>
+        protected virtual void PerformFail()
+        {
+            Debug.Assert(!GameplayState.HasFailed);
+            Debug.Assert(!GameplayState.HasPassed);
+            Debug.Assert(!GameplayState.HasQuit);
+
+            GameplayState.HasFailed = true;
+
+            updateGameplayState();
+
+            // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
+            // could process an extra frame after the GameplayClock is stopped.
+            // In such cases we want the fail state to precede a user triggered pause.
+            if (PauseOverlay.State.Value == Visibility.Visible)
+                PauseOverlay.Hide();
+
+            bool restartOnFail = GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail);
+            if (!restartOnFail)
+                failAnimationContainer.Start();
+
+            // Failures can be triggered either by a judgement, or by a mod.
+            //
+            // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
+            // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
+            //
+            // A schedule here ensures that any lingering judgements from the current frame are applied before we
+            // finalise the score as "failed".
+            Schedule(() =>
+            {
+                ConcludeFailedScore(Score);
+
+                if (restartOnFail)
+                    Restart(true);
+            });
+        }
+
+        /// <summary>
+        /// Performs last operations on the supplied <paramref name="score"/> before this <see cref="Player"/> is definitively exited due to failing.
+        /// </summary>
+        protected virtual void ConcludeFailedScore(Score score)
+        {
+            ScoreProcessor.FailScore(score.ScoreInfo);
+        }
+
         /// <summary>
         /// Invoked when the fail animation has finished.
         /// </summary>
@@ -1046,7 +1046,7 @@ namespace osu.Game.Screens.Play
             // already resuming
             && !IsResuming;
 
-        public bool Pause()
+        public virtual bool Pause()
         {
             if (!pausingSupportedByCurrentState) return false;
 
diff --git a/osu.Game/Screens/Play/PlayerConfiguration.cs b/osu.Game/Screens/Play/PlayerConfiguration.cs
index cfe8a67684..f529859bfb 100644
--- a/osu.Game/Screens/Play/PlayerConfiguration.cs
+++ b/osu.Game/Screens/Play/PlayerConfiguration.cs
@@ -15,12 +15,6 @@ namespace osu.Game.Screens.Play
         /// </summary>
         public bool ShowResults { get; set; } = true;
 
-        /// <summary>
-        /// Whether the fail animation / screen should be triggered on failing.
-        /// If false, the score will still be marked as failed but gameplay will continue.
-        /// </summary>
-        public bool AllowFailAnimation { get; set; } = true;
-
         /// <summary>
         /// Whether the player should be allowed to trigger a restart.
         /// </summary>
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index 848b8292d4..57159afd22 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -277,11 +277,22 @@ namespace osu.Game.Screens.Play
             showStoryboards.BindValueChanged(val => epilepsyWarning?.FadeTo(val.NewValue ? 1 : 0, 250, Easing.OutQuint), true);
             epilepsyWarning?.FinishTransforms(true);
 
+            // this re-fetch has two purposes:
+            // - is a safety against potential unexpected screen transitions, making sure that the leaderboard
+            //   displayed during gameplay definitely matches the beatmap and ruleset being played
+            //   (as the solo gameplay leaderboard provider uses the global leaderboard manager to populate itself)
+            // - the sort mode is not specified and defaults to `Score` which is good because gameplay leaderboards only support sorting by score.
+            //   this may change at some point in the future, at which point specifying a sort mode should be considered.
+            refetchLeaderboard(force: false);
+        }
+
+        private void refetchLeaderboard(bool force)
+        {
             leaderboardManager?.FetchWithCriteria(new LeaderboardCriteria(
                 Beatmap.Value.BeatmapInfo,
                 Ruleset.Value,
                 leaderboardManager?.CurrentCriteria?.Scope ?? BeatmapLeaderboardScope.Global,
-                leaderboardManager?.CurrentCriteria?.ExactMods));
+                leaderboardManager?.CurrentCriteria?.ExactMods), force);
         }
 
         #region Screen handling
@@ -491,6 +502,11 @@ namespace osu.Game.Screens.Play
             QuickRestart = quickRestartRequested;
             hideOverlays = true;
             ValidForResume = true;
+            // when retrying, it is desired to refetch the global state leaderboard so that the user's previous score can show up on the leaderboard, if it needs to.
+            // that said, only do this when the user is *not* quick-retrying.
+            // this avoids the quick retry becoming longer than it needs to (because an extra API request has to complete before gameplay can start),
+            // and if the user is quick-retrying, their last score is most likely not important for global leaderboards, or the user won't care.
+            refetchLeaderboard(force: !quickRestartRequested);
         }
 
         private void contentIn(double delayBeforeSideDisplays = 0)
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index 5efef16d08..e2337a4e0e 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -17,6 +17,7 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -39,6 +40,8 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
         private Bindable<ScoreInfo?> lastAppliedScore { get; } = new Bindable<ScoreInfo?>();
 
+        private readonly Bindable<bool> autoAdjustBeatmapOffset = new Bindable<bool>();
+
         public BindableDouble Current { get; } = new BindableDouble
         {
             MinValue = -50,
@@ -60,17 +63,23 @@ namespace osu.Game.Screens.Play.PlayerSettings
         [Resolved]
         private Player? player { get; set; }
 
+        [Resolved]
+        private SettingsOverlay? settings { get; set; }
+
+        // the last play graph is relative to the offset at the point of the last play, so we need to factor that out for some usages.
+        private double adjustmentSinceLastPlay => lastPlayBeatmapOffset - Current.Value;
+
         private double lastPlayMedian;
+        private double lastPlayUnstableRate;
         private double lastPlayBeatmapOffset;
         private HitEventTimingDistributionGraph? lastPlayGraph;
-
         private SettingsButton? calibrateFromLastPlayButton;
-
         private IDisposable? beatmapOffsetSubscription;
-
         private Task? realmWriteTask;
         private ScoreInfo? lastValidScore;
 
+        private bool allowOffsetAdjust => player?.AllowCriticalSettingsAdjustment != false;
+
         public BeatmapOffsetControl()
         {
             RelativeSizeAxes = Axes.X;
@@ -102,9 +111,10 @@ namespace osu.Game.Screens.Play.PlayerSettings
         }
 
         [BackgroundDependencyLoader]
-        private void load(SessionStatics statics)
+        private void load(SessionStatics statics, OsuConfigManager config)
         {
             statics.BindWith(Static.LastAppliedOffsetScore, lastAppliedScore);
+            config.BindWith(OsuSetting.AutomaticallyAdjustBeatmapOffset, autoAdjustBeatmapOffset);
         }
 
         protected override void LoadComplete()
@@ -136,44 +146,94 @@ namespace osu.Game.Screens.Play.PlayerSettings
             ReferenceScore.BindValueChanged(scoreChanged, true);
         }
 
-        // the last play graph is relative to the offset at the point of the last play, so we need to factor that out for some usages.
-        private double adjustmentSinceLastPlay => lastPlayBeatmapOffset - Current.Value;
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            // To match stable, this should adjust by 5 ms, or 1 ms when holding alt.
+            // But that is hard to make work with global actions due to the operating mode.
+            // Let's use the more precise as a default for now.
+            const double amount = 1;
+
+            switch (e.Action)
+            {
+                case GlobalAction.IncreaseOffset:
+                    if (!Current.Disabled)
+                        Current.Value += amount;
+                    return true;
+
+                case GlobalAction.DecreaseOffset:
+                    if (!Current.Disabled)
+                        Current.Value -= amount;
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        {
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            bool allow = allowOffsetAdjust;
+
+            if (calibrateFromLastPlayButton != null)
+            {
+                double suggestedOffset = computeSuggestedOffset(lastPlayMedian, lastPlayUnstableRate, lastPlayBeatmapOffset);
+                calibrateFromLastPlayButton.Enabled.Value = allow && !Precision.AlmostEquals(suggestedOffset, Current.Value, Current.Precision / 2);
+            }
+
+            Current.Disabled = !allow;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            beatmapOffsetSubscription?.Dispose();
+        }
 
         private void currentChanged(ValueChangedEvent<double> offset)
         {
-            Scheduler.AddOnce(updateOffset);
+            // Negative is applied here because the play graph is considering a hit offset, not track (as we currently use for clocks).
+            lastPlayGraph?.UpdateOffset(-adjustmentSinceLastPlay);
 
-            void updateOffset()
+            // Calibration button may be hidden due to automatic offset adjustment, but it should be visible when the user manually adjusts their offset away from the applied suggestion.
+            calibrateFromLastPlayButton?.Show();
+
+            // This is intentionally not scheduled as the offset may be changed while the control is hidden and cannot process its scheduler.
+            // This is the case when auto-adjustment is enabled and the offset is adjusted while the player is quick-retrying.
+            writeOffsetToBeatmap();
+        }
+
+        private void writeOffsetToBeatmap()
+        {
+            // ensure the previous write has completed. ignoring performance concerns, if we don't do this, the async writes could be out of sequence.
+            if (realmWriteTask?.IsCompleted == false)
             {
-                // Negative is applied here because the play graph is considering a hit offset, not track (as we currently use for clocks).
-                lastPlayGraph?.UpdateOffset(-adjustmentSinceLastPlay);
-
-                // ensure the previous write has completed. ignoring performance concerns, if we don't do this, the async writes could be out of sequence.
-                if (realmWriteTask?.IsCompleted == false)
-                {
-                    Scheduler.AddOnce(updateOffset);
-                    return;
-                }
-
-                realmWriteTask = realm.WriteAsync(r =>
-                {
-                    var setInfo = r.Find<BeatmapSetInfo>(beatmap.Value.BeatmapSetInfo.ID);
-
-                    if (setInfo == null) // only the case for tests.
-                        return;
-
-                    // Apply to all difficulties in a beatmap set if they have the same audio
-                    // (they generally always share timing).
-                    foreach (var b in setInfo.Beatmaps)
-                    {
-                        BeatmapUserSettings userSettings = b.UserSettings;
-                        double val = Current.Value;
-
-                        if (userSettings.Offset != val && b.AudioEquals(beatmap.Value.BeatmapInfo))
-                            userSettings.Offset = val;
-                    }
-                });
+                Scheduler.AddOnce(writeOffsetToBeatmap);
+                return;
             }
+
+            realmWriteTask = realm.WriteAsync(r =>
+            {
+                var setInfo = r.Find<BeatmapSetInfo>(beatmap.Value.BeatmapSetInfo.ID);
+
+                if (setInfo == null) // only the case for tests.
+                    return;
+
+                // Apply to all difficulties in a beatmap set if they have the same audio
+                // (they generally always share timing).
+                foreach (var b in setInfo.Beatmaps)
+                {
+                    BeatmapUserSettings userSettings = b.UserSettings;
+                    double val = Current.Value;
+
+                    if (userSettings.Offset != val && b.AudioEquals(beatmap.Value.BeatmapInfo))
+                        userSettings.Offset = val;
+                }
+            });
         }
 
         private void scoreChanged(ValueChangedEvent<ScoreInfo?> score)
@@ -192,11 +252,14 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
             var hitEvents = score.NewValue.HitEvents;
 
-            if (!(hitEvents.CalculateMedianHitError() is double median))
+            if (hitEvents.CalculateMedianHitError() is not double median)
+                return;
+
+            if (hitEvents.CalculateUnstableRate()?.Result is not double unstableRate)
                 return;
 
             // affecting unstable rate here is used as a substitute of determining if a hit event represents a *timed* hit event,
-            // i.e. an user input that the user had to *time to the track*,
+            // i.e. a user input that the user had to *time to the track*,
             // i.e. one that it *makes sense to use* when doing anything with timing and offsets.
             bool hasEnoughUsableEvents = hitEvents.Count(HitEventExtensions.AffectsUnstableRate) >= 50;
 
@@ -230,9 +293,10 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
             lastValidScore = score.NewValue!;
             lastPlayMedian = median;
+            lastPlayUnstableRate = unstableRate;
             lastPlayBeatmapOffset = Current.Value;
 
-            LinkFlowContainer globalOffsetText;
+            LinkFlowContainer offsetText;
 
             referenceScoreContainer.AddRange(new Drawable[]
             {
@@ -241,89 +305,58 @@ namespace osu.Game.Screens.Play.PlayerSettings
                     RelativeSizeAxes = Axes.X,
                     Height = 50,
                 },
-                new AverageHitError(hitEvents),
+                new AverageHitError(hitEvents) { FontSize = OsuFont.Style.Caption1.Size },
                 calibrateFromLastPlayButton = new SettingsButton
                 {
                     Text = BeatmapOffsetControlStrings.CalibrateUsingLastPlay,
                     Action = () =>
                     {
-                        if (Current.Disabled)
-                            return;
-
-                        Current.Value = lastPlayBeatmapOffset - lastPlayMedian;
-                        lastAppliedScore.Value = lastValidScore;
+                        if (!Current.Disabled)
+                            applySuggestedOffset();
                     },
                 },
-                globalOffsetText = new LinkFlowContainer
+                offsetText = new LinkFlowContainer
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
                 }
             });
 
-            if (settings != null)
+            if (autoAdjustBeatmapOffset.Value && !Current.Disabled)
             {
-                globalOffsetText.AddText("You can also ");
-                globalOffsetText.AddLink("adjust the global offset", () => settings.ShowAtControl<AudioOffsetAdjustControl>());
-                globalOffsetText.AddText(" based off this play.");
-            }
-        }
+                bool offsetChanged = applySuggestedOffset();
 
-        [Resolved]
-        private SettingsOverlay? settings { get; set; }
+                calibrateFromLastPlayButton.Hide();
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            beatmapOffsetSubscription?.Dispose();
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            bool allow = allowOffsetAdjust;
-
-            if (calibrateFromLastPlayButton != null)
-                calibrateFromLastPlayButton.Enabled.Value = allow && !Precision.AlmostEquals(lastPlayMedian, adjustmentSinceLastPlay, Current.Precision / 2);
-
-            Current.Disabled = !allow;
-        }
-
-        private bool allowOffsetAdjust => player?.AllowCriticalSettingsAdjustment != false;
-
-        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-        {
-            // To match stable, this should adjust by 5 ms, or 1 ms when holding alt.
-            // But that is hard to make work with global actions due to the operating mode.
-            // Let's use the more precise as a default for now.
-            const double amount = 1;
-
-            switch (e.Action)
-            {
-                case GlobalAction.IncreaseOffset:
-                    if (!Current.Disabled)
-                        Current.Value += amount;
-                    return true;
-
-                case GlobalAction.DecreaseOffset:
-                    if (!Current.Disabled)
-                        Current.Value -= amount;
-                    return true;
+                if (offsetChanged)
+                {
+                    offsetText.AddText($"Beatmap offset was adjusted to {Current.Value.ToStandardFormattedString(1)} ms.", t => t.Font = OsuFont.Style.Caption1);
+                    offsetText.NewParagraph();
+                }
             }
 
-            return false;
+            offsetText.AddText("You can also ", t => t.Font = OsuFont.Style.Caption2);
+            offsetText.AddLink("adjust the global offset", () => settings?.ShowAtControl<AudioOffsetAdjustControl>(), creationParameters: t => t.Font = OsuFont.Style.Caption2);
+            offsetText.AddText(" based off this play.", t => t.Font = OsuFont.Style.Caption2);
         }
 
-        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        private bool applySuggestedOffset()
         {
+            double lastOffset = Current.Value;
+
+            Current.Value = computeSuggestedOffset(lastPlayMedian, lastPlayUnstableRate, lastPlayBeatmapOffset);
+            lastAppliedScore.Value = lastValidScore;
+
+            return !Precision.AlmostEquals(Current.Value, lastOffset, Current.Precision / 2);
         }
 
         public static LocalisableString GetOffsetExplanatoryText(double offset)
         {
-            return offset == 0
-                ? LocalisableString.Interpolate($@"{offset:0.0} ms")
-                : LocalisableString.Interpolate($@"{offset:0.0} ms {getEarlyLateText(offset)}");
+            string formatOffset = offset.ToStandardFormattedString(1);
+
+            return formatOffset == "0"
+                ? LocalisableString.Interpolate($@"{formatOffset} ms")
+                : LocalisableString.Interpolate($@"{formatOffset} ms {getEarlyLateText(offset)}");
 
             LocalisableString getEarlyLateText(double value)
             {
@@ -335,6 +368,23 @@ namespace osu.Game.Screens.Play.PlayerSettings
             }
         }
 
+        private static double computeSuggestedOffset(double median, double unstableRate, double currentOffset)
+        {
+            const double ur_adjustment_cutoff = 90;
+            const double exponential_factor = -0.0116;
+
+            double offsetAdjustment = median;
+
+            if (unstableRate >= ur_adjustment_cutoff)
+            {
+                // A demonstrative graph of this algorithm is embedded in https://github.com/ppy/osu/discussions/30521.
+                // This ultimately prevents scores with high unstable rate from suggesting potentially invalid offsets.
+                offsetAdjustment *= Math.Exp(exponential_factor * (unstableRate - ur_adjustment_cutoff));
+            }
+
+            return currentOffset - offsetAdjustment;
+        }
+
         private partial class OffsetSliderBar : PlayerSliderBar<double>
         {
             protected override Drawable CreateControl() => new CustomSliderBar();
diff --git a/osu.Game/Screens/Play/ReplayFailIndicator.cs b/osu.Game/Screens/Play/ReplayFailIndicator.cs
new file mode 100644
index 0000000000..769a84dce4
--- /dev/null
+++ b/osu.Game/Screens/Play/ReplayFailIndicator.cs
@@ -0,0 +1,174 @@
+// 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 ManagedBass.Fx;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Platform;
+using osu.Game.Audio;
+using osu.Game.Audio.Effects;
+using osu.Game.Beatmaps;
+using osu.Game.Extensions;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Skinning;
+using osuTK;
+using osu.Game.Localisation;
+
+namespace osu.Game.Screens.Play
+{
+    public partial class ReplayFailIndicator : CompositeDrawable
+    {
+        public Action? GoToResults { get; init; }
+
+        private readonly GameplayClockContainer gameplayClockContainer;
+        private readonly BindableDouble trackFreq = new BindableDouble(1);
+        private readonly BindableDouble volumeAdjustment = new BindableDouble(1);
+
+        private Track track = null!;
+        private SkinnableSound failSample = null!;
+        private AudioFilter failLowPassFilter = null!;
+        private AudioFilter failHighPassFilter = null!;
+        private Container content = null!;
+
+        private double? failTime;
+
+        // relied on to make arbitrary seeks / rewinding work pretty well out-of-the-box, leveraging custom clock and absolute transform sequences
+        public override bool RemoveCompletedTransforms => false;
+
+        public ReplayFailIndicator(GameplayClockContainer gameplayClockContainer)
+        {
+            Clock = this.gameplayClockContainer = gameplayClockContainer;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, AudioManager audio, IBindable<WorkingBeatmap> beatmap, GameHost host)
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            AutoSizeAxes = Axes.Both;
+
+            track = beatmap.Value.Track;
+
+            RoundedButton goToResultsButton;
+
+            InternalChildren = new Drawable[]
+            {
+                failSample = new SkinnableSound(new SampleInfo(@"Gameplay/failsound")),
+                failLowPassFilter = new AudioFilter(audio.TrackMixer),
+                failHighPassFilter = new AudioFilter(audio.TrackMixer, BQFType.HighPass),
+                content = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    Masking = true,
+                    CornerRadius = 20,
+                    Alpha = 0,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colours.Gray3,
+                            Alpha = 0.8f,
+                        },
+                        new FillFlowContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Direction = FillDirection.Vertical,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Padding = new MarginPadding(20),
+                            Spacing = new Vector2(15),
+                            Children = new Drawable[]
+                            {
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Font = OsuFont.Style.Title,
+                                    Text = ReplayFailIndicatorStrings.ReplayFailed,
+                                },
+                                goToResultsButton = new RoundedButton
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Width = 150,
+                                    Text = ReplayFailIndicatorStrings.GoToResults,
+                                    Action = GoToResults,
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            // every single component here is fine being synced to the gameplay clock...
+            // except the "go to results" button, which starts having hover animations synced to the audio track
+            // which is something that we don't want.
+            // it is maybe probably possible to restructure the drawable hierarchy here to remove the button from under the gameplay clock,
+            // but it would resort in uglier and more complicated drawable code.
+            // thus, resort to the escape hatch extension method to ensure the button specifically still runs on the game update clock.
+            goToResultsButton.ApplyGameWideClock(host);
+
+            track.AddAdjustment(AdjustableProperty.Volume, volumeAdjustment);
+            track.AddAdjustment(AdjustableProperty.Frequency, trackFreq);
+        }
+
+        public void Display()
+        {
+            failTime = Clock.CurrentTime;
+
+            using (BeginAbsoluteSequence(failTime.Value))
+            {
+                // intentionally shorter than the actual fail animation
+                const double audio_sweep_duration = 1000;
+
+                content.FadeInFromZero(200, Easing.OutQuint);
+                this.ScaleTo(1.1f, audio_sweep_duration, Easing.OutElasticHalf);
+                this.TransformBindableTo(trackFreq, 0, audio_sweep_duration);
+                this.TransformBindableTo(volumeAdjustment, 0.5);
+                failHighPassFilter.CutoffTo(300);
+                failLowPassFilter.CutoffTo(300, audio_sweep_duration, Easing.OutCubic);
+            }
+        }
+
+        private bool failSamplePlaybackInitiated;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // the playback of the fail sample is the one thing that cannot be easily written using rewindable transforms and such.
+            // this part needs to be hardcoded in update to work.
+            if (gameplayClockContainer.GetTrueGameplayRate() > 0 && Time.Current >= failTime && !failSamplePlaybackInitiated)
+            {
+                failSamplePlaybackInitiated = true;
+                failSample.Play();
+            }
+
+            if (Time.Current < failTime && failSamplePlaybackInitiated)
+            {
+                failSamplePlaybackInitiated = false;
+                failSample.Stop();
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            failSample.Stop();
+            failSample.Dispose();
+            track.RemoveAdjustment(AdjustableProperty.Frequency, trackFreq);
+            track.RemoveAdjustment(AdjustableProperty.Volume, volumeAdjustment);
+            base.Dispose(isDisposing);
+        }
+    }
+}
diff --git a/osu.Game/Screens/Play/ReplayPlayer.cs b/osu.Game/Screens/Play/ReplayPlayer.cs
index c058238a0a..1c583609d9 100644
--- a/osu.Game/Screens/Play/ReplayPlayer.cs
+++ b/osu.Game/Screens/Play/ReplayPlayer.cs
@@ -1,15 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
@@ -29,17 +29,20 @@ namespace osu.Game.Screens.Play
 
         private readonly Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore;
 
-        private PlaybackSettings playbackSettings;
-
         [Cached(typeof(IGameplayLeaderboardProvider))]
         private readonly SoloGameplayLeaderboardProvider leaderboardProvider = new SoloGameplayLeaderboardProvider();
 
-        protected override UserActivity InitialActivity => new UserActivity.WatchingReplay(Score.ScoreInfo);
+        protected override UserActivity? InitialActivity =>
+            // score may be null if LoadedBeatmapSuccessfully is false.
+            Score == null ? null : new UserActivity.WatchingReplay(Score.ScoreInfo);
 
         private bool isAutoplayPlayback => GameplayState.Mods.OfType<ModAutoplay>().Any();
 
         private double? lastFrameTime;
 
+        private ReplayFailIndicator? failIndicator;
+        private PlaybackSettings? playbackSettings;
+
         protected override bool CheckModsAllowFailure()
         {
             // autoplay should be able to fail if the beatmap is not humanly beatable
@@ -57,12 +60,12 @@ namespace osu.Game.Screens.Play
             return false;
         }
 
-        public ReplayPlayer(Score score, PlayerConfiguration configuration = null)
+        public ReplayPlayer(Score score, PlayerConfiguration? configuration = null)
             : this((_, _) => score, configuration)
         {
         }
 
-        public ReplayPlayer(Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore, PlayerConfiguration configuration = null)
+        public ReplayPlayer(Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore, PlayerConfiguration? configuration = null)
             : base(configuration)
         {
             this.createScore = createScore;
@@ -97,6 +100,17 @@ namespace osu.Game.Screens.Play
                 playbackSettings.UserPlaybackRate.BindTo(master.UserPlaybackRate);
 
             HUDOverlay.PlayerSettingsOverlay.AddAtStart(playbackSettings);
+            AddInternal(failIndicator = new ReplayFailIndicator(GameplayClockContainer)
+            {
+                GoToResults = () =>
+                {
+                    if (!this.IsCurrentScreen())
+                        return;
+
+                    ValidForResume = false;
+                    this.Push(new SoloResultsScreen(Score.ScoreInfo));
+                }
+            });
         }
 
         protected override void PrepareReplay()
@@ -119,6 +133,9 @@ namespace osu.Game.Screens.Play
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
+            if (!LoadedBeatmapSuccessfully)
+                return false;
+
             switch (e.Action)
             {
                 case GlobalAction.StepReplayBackward:
@@ -130,11 +147,11 @@ namespace osu.Game.Screens.Play
                     return true;
 
                 case GlobalAction.SeekReplayBackward:
-                    SeekInDirection(-5 * (float)playbackSettings.UserPlaybackRate.Value);
+                    SeekInDirection(-5 * (float)playbackSettings!.UserPlaybackRate.Value);
                     return true;
 
                 case GlobalAction.SeekReplayForward:
-                    SeekInDirection(5 * (float)playbackSettings.UserPlaybackRate.Value);
+                    SeekInDirection(5 * (float)playbackSettings!.UserPlaybackRate.Value);
                     return true;
 
                 case GlobalAction.TogglePauseReplay:
@@ -173,5 +190,37 @@ namespace osu.Game.Screens.Play
         public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
         }
+
+        protected override void PerformFail()
+        {
+            // base logic intentionally suppressed - we have our own custom fail interaction
+            ScoreProcessor.FailScore(Score.ScoreInfo);
+            failIndicator!.Display();
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            stopAllAudioEffects();
+            base.OnSuspending(e);
+        }
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            // safety against filters or samples from the indicator playing long after the screen is exited
+            failIndicator?.RemoveAndDisposeImmediately();
+            return base.OnExiting(e);
+        }
+
+        private void stopAllAudioEffects()
+        {
+            // safety against filters or samples from the indicator playing long after the screen is exited
+            failIndicator?.RemoveAndDisposeImmediately();
+
+            if (GameplayClockContainer is MasterGameplayClockContainer master)
+            {
+                playbackSettings?.UserPlaybackRate.UnbindFrom(master.UserPlaybackRate);
+                master.UserPlaybackRate.SetDefault();
+            }
+        }
     }
 }
diff --git a/osu.Game/Screens/Play/SoloSpectatorPlayer.cs b/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
index be83a4c6b5..87d77db847 100644
--- a/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
+++ b/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
@@ -45,6 +45,26 @@ namespace osu.Game.Screens.Play
             });
         }
 
+        #region Fail handling
+
+        protected override bool CheckModsAllowFailure()
+        {
+            if (!allowFail)
+                return false;
+
+            return base.CheckModsAllowFailure();
+        }
+
+        private bool allowFail;
+
+        /// <summary>
+        /// Should be called when it is apparent that the player being spectated has failed.
+        /// This will subsequently stop blocking the fail screen from displaying (usually done out of safety).
+        /// </summary>
+        public void AllowFail() => allowFail = true;
+
+        #endregion
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
diff --git a/osu.Game/Screens/Play/SoloSpectatorScreen.cs b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
index 269bc3bb92..75f8da707c 100644
--- a/osu.Game/Screens/Play/SoloSpectatorScreen.cs
+++ b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
@@ -183,7 +183,7 @@ namespace osu.Game.Screens.Play
         {
             if (this.GetChildScreen() is SpectatorPlayerLoader loader)
             {
-                if (loader.GetChildScreen() is SpectatorPlayer player)
+                if (loader.GetChildScreen() is SoloSpectatorPlayer player)
                 {
                     player.AllowFail();
                     resetStartState();
diff --git a/osu.Game/Screens/Play/SpectatorPlayer.cs b/osu.Game/Screens/Play/SpectatorPlayer.cs
index 6bfb6e033a..4bd9bfafc0 100644
--- a/osu.Game/Screens/Play/SpectatorPlayer.cs
+++ b/osu.Game/Screens/Play/SpectatorPlayer.cs
@@ -29,16 +29,6 @@ namespace osu.Game.Screens.Play
 
         private readonly Score score;
 
-        protected override bool CheckModsAllowFailure()
-        {
-            if (!allowFail)
-                return false;
-
-            return base.CheckModsAllowFailure();
-        }
-
-        private bool allowFail;
-
         protected SpectatorPlayer(Score score, PlayerConfiguration? configuration = null)
             : base(configuration)
         {
@@ -72,12 +62,6 @@ namespace osu.Game.Screens.Play
             }, true);
         }
 
-        /// <summary>
-        /// Should be called when it is apparent that the player being spectated has failed.
-        /// This will subsequently stop blocking the fail screen from displaying (usually done out of safety).
-        /// </summary>
-        public void AllowFail() => allowFail = true;
-
         protected override void StartGameplay()
         {
             base.StartGameplay();
diff --git a/osu.Game/Screens/Play/SubmittingPlayer.cs b/osu.Game/Screens/Play/SubmittingPlayer.cs
index 7becb2b33e..06f1a9c530 100644
--- a/osu.Game/Screens/Play/SubmittingPlayer.cs
+++ b/osu.Game/Screens/Play/SubmittingPlayer.cs
@@ -234,27 +234,38 @@ namespace osu.Game.Screens.Play
             spectatorClient.BeginPlaying(token, GameplayState, Score);
         }
 
-        protected override void OnFail()
+        public override bool Pause()
         {
-            base.OnFail();
+            bool wasPaused = GameplayClockContainer.IsPaused.Value;
 
-            submitFromFailOrQuit();
+            bool paused = base.Pause();
+
+            if (!wasPaused && paused)
+                Score.ScoreInfo.Pauses.Add((int)Math.Round(GameplayClockContainer.CurrentTime));
+
+            return paused;
+        }
+
+        protected override void ConcludeFailedScore(Score score)
+        {
+            base.ConcludeFailedScore(score);
+            submitFromFailOrQuit(score);
         }
 
         public override bool OnExiting(ScreenExitEvent e)
         {
             bool exiting = base.OnExiting(e);
-            submitFromFailOrQuit();
+            submitFromFailOrQuit(Score);
             statics.SetValue(Static.LastLocalUserScore, Score?.ScoreInfo.DeepClone());
             return exiting;
         }
 
-        private void submitFromFailOrQuit()
+        private void submitFromFailOrQuit(Score score)
         {
             if (LoadedBeatmapSuccessfully)
             {
                 // compare: https://github.com/ppy/osu/blob/ccf1acce56798497edfaf92d3ece933469edcf0a/osu.Game/Screens/Play/Player.cs#L848-L851
-                var scoreCopy = Score.DeepClone();
+                var scoreCopy = score.DeepClone();
 
                 Task.Run(async () =>
                 {
diff --git a/osu.Game/Screens/Ranking/CollectionPopover.cs b/osu.Game/Screens/Ranking/CollectionPopover.cs
index ffc448d7a9..8ecee85c3f 100644
--- a/osu.Game/Screens/Ranking/CollectionPopover.cs
+++ b/osu.Game/Screens/Ranking/CollectionPopover.cs
@@ -10,6 +10,7 @@ using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Ranking
 {
@@ -59,7 +60,7 @@ namespace osu.Game.Screens.Ranking
                                            .AsEnumerable()
                                            .Select(c => new CollectionToggleMenuItem(c.ToLive(realm), beatmapInfo)).Cast<OsuMenuItem>().ToList();
 
-                collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
+                collectionItems.Add(new OsuMenuItem(CommonStrings.Manage, MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
 
                 return collectionItems.ToArray();
             }
diff --git a/osu.Game/Screens/Ranking/SoloResultsScreen.cs b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
index 56d175420f..eaf0369e32 100644
--- a/osu.Game/Screens/Ranking/SoloResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
@@ -20,6 +20,8 @@ namespace osu.Game.Screens.Ranking
     {
         private readonly IBindable<LeaderboardScores?> globalScores = new Bindable<LeaderboardScores?>();
 
+        private TaskCompletionSource<LeaderboardScores>? requestTaskSource;
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
@@ -37,23 +39,37 @@ namespace osu.Game.Screens.Ranking
             globalScores.BindTo(leaderboardManager.Scores);
         }
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (requestTaskSource?.Task.IsCompleted == false)
+                requestTaskSource.SetCanceled();
+        }
+
         protected override async Task<ScoreInfo[]> FetchScores()
         {
             Debug.Assert(Score != null);
 
+            // sort mode intentionally omitted to default to score - results screen only supports sorting by score, so don't pass any other to avoid confusion
             var criteria = new LeaderboardCriteria(
                 Score.BeatmapInfo!,
                 Score.Ruleset,
                 leaderboardManager.CurrentCriteria?.Scope ?? BeatmapLeaderboardScope.Global,
                 leaderboardManager.CurrentCriteria?.ExactMods
             );
-            var requestTaskSource = new TaskCompletionSource<LeaderboardScores>();
+
+            Debug.Assert(requestTaskSource == null || requestTaskSource.Task.IsCompleted);
+
+            requestTaskSource = new TaskCompletionSource<LeaderboardScores>();
+
             globalScores.BindValueChanged(_ =>
             {
                 if (globalScores.Value != null && leaderboardManager.CurrentCriteria?.Equals(criteria) == true)
                     requestTaskSource.TrySetResult(globalScores.Value);
             });
-            leaderboardManager.FetchWithCriteria(criteria, forceRefresh: true);
+
+            Schedule(() => leaderboardManager.FetchWithCriteria(criteria, forceRefresh: true));
 
             var result = await requestTaskSource.Task.ConfigureAwait(false);
 
diff --git a/osu.Game/Screens/Ranking/Statistics/SimpleStatisticItem.cs b/osu.Game/Screens/Ranking/Statistics/SimpleStatisticItem.cs
index d8de1b07b5..280227baea 100644
--- a/osu.Game/Screens/Ranking/Statistics/SimpleStatisticItem.cs
+++ b/osu.Game/Screens/Ranking/Statistics/SimpleStatisticItem.cs
@@ -19,10 +19,23 @@ namespace osu.Game.Screens.Ranking.Statistics
         /// </summary>
         protected string Value
         {
-            set => this.value.Text = value;
+            set => valueText.Text = value;
         }
 
-        private readonly OsuSpriteText value;
+        /// <summary>
+        /// The font size preferred for the displayed texts.
+        /// </summary>
+        public float FontSize
+        {
+            set
+            {
+                nameText.Font = nameText.Font.With(size: value);
+                valueText.Font = valueText.Font.With(size: value);
+            }
+        }
+
+        private readonly OsuSpriteText nameText;
+        private readonly OsuSpriteText valueText;
 
         /// <summary>
         /// Creates a new simple statistic item.
@@ -37,14 +50,14 @@ namespace osu.Game.Screens.Ranking.Statistics
 
             AddRange(new[]
             {
-                new OsuSpriteText
+                nameText = new OsuSpriteText
                 {
                     Text = Name,
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft,
                     Font = OsuFont.GetFont(size: StatisticItem.FONT_SIZE)
                 },
-                value = new OsuSpriteText
+                valueText = new OsuSpriteText
                 {
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.CentreRight,
diff --git a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
index c33514e343..5c5c814c5b 100644
--- a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
+++ b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
@@ -19,7 +19,6 @@ using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Placeholders;
 using osu.Game.Scoring;
@@ -246,11 +245,8 @@ namespace osu.Game.Screens.Ranking.Statistics
                 // We may want to iterate on the following conditions further in the future
 
                 var localUserScore = AchievedScore ?? realm.Run(r =>
-                    r.All<ScoreInfo>()
-                     .Filter($@"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                             + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                             + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                             + $@" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, newScore.BeatmapInfo.ID, newScore.BeatmapInfo.Ruleset.ShortName)
+                    r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                     .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0", newScore.BeatmapInfo.ID)
                      .AsEnumerable()
                      .OrderByDescending(score => score.Ruleset.MatchesOnlineID(newScore.BeatmapInfo.Ruleset))
                      .ThenByDescending(score => score.Rank)
@@ -267,6 +263,7 @@ namespace osu.Game.Screens.Ranking.Statistics
                 {
                     yield return new StatisticItem("Tag the beatmap!", () => new UserTagControl(newScore.BeatmapInfo)
                     {
+                        Writable = true,
                         RelativeSizeAxes = Axes.X,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
@@ -274,12 +271,31 @@ namespace osu.Game.Screens.Ranking.Statistics
                 }
                 else
                 {
-                    yield return new StatisticItem("Tag the beatmap!", () => new OsuTextFlowContainer(cp => cp.Font = OsuFont.GetFont(size: StatisticItem.FONT_SIZE, weight: FontWeight.SemiBold))
+                    yield return new StatisticItem("Tag the beatmap!", () => new FillFlowContainer<CompositeDrawable>
                     {
+                        Children = new CompositeDrawable[]
+                        {
+                            new OsuTextFlowContainer(cp => cp.Font = OsuFont.GetFont(size: StatisticItem.FONT_SIZE, weight: FontWeight.SemiBold))
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                TextAnchor = Anchor.Centre,
+                                Text = preventTaggingReason,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                            new UserTagControl(newScore.BeatmapInfo)
+                            {
+                                Writable = false,
+                                RelativeSizeAxes = Axes.X,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            }
+                        },
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
-                        TextAnchor = Anchor.Centre,
-                        Text = preventTaggingReason,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(4),
                     });
                 }
             }
diff --git a/osu.Game/Screens/Ranking/UserTagControl.cs b/osu.Game/Screens/Ranking/UserTagControl.cs
index 5618dd2490..1005e7ea2c 100644
--- a/osu.Game/Screens/Ranking/UserTagControl.cs
+++ b/osu.Game/Screens/Ranking/UserTagControl.cs
@@ -43,7 +43,12 @@ namespace osu.Game.Screens.Ranking
 
         private readonly Bindable<APIBeatmap?> apiBeatmap = new Bindable<APIBeatmap?>();
 
-        private AddNewTagUserTag addNewTagUserTag = null!;
+        private AddNewTagUserTag? addNewTagUserTag;
+
+        /// <summary>
+        /// Determines whether the user can modify the contained tags
+        /// </summary>
+        public bool Writable { private get; init; }
 
         private InputManager inputManager = null!;
 
@@ -91,12 +96,17 @@ namespace osu.Game.Screens.Ranking
                                         AutoSizeAxes = Axes.Y,
                                         Direction = FillDirection.Full,
                                         Spacing = new Vector2(4),
-                                        Child = addNewTagUserTag = new AddNewTagUserTag
-                                        {
-                                            AvailableTags = { BindTarget = relevantTagsById },
-                                            OnTagSelected = toggleVote,
-                                        },
-                                    },
+                                        Children = Writable
+                                            ?
+                                            [
+                                                addNewTagUserTag = new AddNewTagUserTag
+                                                {
+                                                    AvailableTags = { BindTarget = relevantTagsById },
+                                                    OnTagSelected = toggleVote,
+                                                }
+                                            ]
+                                            : []
+                                    }
                                 },
                             },
                         }
@@ -196,7 +206,7 @@ namespace osu.Game.Screens.Ranking
                 case NotifyCollectionChangedAction.Reset:
                 {
                     tagFlow.Clear();
-                    tagFlow.Add(addNewTagUserTag);
+                    if (Writable) tagFlow.Add(addNewTagUserTag!);
                     break;
                 }
             }
@@ -204,6 +214,9 @@ namespace osu.Game.Screens.Ranking
 
         private void toggleVote(UserTag tag)
         {
+            if (!Writable)
+                return;
+
             if (tag.Updating.Value)
                 return;
 
diff --git a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
index 02b5eb5b7a..4cd91a85e2 100644
--- a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
@@ -83,6 +83,20 @@ namespace osu.Game.Screens.Select.Carousel
                      criteria.Title.Matches(BeatmapInfo.Metadata.TitleUnicode);
             match &= !criteria.DifficultyName.HasFilter || criteria.DifficultyName.Matches(BeatmapInfo.DifficultyName);
             match &= !criteria.Source.HasFilter || criteria.Source.Matches(BeatmapInfo.Metadata.Source);
+
+            if (criteria.UserTags.Any())
+            {
+                foreach (var tagFilter in criteria.UserTags)
+                {
+                    bool anyTagMatched = false;
+
+                    foreach (string tag in BeatmapInfo.Metadata.UserTags)
+                        anyTagMatched |= tagFilter.Matches(tag);
+
+                    match &= anyTagMatched;
+                }
+            }
+
             match &= !criteria.UserStarDifficulty.HasFilter || criteria.UserStarDifficulty.IsInRange(BeatmapInfo.StarRating);
 
             if (!match) return false;
diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
index 74f0c714a3..a8f5b6dd24 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
@@ -112,7 +112,7 @@ namespace osu.Game.Screens.Select.Carousel
             }
 
             if (manager != null)
-                hideRequested = manager.Hide;
+                hideRequested = b => manager.Hide(b);
 
             Header.Children = new Drawable[]
             {
diff --git a/osu.Game/Screens/Select/Carousel/TopLocalRank.cs b/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
index da9661f702..6f1f2e8370 100644
--- a/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
+++ b/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Rulesets;
@@ -59,12 +58,9 @@ namespace osu.Game.Screens.Select.Carousel
             {
                 scoreSubscription?.Dispose();
                 scoreSubscription = realm.RegisterForNotifications(r =>
-                        r.All<ScoreInfo>()
-                         .Filter($"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                                 + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                                 + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                                 + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $2"
-                                 + $" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, beatmapInfo.ID, ruleset.Value.ShortName),
+                        r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                         .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
+                                 + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1", beatmapInfo.ID, ruleset.Value.ShortName),
                     localScoresChanged);
             }, true);
 
diff --git a/osu.Game/Screens/Select/Carousel/UpdateBeatmapSetButton.cs b/osu.Game/Screens/Select/Carousel/UpdateBeatmapSetButton.cs
index e45583887a..d41870f1d2 100644
--- a/osu.Game/Screens/Select/Carousel/UpdateBeatmapSetButton.cs
+++ b/osu.Game/Screens/Select/Carousel/UpdateBeatmapSetButton.cs
@@ -165,13 +165,13 @@ namespace osu.Game.Screens.Select.Carousel
 
         protected override bool OnHover(HoverEvent e)
         {
-            icon.Spin(400, RotationDirection.Clockwise);
+            icon.Spin(400, RotationDirection.Clockwise, icon.Rotation);
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            icon.Spin(4000, RotationDirection.Clockwise);
+            icon.Spin(4000, RotationDirection.Clockwise, icon.Rotation);
             base.OnHoverLost(e);
         }
     }
diff --git a/osu.Game/Screens/Select/Details/AdvancedStats.cs b/osu.Game/Screens/Select/Details/AdvancedStats.cs
index 152398dee3..2d105ae382 100644
--- a/osu.Game/Screens/Select/Details/AdvancedStats.cs
+++ b/osu.Game/Screens/Select/Details/AdvancedStats.cs
@@ -16,10 +16,12 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Beatmaps;
 using osu.Framework.Bindables;
 using System.Collections.Generic;
-using osu.Game.Rulesets.Mods;
+using System.Diagnostics;
 using System.Linq;
+using osu.Game.Rulesets.Mods;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using osu.Framework.Extensions;
 using osu.Framework.Localisation;
 using osu.Framework.Threading;
@@ -28,21 +30,21 @@ using osu.Game.Configuration;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Difficulty;
 using osu.Game.Utils;
 
 namespace osu.Game.Screens.Select.Details
 {
-    public partial class AdvancedStats : Container, IHasCustomTooltip<AdjustedAttributesTooltip.Data>
+    public partial class AdvancedStats : Container
     {
+        private readonly int columns;
+
         [Resolved]
         private BeatmapDifficultyCache difficultyCache { get; set; }
 
-        protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate;
+        protected FillFlowContainer Flow { get; private set; }
         private readonly StatisticRow starDifficulty;
 
-        public ITooltip<AdjustedAttributesTooltip.Data> GetCustomTooltip() => new AdjustedAttributesTooltip();
-        public AdjustedAttributesTooltip.Data TooltipContent { get; private set; }
-
         private IBeatmapInfo beatmapInfo;
 
         public IBeatmapInfo BeatmapInfo
@@ -77,65 +79,48 @@ namespace osu.Game.Screens.Select.Details
 
         public AdvancedStats(int columns = 1)
         {
+            this.columns = columns;
+
             switch (columns)
             {
                 case 1:
-                    Child = new FillFlowContainer
+                    Child = Flow = new FillFlowContainer
                     {
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         Children = new[]
                         {
-                            FirstValue = new StatisticRow(), // circle size/key amount
-                            HpDrain = new StatisticRow { Title = BeatmapsetsStrings.ShowStatsDrain },
-                            Accuracy = new StatisticRow { Title = BeatmapsetsStrings.ShowStatsAccuracy },
-                            ApproachRate = new StatisticRow { Title = BeatmapsetsStrings.ShowStatsAr },
-                            starDifficulty = new StatisticRow(10, true) { Title = BeatmapsetsStrings.ShowStatsStars },
+                            starDifficulty = new StatisticRow(forceDecimalPlaces: true)
+                            {
+                                Title = BeatmapsetsStrings.ShowStatsStars,
+                                MaxValue = 10,
+                            },
                         },
                     };
                     break;
 
                 case 2:
-                    Child = new FillFlowContainer
+                    Child = Flow = new FillFlowContainer
                     {
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         Direction = FillDirection.Full,
                         Children = new[]
                         {
-                            FirstValue = new StatisticRow
-                            {
-                                Width = 0.5f,
-                                Padding = new MarginPadding { Right = 5, Vertical = 2.5f },
-                            }, // circle size/key amount
-                            HpDrain = new StatisticRow
-                            {
-                                Title = BeatmapsetsStrings.ShowStatsDrain,
-                                Width = 0.5f,
-                                Padding = new MarginPadding { Left = 5, Vertical = 2.5f },
-                            },
-                            Accuracy = new StatisticRow
-                            {
-                                Title = BeatmapsetsStrings.ShowStatsAccuracy,
-                                Width = 0.5f,
-                                Padding = new MarginPadding { Right = 5, Vertical = 2.5f },
-                            },
-                            ApproachRate = new StatisticRow
-                            {
-                                Title = BeatmapsetsStrings.ShowStatsAr,
-                                Width = 0.5f,
-                                Padding = new MarginPadding { Left = 5, Vertical = 2.5f },
-                            },
-                            starDifficulty = new StatisticRow(10, true)
+                            starDifficulty = new StatisticRow(forceDecimalPlaces: true)
                             {
+                                MaxValue = 10,
                                 Title = BeatmapsetsStrings.ShowStatsStars,
                                 Width = 0.5f,
-                                Padding = new MarginPadding { Right = 5, Vertical = 2.5f },
+                                Padding = new MarginPadding { Horizontal = 5, Vertical = 2.5f },
                             },
                         },
                     };
                     break;
             }
+
+            Debug.Assert(Flow != null);
+            Flow.SetLayoutPosition(starDifficulty, float.MaxValue);
         }
 
         [BackgroundDependencyLoader]
@@ -171,54 +156,34 @@ namespace osu.Game.Screens.Select.Details
 
         private void updateStatistics()
         {
-            IBeatmapDifficultyInfo baseDifficulty = BeatmapInfo?.Difficulty;
-            BeatmapDifficulty adjustedDifficulty = null;
-
-            if (baseDifficulty != null)
+            if (BeatmapInfo != null && Ruleset.Value != null)
             {
-                BeatmapDifficulty originalDifficulty = new BeatmapDifficulty(baseDifficulty);
+                var displayAttributes = Ruleset.Value.CreateInstance().GetBeatmapAttributesForDisplay(BeatmapInfo, Mods.Value).ToList();
 
-                foreach (var mod in Mods.Value.OfType<IApplicableToDifficulty>())
-                    mod.ApplyToDifficulty(originalDifficulty);
-
-                adjustedDifficulty = originalDifficulty;
-
-                if (Ruleset.Value != null)
+                // if there are not enough attribute displays, make more
+                // the subtraction of 1 is to exclude the star rating row which is always present (and always last)
+                for (int i = Flow.Count - 1; i < displayAttributes.Count; i++)
                 {
-                    double rate = ModUtils.CalculateRateWithMods(Mods.Value);
-
-                    adjustedDifficulty = Ruleset.Value.CreateInstance().GetRateAdjustedDisplayDifficulty(originalDifficulty, rate);
-
-                    TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
+                    Flow.Add(new StatisticRow
+                    {
+                        Width = columns == 1 ? 1 : 0.5f,
+                        Padding = columns == 1 ? new MarginPadding() : new MarginPadding { Horizontal = 5, Vertical = 2.5f },
+                    });
                 }
+
+                // populate all attribute displays that need to be visible...
+                for (int i = 0; i < displayAttributes.Count; i++)
+                {
+                    var attribute = displayAttributes[i];
+                    var row = (StatisticRow)Flow.Where(r => r != starDifficulty).ElementAt(i);
+                    row.SetAttribute(attribute);
+                }
+
+                // and hide any extra ones
+                foreach (var row in Flow.Where(r => r != starDifficulty).Skip(displayAttributes.Count))
+                    ((StatisticRow)row).SetAttribute(null);
             }
 
-            switch (Ruleset.Value?.OnlineID)
-            {
-                case 3:
-                    // Account for mania differences locally for now.
-                    // Eventually this should be handled in a more modular way, allowing rulesets to return arbitrary difficulty attributes.
-                    ILegacyRuleset legacyRuleset = (ILegacyRuleset)Ruleset.Value.CreateInstance();
-
-                    // For the time being, the key count is static no matter what, because:
-                    // a) The method doesn't have knowledge of the active keymods. Doing so may require considerations for filtering.
-                    // b) Using the difficulty adjustment mod to adjust OD doesn't have an effect on conversion.
-                    int keyCount = baseDifficulty == null ? 0 : legacyRuleset.GetKeyCount(BeatmapInfo, Mods.Value);
-
-                    FirstValue.Title = BeatmapsetsStrings.ShowStatsCsMania;
-                    FirstValue.Value = (keyCount, keyCount);
-                    break;
-
-                default:
-                    FirstValue.Title = BeatmapsetsStrings.ShowStatsCs;
-                    FirstValue.Value = (baseDifficulty?.CircleSize ?? 0, adjustedDifficulty?.CircleSize);
-                    break;
-            }
-
-            HpDrain.Value = (baseDifficulty?.DrainRate ?? 0, adjustedDifficulty?.DrainRate);
-            Accuracy.Value = (baseDifficulty?.OverallDifficulty ?? 0, adjustedDifficulty?.OverallDifficulty);
-            ApproachRate.Value = (baseDifficulty?.ApproachRate ?? 0, adjustedDifficulty?.ApproachRate);
-
             updateStarDifficulty();
         }
 
@@ -262,12 +227,11 @@ namespace osu.Game.Screens.Select.Details
             starDifficultyCancellationSource?.Cancel();
         }
 
-        public partial class StatisticRow : Container, IHasAccentColour
+        public partial class StatisticRow : Container, IHasAccentColour, IHasCustomTooltip<RulesetBeatmapAttribute>
         {
             private const float value_width = 25;
             private const float name_width = 70;
 
-            private readonly float maxValue;
             private readonly bool forceDecimalPlaces;
             private readonly OsuSpriteText name, valueText;
             private readonly Bar bar;
@@ -282,6 +246,8 @@ namespace osu.Game.Screens.Select.Details
                 set => name.Text = value;
             }
 
+            public float MaxValue { get; set; }
+
             private (float baseValue, float? adjustedValue)? value;
 
             public (float baseValue, float? adjustedValue) Value
@@ -294,10 +260,10 @@ namespace osu.Game.Screens.Select.Details
 
                     this.value = value;
 
-                    bar.Length = value.baseValue / maxValue;
+                    bar.Length = value.baseValue / MaxValue;
 
                     valueText.Text = (value.adjustedValue ?? value.baseValue).ToString(forceDecimalPlaces ? "0.00" : "0.##");
-                    ModBar.Length = (value.adjustedValue ?? 0) / maxValue;
+                    ModBar.Length = (value.adjustedValue ?? 0) / MaxValue;
 
                     if (Precision.AlmostEquals(value.baseValue, value.adjustedValue ?? value.baseValue, 0.05f))
                         ModBar.AccentColour = valueText.Colour = Color4.White;
@@ -314,9 +280,8 @@ namespace osu.Game.Screens.Select.Details
                 set => bar.AccentColour = value;
             }
 
-            public StatisticRow(float maxValue = 10, bool forceDecimalPlaces = false)
+            public StatisticRow(bool forceDecimalPlaces = false)
             {
-                this.maxValue = maxValue;
                 this.forceDecimalPlaces = forceDecimalPlaces;
                 RelativeSizeAxes = Axes.X;
                 AutoSizeAxes = Axes.Y;
@@ -381,6 +346,26 @@ namespace osu.Game.Screens.Select.Details
                     },
                 };
             }
+
+            public void SetAttribute([CanBeNull] RulesetBeatmapAttribute attribute)
+            {
+                if (attribute != null)
+                {
+                    Title = attribute.Label;
+                    MaxValue = attribute.MaxValue;
+                    Value = (attribute.OriginalValue, attribute.AdjustedValue);
+                    Alpha = 1;
+                }
+                else
+                    Alpha = 0;
+
+                TooltipContent = attribute;
+            }
+
+            public ITooltip<RulesetBeatmapAttribute> GetCustomTooltip() => new BeatmapAttributeTooltip();
+
+            [CanBeNull]
+            public RulesetBeatmapAttribute TooltipContent { get; set; }
         }
     }
 }
diff --git a/osu.Game/Screens/Select/Filter/GroupMode.cs b/osu.Game/Screens/Select/Filter/GroupMode.cs
index 04aef2fe18..06d3a71b0f 100644
--- a/osu.Game/Screens/Select/Filter/GroupMode.cs
+++ b/osu.Game/Screens/Select/Filter/GroupMode.cs
@@ -1,58 +1,59 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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.Localisation;
 
 namespace osu.Game.Screens.Select.Filter
 {
     public enum GroupMode
     {
-        [Description("None")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.None))]
         None,
 
-        [Description("Artist")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Artist))]
         Artist,
 
-        [Description("Author")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Author))]
         Author,
 
-        [Description("BPM")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.BPM))]
         BPM,
 
-        // [Description("Collections")]
-        // Collections,
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Collections))]
+        Collections,
 
-        [Description("Date Added")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.DateAdded))]
         DateAdded,
 
-        [Description("Date Ranked")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.DateRanked))]
         DateRanked,
 
-        [Description("Difficulty")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Difficulty))]
         Difficulty,
 
-        // [Description("Favourites")]
+        // [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Favourites))]
         // Favourites,
 
-        [Description("Last Played")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.LastPlayed))]
         LastPlayed,
 
-        [Description("Length")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Length))]
         Length,
 
-        // [Description("My Maps")]
-        // MyMaps,
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.MyMaps))]
+        MyMaps,
 
-        // [Description("Rank Achieved")]
-        // RankAchieved,
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.RankAchieved))]
+        RankAchieved,
 
-        [Description("Ranked Status")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.RankedStatus))]
         RankedStatus,
 
-        [Description("Source")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Source))]
         Source,
 
-        [Description("Title")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Title))]
         Title,
     }
 }
diff --git a/osu.Game/Screens/Select/Filter/SortMode.cs b/osu.Game/Screens/Select/Filter/SortMode.cs
index 7f2b33adbe..5dd25d4846 100644
--- a/osu.Game/Screens/Select/Filter/SortMode.cs
+++ b/osu.Game/Screens/Select/Filter/SortMode.cs
@@ -1,49 +1,48 @@
 // 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;
+using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Select.Filter
 {
     public enum SortMode
     {
-        [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingArtist))]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Artist))]
         Artist,
 
-        [Description("Author")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Author))]
         Author,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.ArtistTracksBpm))]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.BPM))]
         BPM,
 
-        [Description("Date Submitted")]
-        DateSubmitted,
-
-        [Description("Date Added")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.DateAdded))]
         DateAdded,
 
-        [Description("Date Ranked")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.DateRanked))]
         DateRanked,
 
-        [Description("Last Played")]
-        LastPlayed,
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.DateSubmitted))]
+        DateSubmitted,
 
-        [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingDifficulty))]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Difficulty))]
         Difficulty,
 
-        [LocalisableDescription(typeof(SortStrings), nameof(SortStrings.ArtistTracksLength))]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.LastPlayed))]
+        LastPlayed,
+
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Length))]
         Length,
 
-        // todo: pending support (https://github.com/ppy/osu/issues/4917)
-        // [Description("Rank Achieved")]
+        // // todo: pending support (https://github.com/ppy/osu/issues/4917)
+        // [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.RankAchieved))]
         // RankAchieved,
 
-        [Description("Source")]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Source))]
         Source,
 
-        [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.ListingSearchSortingTitle))]
+        [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Title))]
         Title,
     }
 }
diff --git a/osu.Game/Screens/Select/FilterCriteria.cs b/osu.Game/Screens/Select/FilterCriteria.cs
index cc8a92c7c7..9ac22d90c4 100644
--- a/osu.Game/Screens/Select/FilterCriteria.cs
+++ b/osu.Game/Screens/Select/FilterCriteria.cs
@@ -39,6 +39,7 @@ namespace osu.Game.Screens.Select
         public OptionalTextFilter Title;
         public OptionalTextFilter DifficultyName;
         public OptionalTextFilter Source;
+        public List<OptionalTextFilter> UserTags = [];
 
         public OptionalRange<double> UserStarDifficulty = new OptionalRange<double>
         {
@@ -117,6 +118,18 @@ namespace osu.Game.Screens.Select
 
         public IRulesetFilterCriteria? RulesetCriteria { get; set; }
 
+        /// <summary>
+        /// The user ID of the current local user, used to filter to own maps when <see cref="GroupMode.MyMaps"/> is selected.
+        /// Or null if the user is not logged in.
+        /// </summary>
+        public int? LocalUserId { get; set; }
+
+        /// <summary>
+        /// The username of the current local user, used to filter to own maps when <see cref="GroupMode.MyMaps"/> is selected.
+        /// Or null if the user is not logged in.
+        /// </summary>
+        public string? LocalUserUsername { get; set; }
+
         public readonly struct OptionalSet<T> : IEquatable<OptionalSet<T>>
             where T : struct, Enum
         {
@@ -141,29 +154,25 @@ namespace osu.Game.Screens.Select
 
             public bool IsInRange(T value)
             {
+                bool lowerRangeSatisfied = true;
+                bool upperRangeSatisfied = true;
+
                 if (Min != null)
                 {
                     int comparison = Comparer<T>.Default.Compare(value, Min.Value);
-
-                    if (comparison < 0)
-                        return false;
-
-                    if (comparison == 0 && !IsLowerInclusive)
-                        return false;
+                    lowerRangeSatisfied = comparison > 0 || (comparison == 0 && IsLowerInclusive);
                 }
 
                 if (Max != null)
                 {
                     int comparison = Comparer<T>.Default.Compare(value, Max.Value);
-
-                    if (comparison > 0)
-                        return false;
-
-                    if (comparison == 0 && !IsUpperInclusive)
-                        return false;
+                    upperRangeSatisfied = comparison < 0 || (comparison == 0 && IsUpperInclusive);
                 }
 
-                return true;
+                bool result = lowerRangeSatisfied && upperRangeSatisfied;
+                if (InvertRange)
+                    result = !result;
+                return result;
             }
 
             public T? Min;
@@ -171,6 +180,11 @@ namespace osu.Game.Screens.Select
             public bool IsLowerInclusive;
             public bool IsUpperInclusive;
 
+            /// <summary>
+            /// When <see langword="true"/>, the meaning of this filter is inverted, i.e. it will <i>exclude</i> items that satisfy this range.
+            /// </summary>
+            public bool InvertRange;
+
             public bool Equals(OptionalRange<T> other)
                 => EqualityComparer<T?>.Default.Equals(Min, other.Min)
                    && EqualityComparer<T?>.Default.Equals(Max, other.Max)
@@ -193,22 +207,37 @@ namespace osu.Game.Screens.Select
                 if (string.IsNullOrEmpty(value))
                     return false;
 
+                bool result;
+
                 switch (MatchMode)
                 {
                     default:
                     case MatchMode.Substring:
                         // Note that we are using ordinal here to avoid performance issues caused by globalisation concerns.
                         // See https://github.com/ppy/osu/issues/11571 / https://github.com/dotnet/docs/issues/18423.
-                        return value.Contains(SearchTerm, StringComparison.OrdinalIgnoreCase);
+                        result = value.Contains(SearchTerm, StringComparison.OrdinalIgnoreCase);
+                        break;
 
                     case MatchMode.IsolatedPhrase:
-                        return Regex.IsMatch(value, $@"(^|\s){Regex.Escape(searchTerm)}($|\s)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+                        result = Regex.IsMatch(value, $@"(^|\s){Regex.Escape(searchTerm)}($|\s)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+                        break;
 
                     case MatchMode.FullPhrase:
-                        return CultureInfo.InvariantCulture.CompareInfo.Compare(value, searchTerm, CompareOptions.OrdinalIgnoreCase) == 0;
+                        result = CultureInfo.InvariantCulture.CompareInfo.Compare(value, searchTerm, CompareOptions.OrdinalIgnoreCase) == 0;
+                        break;
                 }
+
+                if (ExcludeTerm)
+                    result = !result;
+
+                return result;
             }
 
+            /// <summary>
+            /// When <see langword="true"/>, the meaning of this filter is inverted, i.e. it will <i>exclude</i> items which match <see cref="SearchTerm"/>.
+            /// </summary>
+            public bool ExcludeTerm;
+
             private string searchTerm;
 
             public string SearchTerm
diff --git a/osu.Game/Screens/Select/FilterQueryParser.cs b/osu.Game/Screens/Select/FilterQueryParser.cs
index 02a6da146e..7d66a61884 100644
--- a/osu.Game/Screens/Select/FilterQueryParser.cs
+++ b/osu.Game/Screens/Select/FilterQueryParser.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.Select
     public static class FilterQueryParser
     {
         private static readonly Regex query_syntax_regex = new Regex(
-            @"\b(?<key>\w+)(?<op>(!?(:|=)|(>|<)(:|=)?))(?<value>("".*""[!]?)|(\S*))",
+            @"\b(?<key>\w+)(?<op>(!?(:|=)|(>|<)(:|=)?))(?<value>("".*?""[!]?)|(\S*))",
             RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
         internal static void ApplyQueries(FilterCriteria criteria, string query)
@@ -76,6 +76,8 @@ namespace osu.Game.Screens.Select
                         return false;
 
                     // Unplayed beatmaps are filtered on DateTimeOffset.MinValue.
+                    if (op == Operator.NotEqual)
+                        played = !played;
 
                     if (played)
                     {
@@ -116,6 +118,12 @@ namespace osu.Game.Screens.Select
                 case "source":
                     return TryUpdateCriteriaText(ref criteria.Source, op, value);
 
+                case "tag":
+                    var tagFilter = new FilterCriteria.OptionalTextFilter();
+                    TryUpdateCriteriaText(ref tagFilter, op, value);
+                    criteria.UserTags.Add(tagFilter);
+                    return true;
+
                 default:
                     return criteria.RulesetCriteria?.TryParseCustomKeywordCriteria(key, op, value) ?? false;
             }
@@ -226,6 +234,10 @@ namespace osu.Game.Screens.Select
         {
             switch (op)
             {
+                case Operator.NotEqual:
+                    textFilter.ExcludeTerm = true;
+                    goto case Operator.Equal;
+
                 case Operator.Equal:
                     textFilter.SearchTerm = value;
                     return true;
@@ -253,14 +265,22 @@ namespace osu.Game.Screens.Select
 
         private static bool tryUpdateCriteriaRange(ref FilterCriteria.OptionalRange<float> range, Operator op, float value, float tolerance = 0.05f)
         {
+            range.InvertRange = false;
+
             switch (op)
             {
                 default:
                     return false;
 
+                case Operator.NotEqual:
+                    range.InvertRange = true;
+                    goto case Operator.Equal;
+
                 case Operator.Equal:
                     range.Min = value - tolerance;
                     range.Max = value + tolerance;
+                    if (tolerance == 0)
+                        range.IsLowerInclusive = range.IsUpperInclusive = true;
                     break;
 
                 case Operator.Greater:
@@ -301,11 +321,17 @@ namespace osu.Game.Screens.Select
 
         private static bool tryUpdateCriteriaRange(ref FilterCriteria.OptionalRange<double> range, Operator op, double value, double tolerance = 0.05)
         {
+            range.InvertRange = false;
+
             switch (op)
             {
                 default:
                     return false;
 
+                case Operator.NotEqual:
+                    range.InvertRange = true;
+                    goto case Operator.Equal;
+
                 case Operator.Equal:
                     range.Min = value - tolerance;
                     range.Max = value + tolerance;
@@ -374,17 +400,30 @@ namespace osu.Game.Screens.Select
         {
             var matchingValues = new HashSet<T>();
 
-            if (op == Operator.Equal && filterValue.Contains(','))
+            if (filterValue.Contains(','))
             {
                 string[] splitValues = filterValue.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                HashSet<T> parsedValues = new HashSet<T>();
 
                 foreach (string splitValue in splitValues)
                 {
                     if (!tryParseEnum<T>(splitValue, out var parsedValue))
                         return false;
 
-                    matchingValues.Add(parsedValue);
+                    parsedValues.Add(parsedValue);
                 }
+
+                if (op == Operator.Equal)
+                {
+                    matchingValues.UnionWith(parsedValues);
+                }
+                else if (op == Operator.NotEqual)
+                {
+                    matchingValues.UnionWith(Enum.GetValues<T>());
+                    matchingValues.ExceptWith(parsedValues);
+                }
+                else
+                    return false;
             }
             else
             {
@@ -419,6 +458,10 @@ namespace osu.Game.Screens.Select
                             if (compareResult > 0) matchingValues.Add(val);
                             break;
 
+                        case Operator.NotEqual:
+                            if (compareResult != 0) matchingValues.Add(val);
+                            break;
+
                         default:
                             return false;
                     }
@@ -437,6 +480,10 @@ namespace osu.Game.Screens.Select
                 default:
                     return false;
 
+                case Operator.NotEqual:
+                    range.InvertRange = true;
+                    goto case Operator.Equal;
+
                 case Operator.Equal:
                     range.IsLowerInclusive = range.IsUpperInclusive = true;
                     range.Min = value;
@@ -517,13 +564,15 @@ namespace osu.Game.Screens.Select
         {
             switch (op)
             {
+                case Operator.NotEqual:
                 case Operator.Equal:
-                    // an equality filter is difficult to define for support here.
+                    // an equality or inequality filter is difficult to define for support here.
                     // if "3 months 2 days ago" means a single concrete time instant, such a filter is basically useless.
                     // if it means a range of 24 hours, then that is annoying to write and also comes with its own implications
                     // (does it mean "time instant 3 months 2 days ago, within 12 hours of tolerance either direction"?
                     // does it mean "the full calendar day, from midnight to midnight, 3 months 2 days ago"?)
                     // as such, for simplicity, just refuse to support this.
+                    // same applies to inequality, but instead 24 hours would be need to be left out
                     return false;
 
                 // for the remaining operators, since the value provided to this function is an "ago" type value
@@ -676,6 +725,7 @@ namespace osu.Game.Screens.Select
             try
             {
                 DateTimeOffset dateTimeOffset;
+                dateRange.InvertRange = false;
 
                 switch (op)
                 {
@@ -731,6 +781,11 @@ namespace osu.Game.Screens.Select
                         dateTimeOffset = dateTimeOffsetFromDateOnly(year.Value, month.Value, day.Value).AddDays(1);
                         return tryUpdateCriteriaRange(ref dateRange, Operator.GreaterOrEqual, dateTimeOffset);
 
+                    case Operator.NotEqual:
+
+                        dateRange.InvertRange = true;
+                        goto case Operator.Equal;
+
                     case Operator.Equal:
 
                         DateTimeOffset minDateTimeOffset;
diff --git a/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboardScope.cs b/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboardScope.cs
index a3687d9586..497e456881 100644
--- a/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboardScope.cs
+++ b/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboardScope.cs
@@ -1,27 +1,26 @@
 // 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;
+using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Select.Leaderboards
 {
     public enum BeatmapLeaderboardScope
     {
-        [Description("Local Ranking")]
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Local))]
         Local,
 
-        [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowScoreboardGlobal))]
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Global))]
         Global,
 
-        [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowScoreboardCountry))]
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Country))]
         Country,
 
-        [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowScoreboardFriend))]
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Friend))]
         Friend,
 
-        [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowScoreboardTeam))]
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Team))]
         Team,
     }
 }
diff --git a/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
index 6118529780..9c4875477c 100644
--- a/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
+++ b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
@@ -13,6 +13,9 @@ namespace osu.Game.Screens.Select.Leaderboards
         /// <summary>
         /// List of all scores to display on the leaderboard.
         /// </summary>
+        /// <remarks>
+        /// Implementors should ensure that this list is only mutated from the update thread.
+        /// </remarks>
         IBindableList<GameplayLeaderboardScore> Scores { get; }
     }
 
diff --git a/osu.Game/Screens/Select/Leaderboards/LeaderboardSortMode.cs b/osu.Game/Screens/Select/Leaderboards/LeaderboardSortMode.cs
new file mode 100644
index 0000000000..d5fb2f3c54
--- /dev/null
+++ b/osu.Game/Screens/Select/Leaderboards/LeaderboardSortMode.cs
@@ -0,0 +1,26 @@
+// 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.Localisation;
+using osu.Game.Localisation;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    public enum LeaderboardSortMode
+    {
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Score))]
+        Score,
+
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Accuracy))]
+        Accuracy,
+
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.MaxCombo))]
+        MaxCombo,
+
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Misses))]
+        Misses,
+
+        [LocalisableDescription(typeof(BeatmapLeaderboardWedgeStrings), nameof(BeatmapLeaderboardWedgeStrings.Date))]
+        Date,
+    }
+}
diff --git a/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs
index 206b1375de..ea0a2b68dc 100644
--- a/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs
+++ b/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs
@@ -34,35 +34,43 @@ namespace osu.Game.Screens.Select.Leaderboards
         [BackgroundDependencyLoader]
         private void load(IAPIProvider api, GameplayState? gameplayState)
         {
-            var scoresRequest = new IndexPlaylistScoresRequest(room.RoomID!.Value, playlistItem.ID);
-            scoresRequest.Success += response =>
-            {
-                var newScores = new List<GameplayLeaderboardScore>();
+            var scoresToShow = new List<GameplayLeaderboardScore>();
 
+            var scoresRequest = new IndexPlaylistScoresRequest(room.RoomID!.Value, playlistItem.ID);
+            api.Perform(scoresRequest);
+
+            var response = scoresRequest.Response;
+
+            if (response != null)
+            {
                 isPartial = response.Scores.Count < response.TotalScores;
 
                 for (int i = 0; i < response.Scores.Count; i++)
                 {
                     var score = response.Scores[i];
                     score.Position = i + 1;
-                    newScores.Add(new GameplayLeaderboardScore(score, tracked: false, GameplayLeaderboardScore.ComboDisplayMode.Highest));
+                    scoresToShow.Add(new GameplayLeaderboardScore(score, tracked: false, GameplayLeaderboardScore.ComboDisplayMode.Highest));
                 }
 
                 if (response.UserScore != null && response.Scores.All(s => s.ID != response.UserScore.ID))
-                    newScores.Add(new GameplayLeaderboardScore(response.UserScore, tracked: false, GameplayLeaderboardScore.ComboDisplayMode.Highest));
-
-                scores.AddRange(newScores);
-            };
-            api.Perform(scoresRequest);
+                    scoresToShow.Add(new GameplayLeaderboardScore(response.UserScore, tracked: false, GameplayLeaderboardScore.ComboDisplayMode.Highest));
+            }
 
             if (gameplayState != null)
             {
                 var localScore = new GameplayLeaderboardScore(gameplayState, tracked: true, GameplayLeaderboardScore.ComboDisplayMode.Highest);
                 localScore.TotalScore.BindValueChanged(_ => sorting.Invalidate());
-                scores.Add(localScore);
+                scoresToShow.Add(localScore);
             }
 
-            Scheduler.AddDelayed(sort, 1000, true);
+            // touching the public bindable must happen on the update thread for general thread safety,
+            // since we may have external subscribers bound already
+            Schedule(() =>
+            {
+                scores.AddRange(scoresToShow);
+                sort();
+                Scheduler.AddDelayed(sort, 1000, true);
+            });
         }
 
         // logic shared with SoloGameplayLeaderboardProvider
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index 1b8d8b506d..bcac74662e 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -8,6 +8,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -18,12 +19,16 @@ using osu.Framework.Graphics.Pooling;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 using osu.Game.Configuration;
 using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets;
+using osu.Game.Scoring;
 using osu.Game.Screens.Select;
+using Realms;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -35,12 +40,12 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// From the provided beatmaps, select the most appropriate one for the user's skill.
         /// </summary>
-        public required Action<IEnumerable<BeatmapInfo>> RequestRecommendedSelection { private get; init; }
+        public required Action<IEnumerable<GroupedBeatmap>> RequestRecommendedSelection { private get; init; }
 
         /// <summary>
         /// Selection requested for the provided beatmap.
         /// </summary>
-        public required Action<BeatmapInfo> RequestSelection { private get; init; }
+        public required Action<GroupedBeatmap> RequestSelection { private get; init; }
 
         public const float SPACING = 3f;
 
@@ -48,13 +53,12 @@ namespace osu.Game.Screens.SelectV2
 
         private readonly LoadingLayer loading;
 
-        private readonly BeatmapCarouselFilterMatching matching;
         private readonly BeatmapCarouselFilterGrouping grouping;
 
         /// <summary>
         /// Total number of beatmap difficulties displayed with the filter.
         /// </summary>
-        public int MatchedBeatmapsCount => matching.BeatmapItemsCount;
+        public int MatchedBeatmapsCount => Filters.Last().BeatmapItemsCount;
 
         protected override float GetSpacingBetweenPanels(CarouselItem top, CarouselItem bottom)
         {
@@ -65,15 +69,15 @@ namespace osu.Game.Screens.SelectV2
             if (grouping.BeatmapSetsGroupedTogether)
             {
                 // Give some space around the expanded beatmap set, at the top..
-                if (bottom.Model is BeatmapSetInfo && bottom.IsExpanded)
+                if (bottom.Model is GroupedBeatmapSet && bottom.IsExpanded)
                     return SPACING * 2;
 
                 // ..and the bottom.
-                if (top.Model is BeatmapInfo && bottom.Model is BeatmapSetInfo)
+                if (top.Model is GroupedBeatmap && bottom.Model is GroupedBeatmapSet)
                     return SPACING * 2;
 
                 // Beatmap difficulty panels do not overlap with themselves or any other panel.
-                if (top.Model is BeatmapInfo || bottom.Model is BeatmapInfo)
+                if (top.Model is GroupedBeatmap || bottom.Model is GroupedBeatmap)
                     return SPACING;
             }
             else
@@ -96,9 +100,9 @@ namespace osu.Game.Screens.SelectV2
 
             Filters = new ICarouselFilter[]
             {
-                matching = new BeatmapCarouselFilterMatching(() => Criteria!),
+                new BeatmapCarouselFilterMatching(() => Criteria!),
                 new BeatmapCarouselFilterSorting(() => Criteria!),
-                grouping = new BeatmapCarouselFilterGrouping(() => Criteria!),
+                grouping = new BeatmapCarouselFilterGrouping(() => Criteria!, GetAllCollections, GetBeatmapInfoGuidToTopRankMapping)
             };
 
             AddInternal(loading = new LoadingLayer());
@@ -139,14 +143,84 @@ namespace osu.Game.Screens.SelectV2
             switch (changed.Action)
             {
                 case NotifyCollectionChangedAction.Add:
+                    if (!newItems!.Any())
+                        return;
+
                     Items.AddRange(newItems!.SelectMany(s => s.Beatmaps));
                     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 as GroupedBeatmap)?.Beatmap, 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 GroupedBeatmap groupedBeatmap)
+                                {
+                                    // check the new selection wasn't deleted above
+                                    if (!Items.Contains(groupedBeatmap.Beatmap))
+                                        return false;
+
+                                    RequestSelection(groupedBeatmap);
+                                    return true;
+                                }
+
+                                if (item.Model is GroupedBeatmapSet groupedSet)
+                                {
+                                    if (oldItems.Contains(groupedSet.BeatmapSet))
+                                        return false;
+
+                                    selectRecommendedDifficultyForBeatmapSet(groupedSet);
+                                    return true;
+                                }
+                            }
+
+                            return false;
+                        }
                     }
 
                     break;
@@ -171,16 +245,25 @@ namespace osu.Game.Screens.SelectV2
                         int previousIndex = Items.IndexOf(beatmap);
                         Debug.Assert(previousIndex >= 0);
 
+                        // we're intentionally being lenient with there being two difficulties with equal online ID or difficulty name.
+                        // this can be the case when the user modifies the beatmap using the editor's "external edit" feature.
                         BeatmapInfo? matchingNewBeatmap =
-                            newSetBeatmaps.SingleOrDefault(b => b.OnlineID > 0 && b.OnlineID == beatmap.OnlineID) ??
-                            newSetBeatmaps.SingleOrDefault(b => b.DifficultyName == beatmap.DifficultyName && b.Ruleset.Equals(beatmap.Ruleset));
+                            newSetBeatmaps.FirstOrDefault(b => b.OnlineID > 0 && b.OnlineID == beatmap.OnlineID) ??
+                            newSetBeatmaps.FirstOrDefault(b => b.DifficultyName == beatmap.DifficultyName && b.Ruleset.Equals(beatmap.Ruleset));
+
+                        // The matching beatmap may have been deleted or invalidated in some way since this event was fired.
+                        // Let's make sure we have the most up-to-date realm state.
+                        if (matchingNewBeatmap?.ID is Guid matchingID)
+                            matchingNewBeatmap = realm.Run(r => r.FindWithRefresh<BeatmapInfo>(matchingID)?.Detach());
 
                         if (matchingNewBeatmap != null)
                         {
                             // TODO: should this exist in song select instead of here?
                             // we need to ensure the global beatmap is also updated alongside changes.
-                            if (CurrentSelection != null && CheckModelEquality(beatmap, CurrentSelection))
-                                RequestSelection(matchingNewBeatmap);
+                            if (CurrentBeatmap != null && beatmap.Equals(CurrentBeatmap))
+                                // we don't know in which group the matching new beatmap is, but that's fine - we can leave it null for now.
+                                // we are about to modify `Items`, which will trigger a re-filter, which will pick a correct group - if one is present - via `HandleFilterCompleted()`.
+                                RequestSelection(new GroupedBeatmap(null, matchingNewBeatmap));
 
                             Items.ReplaceRange(previousIndex, 1, [matchingNewBeatmap]);
                             newSetBeatmaps.Remove(matchingNewBeatmap);
@@ -209,10 +292,54 @@ namespace osu.Game.Screens.SelectV2
 
         protected GroupDefinition? ExpandedGroup { get; private set; }
 
-        protected BeatmapSetInfo? ExpandedBeatmapSet { get; private set; }
+        protected GroupedBeatmapSet? ExpandedBeatmapSet { get; private set; }
 
         protected override bool ShouldActivateOnKeyboardSelection(CarouselItem item) =>
-            grouping.BeatmapSetsGroupedTogether && item.Model is BeatmapInfo;
+            grouping.BeatmapSetsGroupedTogether && item.Model is GroupedBeatmap;
+
+        /// <summary>
+        /// The currently selected <see cref="GroupedBeatmap"/>.
+        /// </summary>
+        /// <remarks>
+        /// The selection is never reset due to not existing. It can be set to anything.
+        /// If no matching carousel item exists, there will be no visually selected item while waiting for potential new item which matches.
+        /// </remarks>
+        public GroupedBeatmap? CurrentGroupedBeatmap
+        {
+            get => CurrentSelection as GroupedBeatmap;
+            set => CurrentSelection = value;
+        }
+
+        /// <summary>
+        /// The currently selected <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is a property mostly dedicated to external consumers who only care about showing some particular copy of a beatmap
+        /// (there could be multiple panels for one beatmap due to grouping).
+        /// Through this property, the carousel basically figures out what group to use internally.
+        /// </remarks>
+        public BeatmapInfo? CurrentBeatmap
+        {
+            get => CurrentGroupedBeatmap?.Beatmap;
+            set
+            {
+                if (value == null)
+                {
+                    CurrentGroupedBeatmap = null;
+                    return;
+                }
+
+                if (CurrentGroupedBeatmap != null && value.Equals(CurrentGroupedBeatmap.Beatmap))
+                    return;
+
+                // it is not universally guaranteed that the carousel items will be materialised at the time this is set.
+                // therefore, in cases where it is known that they will not be, default to a null group.
+                // even if grouping is active, this will be rectified to a correct group on the next invocation of `HandleFilterCompleted()`.
+                CurrentGroupedBeatmap = IsLoaded && !IsFiltering
+                    ? GetCarouselItems()?.Select(item => item.Model).OfType<GroupedBeatmap>().FirstOrDefault(gb => gb.Beatmap.Equals(value))
+                    : new GroupedBeatmap(null, value);
+            }
+        }
 
         protected override void HandleItemActivated(CarouselItem item)
         {
@@ -232,23 +359,23 @@ namespace osu.Game.Screens.SelectV2
                         setExpandedGroup(group);
 
                         // If the active selection is within this group, it should get keyboard focus immediately.
-                        if (CurrentSelectionItem?.IsVisible == true && CurrentSelection is BeatmapInfo info)
-                            RequestSelection(info);
+                        if (CurrentSelectionItem?.IsVisible == true && CurrentSelection is GroupedBeatmap gb)
+                            RequestSelection(gb);
 
                         return;
 
-                    case BeatmapSetInfo setInfo:
-                        selectRecommendedDifficultyForBeatmapSet(setInfo);
+                    case GroupedBeatmapSet groupedSet:
+                        selectRecommendedDifficultyForBeatmapSet(groupedSet);
                         return;
 
-                    case BeatmapInfo beatmapInfo:
-                        if (CurrentSelection != null && CheckModelEquality(CurrentSelection, beatmapInfo))
+                    case GroupedBeatmap groupedBeatmap:
+                        if (CurrentSelection != null && CheckModelEquality(CurrentSelection, groupedBeatmap))
                         {
-                            RequestPresentBeatmap?.Invoke(beatmapInfo);
+                            RequestPresentBeatmap?.Invoke(groupedBeatmap.Beatmap);
                             return;
                         }
 
-                        RequestSelection(beatmapInfo);
+                        RequestSelection(groupedBeatmap);
                         return;
                 }
             }
@@ -264,22 +391,70 @@ namespace osu.Game.Screens.SelectV2
 
             switch (model)
             {
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                 case GroupDefinition:
                     throw new InvalidOperationException("Groups should never become selected");
 
-                case BeatmapInfo beatmapInfo:
-                    // Find any containing group. There should never be too many groups so iterating is efficient enough.
-                    GroupDefinition? containingGroup = grouping.GroupItems.SingleOrDefault(kvp => kvp.Value.Any(i => CheckModelEquality(i.Model, beatmapInfo))).Key;
-
-                    setExpandedGroup(containingGroup);
+                case GroupedBeatmap groupedBeatmap:
+                    setExpandedGroup(groupedBeatmap.Group);
 
                     if (grouping.BeatmapSetsGroupedTogether)
-                        setExpandedSet(beatmapInfo);
+                        setExpandedSet(new GroupedBeatmapSet(groupedBeatmap.Group, groupedBeatmap.Beatmap.BeatmapSet!));
                     break;
             }
         }
 
+        protected override bool HandleItemsChanged(NotifyCollectionChangedEventArgs args)
+        {
+            switch (args.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                case NotifyCollectionChangedAction.Remove:
+                case NotifyCollectionChangedAction.Move:
+                case NotifyCollectionChangedAction.Reset:
+                    return true;
+
+                case NotifyCollectionChangedAction.Replace:
+                    var oldBeatmaps = args.OldItems!.OfType<BeatmapInfo>().ToList();
+                    var newBeatmaps = args.NewItems!.OfType<BeatmapInfo>().ToList();
+
+                    for (int i = 0; i < oldBeatmaps.Count; i++)
+                    {
+                        var oldBeatmap = oldBeatmaps[i];
+                        var newBeatmap = newBeatmaps[i];
+
+                        // Ignore changes which don't concern us.
+                        //
+                        // Here are some examples of things that can go wrong:
+                        // - Background difficulty calculation runs and causes a realm update.
+                        //   We use `BeatmapDifficultyCache` and don't want to know about these.
+                        // - Background user tag population runs and causes a realm update.
+                        //   We don't display user tags so want to ignore this.
+                        bool equalForDisplayPurposes =
+                            // covers metadata changes
+                            oldBeatmap.Hash == newBeatmap.Hash &&
+                            // sanity check
+                            oldBeatmap.OnlineID == newBeatmap.OnlineID &&
+                            // displayed on panel
+                            oldBeatmap.Status == newBeatmap.Status &&
+                            // displayed on panel
+                            oldBeatmap.DifficultyName == newBeatmap.DifficultyName &&
+                            // hidden changed, needs re-filter
+                            oldBeatmap.Hidden == newBeatmap.Hidden &&
+                            // might be used for grouping, returning from gameplay
+                            oldBeatmap.LastPlayed == newBeatmap.LastPlayed;
+
+                        if (equalForDisplayPurposes)
+                            return false;
+                    }
+
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
         protected override void HandleFilterCompleted()
         {
             base.HandleFilterCompleted();
@@ -289,9 +464,27 @@ namespace osu.Game.Screens.SelectV2
             // Store selected group before handling selection (it may implicitly change the expanded group).
             var groupForReselection = ExpandedGroup;
 
-            // Ensure correct post-selection logic is handled on the new items list.
-            // This will update the visual state of the selected item.
-            HandleItemSelected(CurrentSelection);
+            var currentGroupedBeatmap = CurrentSelection as GroupedBeatmap;
+
+            // The filter might have changed the set of available groups, which means that the current selection may point to a stale group.
+            // Check whether that is the case.
+            bool groupingRemainsOff = currentGroupedBeatmap?.Group == null && grouping.GroupItems.Count == 0;
+            bool groupStillExists = currentGroupedBeatmap?.Group != null && grouping.GroupItems.ContainsKey(currentGroupedBeatmap.Group);
+
+            if (groupingRemainsOff || groupStillExists)
+            {
+                // Only update the visual state of the selected item.
+                HandleItemSelected(currentGroupedBeatmap);
+            }
+            else if (currentGroupedBeatmap != null)
+            {
+                // If the group no longer exists, grab an arbitrary other instance of the beatmap under the first group encountered.
+                var newSelection = GetCarouselItems()?.Select(i => i.Model).OfType<GroupedBeatmap>().FirstOrDefault(gb => gb.Beatmap.Equals(currentGroupedBeatmap.Beatmap));
+                // Only change the selection if we actually got a positive hit.
+                // This is necessary so that selection isn't lost if the panel reappears later due to e.g. unapplying some filter criteria that made it disappear in the first place.
+                if (newSelection != null)
+                    CurrentSelection = newSelection;
+            }
 
             // If a group was selected that is not the one containing the selection, attempt to reselect it.
             // If the original group was not found, ExpandedGroup will already have been updated to a valid value in `HandleItemSelected` above.
@@ -299,12 +492,12 @@ namespace osu.Game.Screens.SelectV2
                 setExpandedGroup(groupForReselection);
         }
 
-        private void selectRecommendedDifficultyForBeatmapSet(BeatmapSetInfo beatmapSet)
+        private void selectRecommendedDifficultyForBeatmapSet(GroupedBeatmapSet set)
         {
             // Selecting a set isn't valid – let's re-select the first visible difficulty.
-            if (grouping.SetItems.TryGetValue(beatmapSet, out var items))
+            if (grouping.SetItems.TryGetValue(set, out var items))
             {
-                var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+                var beatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>();
                 RequestRecommendedSelection(beatmaps);
             }
         }
@@ -322,8 +515,10 @@ namespace osu.Game.Screens.SelectV2
 
             foreach (var item in items)
             {
-                if (item.Model is BeatmapInfo beatmapInfo)
+                if (item.Model is GroupedBeatmap groupedBeatmap)
                 {
+                    var beatmapInfo = groupedBeatmap.Beatmap;
+
                     if (beatmapSetInfo == null)
                     {
                         beatmapSetInfo = beatmapInfo.BeatmapSet!;
@@ -336,9 +531,9 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+            var beatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>();
 
-            if (beatmaps.Any(b => b.Equals(CurrentSelection as BeatmapInfo)))
+            if (beatmaps.Any(b => b.Equals(CurrentSelection as GroupedBeatmap)))
                 return;
 
             RequestRecommendedSelection(beatmaps);
@@ -350,10 +545,10 @@ namespace osu.Game.Screens.SelectV2
         {
             switch (item.Model)
             {
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                     return true;
 
-                case BeatmapInfo:
+                case GroupedBeatmap:
                     return !grouping.BeatmapSetsGroupedTogether;
 
                 case GroupDefinition:
@@ -364,7 +559,7 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private void setExpandedGroup(GroupDefinition group)
+        private void setExpandedGroup(GroupDefinition? group)
         {
             if (ExpandedGroup != null)
                 setExpansionStateOfGroup(ExpandedGroup, false);
@@ -372,7 +567,7 @@ namespace osu.Game.Screens.SelectV2
             ExpandedGroup = group;
 
             if (ExpandedGroup != null)
-                setExpansionStateOfGroup(group, true);
+                setExpansionStateOfGroup(ExpandedGroup, true);
         }
 
         private void setExpansionStateOfGroup(GroupDefinition group, bool expanded)
@@ -389,11 +584,11 @@ namespace osu.Game.Screens.SelectV2
                                 i.IsExpanded = true;
                                 break;
 
-                            case BeatmapSetInfo set:
+                            case GroupedBeatmapSet groupedSet:
                                 // Case where there are set headers, header should be visible
                                 // and items should use the set's expanded state.
                                 i.IsVisible = true;
-                                setExpansionStateOfSetItems(set, i.IsExpanded);
+                                setExpansionStateOfSetItems(groupedSet, i.IsExpanded);
                                 break;
 
                             default:
@@ -423,21 +618,21 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private void setExpandedSet(BeatmapInfo beatmapInfo)
+        private void setExpandedSet(GroupedBeatmapSet set)
         {
             if (ExpandedBeatmapSet != null)
                 setExpansionStateOfSetItems(ExpandedBeatmapSet, false);
-            ExpandedBeatmapSet = beatmapInfo.BeatmapSet!;
+            ExpandedBeatmapSet = set;
             setExpansionStateOfSetItems(ExpandedBeatmapSet, true);
         }
 
-        private void setExpansionStateOfSetItems(BeatmapSetInfo set, bool expanded)
+        private void setExpansionStateOfSetItems(GroupedBeatmapSet set, bool expanded)
         {
             if (grouping.SetItems.TryGetValue(set, out var items))
             {
                 foreach (var i in items)
                 {
-                    if (i.Model is BeatmapSetInfo)
+                    if (i.Model is GroupedBeatmapSet)
                         i.IsExpanded = expanded;
                     else
                         i.IsVisible = expanded;
@@ -475,11 +670,11 @@ namespace osu.Game.Screens.SelectV2
                         sampleToggleGroup?.Play();
                         return;
 
-                    case BeatmapSetInfo:
+                    case GroupedBeatmapSet:
                         sampleChangeSet?.Play();
                         return;
 
-                    case BeatmapInfo:
+                    case GroupedBeatmap:
                         sampleChangeDifficulty?.Play();
                         return;
                 }
@@ -554,6 +749,37 @@ namespace osu.Game.Screens.SelectV2
 
         #endregion
 
+        #region Database fetches for grouping support
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        protected virtual List<BeatmapCollection> GetAllCollections() => realm.Run(r => r.All<BeatmapCollection>().AsEnumerable().Detach());
+
+        protected virtual Dictionary<Guid, ScoreRank> GetBeatmapInfoGuidToTopRankMapping(FilterCriteria criteria) => realm.Run(r =>
+        {
+            var topRankMapping = new Dictionary<Guid, ScoreRank>();
+
+            var allLocalScores = r.GetAllLocalScoresForUser(criteria.LocalUserId)
+                                  .Filter($@"{nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $0", criteria.Ruleset?.ShortName)
+                                  .OrderByDescending(s => s.TotalScore)
+                                  .ThenBy(s => s.Date);
+
+            foreach (var score in allLocalScores)
+            {
+                Debug.Assert(score.BeatmapInfo != null);
+
+                if (topRankMapping.ContainsKey(score.BeatmapInfo.ID))
+                    continue;
+
+                topRankMapping[score.BeatmapInfo.ID] = score.Rank;
+            }
+
+            return topRankMapping;
+        });
+
+        #endregion
+
         #region Drawable pooling
 
         private readonly DrawablePool<PanelBeatmap> beatmapPanelPool = new DrawablePool<PanelBeatmap>(100);
@@ -580,11 +806,11 @@ namespace osu.Game.Screens.SelectV2
             // it is doing a Replace operation on the list. If it is, then check the local handling in beatmapSetsChanged
             // before changing matching requirements here.
 
-            if (x is BeatmapSetInfo beatmapSetX && y is BeatmapSetInfo beatmapSetY)
-                return beatmapSetX.Equals(beatmapSetY);
+            if (x is GroupedBeatmapSet groupedSetX && y is GroupedBeatmapSet groupedSetY)
+                return groupedSetX.Equals(groupedSetY);
 
-            if (x is BeatmapInfo beatmapX && y is BeatmapInfo beatmapY)
-                return beatmapX.Equals(beatmapY);
+            if (x is GroupedBeatmap groupedBeatmapX && y is GroupedBeatmap groupedBeatmapY)
+                return groupedBeatmapX.Equals(groupedBeatmapY);
 
             if (x is GroupDefinition groupX && y is GroupDefinition groupY)
                 return groupX.Equals(groupY);
@@ -605,13 +831,13 @@ namespace osu.Game.Screens.SelectV2
                 case GroupDefinition:
                     return groupPanelPool.Get();
 
-                case BeatmapInfo:
+                case GroupedBeatmap:
                     if (!grouping.BeatmapSetsGroupedTogether)
                         return standalonePanelPool.Get();
 
                     return beatmapPanelPool.Get();
 
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                     return setPanelPool.Get();
             }
 
@@ -623,8 +849,8 @@ namespace osu.Game.Screens.SelectV2
         #region Random selection handling
 
         private readonly Bindable<RandomSelectAlgorithm> randomAlgorithm = new Bindable<RandomSelectAlgorithm>();
-        private readonly List<BeatmapInfo> previouslyVisitedRandomBeatmaps = new List<BeatmapInfo>();
-        private readonly List<BeatmapInfo> randomHistory = new List<BeatmapInfo>();
+        private readonly HashSet<BeatmapInfo> previouslyVisitedRandomBeatmaps = new HashSet<BeatmapInfo>();
+        private readonly List<GroupedBeatmap> randomHistory = new List<GroupedBeatmap>();
 
         private Sample? spinSample;
         private Sample? randomSelectSample;
@@ -637,7 +863,7 @@ namespace osu.Game.Screens.SelectV2
                 return false;
 
             var selectionBefore = CurrentSelectionItem;
-            var beatmapBefore = selectionBefore?.Model as BeatmapInfo;
+            var beatmapBefore = selectionBefore?.Model as GroupedBeatmap;
 
             bool success;
 
@@ -647,7 +873,7 @@ namespace osu.Game.Screens.SelectV2
                 randomHistory.Add(beatmapBefore);
                 // keep track of visited beatmaps for "RandomPermutation" random tracking.
                 // note that this is reset when we run out of beatmaps, while `randomHistory` is not.
-                previouslyVisitedRandomBeatmaps.Add(beatmapBefore);
+                previouslyVisitedRandomBeatmaps.Add(beatmapBefore.Beatmap);
             }
 
             if (grouping.BeatmapSetsGroupedTogether)
@@ -675,29 +901,29 @@ namespace osu.Game.Screens.SelectV2
 
         private bool nextRandomBeatmap()
         {
-            ICollection<BeatmapInfo> visibleBeatmaps = ExpandedGroup != null
+            ICollection<GroupedBeatmap> visibleBeatmaps = ExpandedGroup != null
                 // In the case of grouping, users expect random to only operate on the expanded group.
                 // This is going to incur some overhead as we don't have a group-beatmapset mapping currently.
                 //
                 // If this becomes an issue, we could either store a mapping, or run the random algorithm many times
                 // using the `SetItems` method until we get a group HIT.
-                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<BeatmapInfo>().ToArray()
-                : GetCarouselItems()!.Select(i => i.Model).OfType<BeatmapInfo>().ToArray();
+                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<GroupedBeatmap>().ToArray()
+                : GetCarouselItems()!.Select(i => i.Model).OfType<GroupedBeatmap>().ToArray();
 
-            BeatmapInfo beatmap;
+            GroupedBeatmap beatmap;
 
             switch (randomAlgorithm.Value)
             {
                 case RandomSelectAlgorithm.RandomPermutation:
                 {
-                    ICollection<BeatmapInfo> notYetVisitedBeatmaps = visibleBeatmaps.Except(previouslyVisitedRandomBeatmaps).ToList();
+                    ICollection<GroupedBeatmap> notYetVisitedBeatmaps = visibleBeatmaps.ExceptBy(previouslyVisitedRandomBeatmaps, gb => gb.Beatmap).ToList();
 
                     if (!notYetVisitedBeatmaps.Any())
                     {
-                        previouslyVisitedRandomBeatmaps.RemoveAll(b => visibleBeatmaps.Contains(b));
+                        previouslyVisitedRandomBeatmaps.ExceptWith(visibleBeatmaps.Select(b => b.Beatmap));
                         notYetVisitedBeatmaps = visibleBeatmaps;
-                        if (CurrentSelection is BeatmapInfo beatmapInfo)
-                            notYetVisitedBeatmaps = notYetVisitedBeatmaps.Except([beatmapInfo]).ToList();
+                        if (CurrentSelection is GroupedBeatmap groupedBeatmap)
+                            notYetVisitedBeatmaps = notYetVisitedBeatmaps.Except([groupedBeatmap]).ToList();
                     }
 
                     if (notYetVisitedBeatmaps.Count == 0)
@@ -721,30 +947,31 @@ namespace osu.Game.Screens.SelectV2
 
         private bool nextRandomSet()
         {
-            ICollection<BeatmapSetInfo> visibleSets = ExpandedGroup != null
+            ICollection<GroupedBeatmapSet> visibleGroupedSets = ExpandedGroup != null
                 // In the case of grouping, users expect random to only operate on the expanded group.
                 // This is going to incur some overhead as we don't have a group-beatmapset mapping currently.
                 //
                 // If this becomes an issue, we could either store a mapping, or run the random algorithm many times
                 // using the `SetItems` method until we get a group HIT.
-                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<BeatmapSetInfo>().ToArray()
+                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<GroupedBeatmapSet>().ToArray()
                 // This is the fastest way to retrieve sets for randomisation.
                 : grouping.SetItems.Keys;
 
-            BeatmapSetInfo set;
+            GroupedBeatmapSet set;
 
             switch (randomAlgorithm.Value)
             {
                 case RandomSelectAlgorithm.RandomPermutation:
                 {
-                    ICollection<BeatmapSetInfo> notYetVisitedSets = visibleSets.Except(previouslyVisitedRandomBeatmaps.Select(b => b.BeatmapSet!)).ToList();
+                    ICollection<GroupedBeatmapSet> notYetVisitedSets =
+                        visibleGroupedSets.ExceptBy(previouslyVisitedRandomBeatmaps.Select(b => b.BeatmapSet!), groupedSet => groupedSet.BeatmapSet).ToList();
 
                     if (!notYetVisitedSets.Any())
                     {
-                        previouslyVisitedRandomBeatmaps.RemoveAll(b => visibleSets.Contains(b.BeatmapSet!));
-                        notYetVisitedSets = visibleSets;
-                        if (CurrentSelection is BeatmapInfo beatmapInfo)
-                            notYetVisitedSets = notYetVisitedSets.Except([beatmapInfo.BeatmapSet!]).ToList();
+                        previouslyVisitedRandomBeatmaps.ExceptWith(visibleGroupedSets.SelectMany(setUnderGrouping => setUnderGrouping.BeatmapSet.Beatmaps));
+                        notYetVisitedSets = visibleGroupedSets;
+                        if (CurrentSelection is GroupedBeatmap groupedBeatmap)
+                            notYetVisitedSets = notYetVisitedSets.ExceptBy([groupedBeatmap.Beatmap.BeatmapSet!], groupedSet => groupedSet.BeatmapSet).ToList();
                     }
 
                     if (notYetVisitedSets.Count == 0)
@@ -755,7 +982,7 @@ namespace osu.Game.Screens.SelectV2
                 }
 
                 case RandomSelectAlgorithm.Random:
-                    set = visibleSets.ElementAt(RNG.Next(visibleSets.Count));
+                    set = visibleGroupedSets.ElementAt(RNG.Next(visibleGroupedSets.Count));
                     break;
 
                 default:
@@ -778,15 +1005,19 @@ namespace osu.Game.Screens.SelectV2
                 var previousBeatmap = randomHistory[^1];
                 randomHistory.RemoveAt(randomHistory.Count - 1);
 
-                var previousBeatmapItem = carouselItems.FirstOrDefault(i => i.Model is BeatmapInfo b && b.Equals(previousBeatmap));
+                // when going back through rewind history, we may no longer be in the same grouping mode.
+                // the user wants to go back to the beatmap first and foremost, so the most important thing is to find a panel that corresponds to the beatmap.
+                // going back to the same group is a nice-to-have, but a secondary concern.
+                var previousBeatmapItem = carouselItems.Where(i => i.Model is GroupedBeatmap gb && gb.Beatmap.Equals(previousBeatmap.Beatmap))
+                                                       .MaxBy(i => ((GroupedBeatmap)i.Model).Group == previousBeatmap.Group);
 
                 if (previousBeatmapItem == null)
                     return false;
 
-                if (CurrentSelection is BeatmapInfo beatmapInfo)
+                if (CurrentSelection is GroupedBeatmap groupedBeatmap)
                 {
                     if (randomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
-                        previouslyVisitedRandomBeatmaps.Remove(beatmapInfo);
+                        previouslyVisitedRandomBeatmaps.Remove(groupedBeatmap.Beatmap);
 
                     if (CurrentSelectionItem == null)
                         playSpinSample(0);
@@ -794,7 +1025,7 @@ namespace osu.Game.Screens.SelectV2
                         playSpinSample(visiblePanelCountBetweenItems(previousBeatmapItem, CurrentSelectionItem));
                 }
 
-                RequestSelection(previousBeatmap);
+                RequestSelection((GroupedBeatmap)previousBeatmapItem.Model);
                 return true;
             }
 
@@ -852,4 +1083,17 @@ namespace osu.Game.Screens.SelectV2
     /// Defines a grouping header for a set of carousel items grouped by star difficulty.
     /// </summary>
     public record StarDifficultyGroupDefinition(int Order, string Title, StarDifficulty Difficulty) : GroupDefinition(Order, Title);
+
+    /// <summary>
+    /// Used to represent a portion of a <see cref="BeatmapSetInfo"/> under a <see cref="GroupDefinition"/>.
+    /// The purpose of this model is to support splitting beatmap sets apart when the active grouping mode demands it.
+    /// </summary>
+    public record GroupedBeatmapSet([UsedImplicitly] GroupDefinition? Group, BeatmapSetInfo BeatmapSet);
+
+    /// <summary>
+    /// Used to represent a <see cref="Beatmap"/> under a <see cref="GroupDefinition"/>.
+    /// The purpose of this model is to support showing multiple copies of a beatmap, which can occur if a beatmap appears in multiple groups
+    /// (most prominently, collections group mode).
+    /// </summary>
+    public record GroupedBeatmap(GroupDefinition? Group, BeatmapInfo Beatmap);
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
index eb55e03d6b..69f5596578 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
@@ -7,10 +7,14 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 using osu.Game.Graphics.Carousel;
+using osu.Game.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -18,32 +22,43 @@ namespace osu.Game.Screens.SelectV2
     {
         public bool BeatmapSetsGroupedTogether { get; private set; }
 
+        /// <summary>
+        /// The total number of beatmap difficulties displayed post filter.
+        /// </summary>
+        public int BeatmapItemsCount { get; private set; }
+
         /// <summary>
         /// Beatmap sets contain difficulties as related panels. This dictionary holds the relationships between set-difficulties to allow expanding them on selection.
         /// </summary>
-        public IDictionary<BeatmapSetInfo, HashSet<CarouselItem>> SetItems => setMap;
+        public IDictionary<GroupedBeatmapSet, HashSet<CarouselItem>> SetItems => setMap;
 
         /// <summary>
         /// Groups contain children which are group-selectable. This dictionary holds the relationships between groups-panels to allow expanding them on selection.
         /// </summary>
         public IDictionary<GroupDefinition, HashSet<CarouselItem>> GroupItems => groupMap;
 
-        private readonly Dictionary<BeatmapSetInfo, HashSet<CarouselItem>> setMap = new Dictionary<BeatmapSetInfo, HashSet<CarouselItem>>();
-        private readonly Dictionary<GroupDefinition, HashSet<CarouselItem>> groupMap = new Dictionary<GroupDefinition, HashSet<CarouselItem>>();
+        private Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>> setMap = new Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>>();
+        private Dictionary<GroupDefinition, HashSet<CarouselItem>> groupMap = new Dictionary<GroupDefinition, HashSet<CarouselItem>>();
 
         private readonly Func<FilterCriteria> getCriteria;
+        private readonly Func<List<BeatmapCollection>> getCollections;
+        private readonly Func<FilterCriteria, IReadOnlyDictionary<Guid, ScoreRank>> getLocalUserTopRanks;
 
-        public BeatmapCarouselFilterGrouping(Func<FilterCriteria> getCriteria)
+        public BeatmapCarouselFilterGrouping(Func<FilterCriteria> getCriteria, Func<List<BeatmapCollection>> getCollections,
+                                             Func<FilterCriteria, IReadOnlyDictionary<Guid, ScoreRank>> getLocalUserTopRanks)
         {
             this.getCriteria = getCriteria;
+            this.getCollections = getCollections;
+            this.getLocalUserTopRanks = getLocalUserTopRanks;
         }
 
         public async Task<List<CarouselItem>> Run(IEnumerable<CarouselItem> items, CancellationToken cancellationToken)
         {
             return await Task.Run(() =>
             {
-                setMap.Clear();
-                groupMap.Clear();
+                // preallocate space for the new mappings using last known estimates
+                var newSetMap = new Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>>(setMap.Count);
+                var newGroupMap = new Dictionary<GroupDefinition, HashSet<CarouselItem>>(groupMap.Count);
 
                 var criteria = getCriteria();
                 var newItems = new List<CarouselItem>();
@@ -51,6 +66,7 @@ namespace osu.Game.Screens.SelectV2
                 BeatmapSetsGroupedTogether = ShouldGroupBeatmapsTogether(criteria);
 
                 var groups = getGroups((List<CarouselItem>)items, criteria);
+                int displayedBeatmapsCount = 0;
 
                 foreach (var (group, itemsInGroup) in groups)
                 {
@@ -63,7 +79,7 @@ namespace osu.Game.Screens.SelectV2
 
                     if (group != null)
                     {
-                        groupMap[group] = currentGroupItems = new HashSet<CarouselItem>();
+                        newGroupMap[group] = currentGroupItems = new HashSet<CarouselItem>();
 
                         addItem(groupItem = new CarouselItem(group)
                         {
@@ -74,14 +90,17 @@ namespace osu.Game.Screens.SelectV2
 
                     foreach (var item in itemsInGroup)
                     {
+                        cancellationToken.ThrowIfCancellationRequested();
+
                         var beatmap = (BeatmapInfo)item.Model;
 
                         bool newBeatmapSet = lastBeatmap?.BeatmapSet!.ID != beatmap.BeatmapSet!.ID;
+                        var groupedBeatmapSet = new GroupedBeatmapSet(group, beatmap.BeatmapSet!);
 
                         if (newBeatmapSet)
                         {
-                            if (!setMap.TryGetValue(beatmap.BeatmapSet!, out currentSetItems))
-                                setMap[beatmap.BeatmapSet!] = currentSetItems = new HashSet<CarouselItem>();
+                            if (!newSetMap.TryGetValue(groupedBeatmapSet, out currentSetItems))
+                                newSetMap[groupedBeatmapSet] = currentSetItems = new HashSet<CarouselItem>();
                         }
 
                         if (BeatmapSetsGroupedTogether)
@@ -91,7 +110,7 @@ namespace osu.Game.Screens.SelectV2
                                 if (groupItem != null)
                                     groupItem.NestedItemCount++;
 
-                                addItem(new CarouselItem(beatmap.BeatmapSet!)
+                                addItem(new CarouselItem(groupedBeatmapSet)
                                 {
                                     DrawHeight = PanelBeatmapSet.HEIGHT,
                                     DepthLayer = -1
@@ -102,12 +121,14 @@ namespace osu.Game.Screens.SelectV2
                         {
                             if (groupItem != null)
                                 groupItem.NestedItemCount++;
-
-                            item.DrawHeight = PanelBeatmapStandalone.HEIGHT;
                         }
 
-                        addItem(item);
+                        addItem(new CarouselItem(new GroupedBeatmap(group, beatmap))
+                        {
+                            DrawHeight = BeatmapSetsGroupedTogether ? PanelBeatmap.HEIGHT : PanelBeatmapStandalone.HEIGHT,
+                        });
                         lastBeatmap = beatmap;
+                        displayedBeatmapsCount++;
                     }
 
                     void addItem(CarouselItem i)
@@ -117,10 +138,15 @@ namespace osu.Game.Screens.SelectV2
                         currentGroupItems?.Add(i);
                         currentSetItems?.Add(i);
 
-                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is BeatmapSetInfo || !BeatmapSetsGroupedTogether));
+                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is GroupedBeatmapSet || !BeatmapSetsGroupedTogether));
                     }
                 }
 
+                cancellationToken.ThrowIfCancellationRequested();
+
+                Interlocked.Exchange(ref setMap, newSetMap);
+                Interlocked.Exchange(ref groupMap, newGroupMap);
+                BeatmapItemsCount = displayedBeatmapsCount;
                 return newItems;
             }, cancellationToken).ConfigureAwait(false);
         }
@@ -133,6 +159,8 @@ namespace osu.Game.Screens.SelectV2
                 return false;
             if (criteria.Sort == SortMode.LastPlayed && criteria.Group == GroupMode.LastPlayed)
                 return false;
+            if (criteria.Group == GroupMode.RankAchieved)
+                return false;
 
             // In the majority case we group sets together for display.
             return true;
@@ -165,11 +193,8 @@ namespace osu.Game.Screens.SelectV2
                     {
                         var date = b.LastPlayed;
 
-                        if (BeatmapSetsGroupedTogether)
-                            date = aggregateMax(b, static b => (b.LastPlayed ?? DateTimeOffset.MinValue));
-
                         if (date == null || date == DateTimeOffset.MinValue)
-                            return new GroupDefinition(int.MaxValue, "Never");
+                            return new GroupDefinition(int.MaxValue, "Never").Yield();
 
                         return defineGroupByDate(date.Value);
                     }, items);
@@ -178,199 +203,239 @@ namespace osu.Game.Screens.SelectV2
                     return getGroupsBy(b => defineGroupByStatus(b.BeatmapSet!.Status), items);
 
                 case GroupMode.BPM:
-                    return getGroupsBy(b =>
-                    {
-                        double bpm = b.BPM;
-
-                        if (BeatmapSetsGroupedTogether)
-                            bpm = aggregateMax(b, bb => bb.BPM);
-
-                        return defineGroupByBPM(bpm);
-                    }, items);
+                    return getGroupsBy(b => defineGroupByBPM(FormatUtils.RoundBPM(b.BPM)), items);
 
                 case GroupMode.Difficulty:
                     return getGroupsBy(b => defineGroupByStars(b.StarRating), items);
 
                 case GroupMode.Length:
-                    return getGroupsBy(b =>
-                    {
-                        double length = b.Length;
-
-                        if (BeatmapSetsGroupedTogether)
-                            length = aggregateMax(b, bb => bb.Length);
-
-                        return defineGroupByLength(length);
-                    }, items);
+                    return getGroupsBy(b => defineGroupByLength(b.Length), items);
 
                 case GroupMode.Source:
                     return getGroupsBy(b => defineGroupBySource(b.BeatmapSet!.Metadata.Source), items);
 
+                case GroupMode.Collections:
+                {
+                    var collections = getCollections();
+                    return getGroupsBy(b => defineGroupByCollection(b, collections), items);
+                }
+
+                case GroupMode.MyMaps:
+                    return getGroupsBy(b => defineGroupByOwnMaps(b, criteria.LocalUserId, criteria.LocalUserUsername), items);
+
+                case GroupMode.RankAchieved:
+                {
+                    var topRankMapping = getLocalUserTopRanks(criteria);
+                    return getGroupsBy(b => defineGroupByRankAchieved(b, topRankMapping), items);
+                }
+
                 // TODO: need implementation
-                //
-                // case GroupMode.Collections:
-                //     goto case GroupMode.None;
-                //
                 // case GroupMode.Favourites:
                 //     goto case GroupMode.None;
-                //
-                // case GroupMode.MyMaps:
-                //     goto case GroupMode.None;
-                //
-                // case GroupMode.RankAchieved:
-                //     goto case GroupMode.None;
 
                 default:
                     throw new ArgumentOutOfRangeException();
             }
         }
 
-        private List<GroupMapping> getGroupsBy(Func<BeatmapInfo, GroupDefinition> getGroup, List<CarouselItem> items)
+        private List<GroupMapping> getGroupsBy(Func<BeatmapInfo, IEnumerable<GroupDefinition>> defineGroups, List<CarouselItem> items)
         {
-            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();
+            var groups = new Dictionary<GroupDefinition, GroupMapping>();
+
+            foreach (var item in items)
+            {
+                foreach (var groupDefinition in defineGroups((BeatmapInfo)item.Model))
+                {
+                    if (!groups.TryGetValue(groupDefinition, out var group))
+                        group = groups[groupDefinition] = new GroupMapping(groupDefinition, []);
+
+                    group.ItemsInGroup.Add(item);
+                }
+            }
+
+            return groups.Values
+                         .OrderBy(g => g.Group!.Order)
+                         .ThenBy(g => g.Group!.Title)
+                         .ToList();
         }
 
-        private GroupDefinition defineGroupAlphabetically(string name)
+        private IEnumerable<GroupDefinition> defineGroupAlphabetically(string name)
         {
             char firstChar = name.FirstOrDefault();
 
             if (char.IsAsciiDigit(firstChar))
-                return new GroupDefinition(int.MinValue, "0-9");
+                return new GroupDefinition(int.MinValue, "0-9").Yield();
 
             if (char.IsAsciiLetter(firstChar))
-                return new GroupDefinition(char.ToUpperInvariant(firstChar) - 'A', char.ToUpperInvariant(firstChar).ToString());
+                return new GroupDefinition(char.ToUpperInvariant(firstChar) - 'A', char.ToUpperInvariant(firstChar).ToString()).Yield();
 
-            return new GroupDefinition(int.MaxValue, "Other");
+            return new GroupDefinition(int.MaxValue, "Other").Yield();
         }
 
-        private GroupDefinition defineGroupByDate(DateTimeOffset date)
+        private IEnumerable<GroupDefinition> defineGroupByDate(DateTimeOffset date)
         {
             var now = DateTimeOffset.Now;
             var elapsed = now - date;
 
             if (elapsed.TotalDays < 1)
-                return new GroupDefinition(0, "Today");
+                return new GroupDefinition(0, "Today").Yield();
 
             if (elapsed.TotalDays < 2)
-                return new GroupDefinition(1, "Yesterday");
+                return new GroupDefinition(1, "Yesterday").Yield();
 
             if (elapsed.TotalDays < 7)
-                return new GroupDefinition(2, "Last week");
+                return new GroupDefinition(2, "Last week").Yield();
 
             if (elapsed.TotalDays < 30)
-                return new GroupDefinition(3, "1 month ago");
+                return new GroupDefinition(3, "Last month").Yield();
 
-            for (int i = 60; i <= 150; i += 30)
+            if (elapsed.TotalDays < 60)
+                return new GroupDefinition(4, "1 month ago").Yield();
+
+            for (int i = 90; i <= 150; i += 30)
             {
                 if (elapsed.TotalDays < i)
-                    return new GroupDefinition(i, $"{i / 30} months ago");
+                    return new GroupDefinition(i, $"{i / 30 - 1} months ago").Yield();
             }
 
-            return new GroupDefinition(151, "Over 5 months ago");
+            return new GroupDefinition(151, "Over 5 months ago").Yield();
         }
 
-        private GroupDefinition defineGroupByRankedDate(DateTimeOffset? date)
+        private IEnumerable<GroupDefinition> defineGroupByRankedDate(DateTimeOffset? date)
         {
             if (date == null)
-                return new GroupDefinition(0, "Unranked");
+                return new GroupDefinition(0, "Unranked").Yield();
 
-            return new GroupDefinition(-date.Value.Year, $"{date.Value.Year}");
+            return new GroupDefinition(-date.Value.Year, $"{date.Value.Year}").Yield();
         }
 
-        private GroupDefinition defineGroupByStatus(BeatmapOnlineStatus status)
+        private IEnumerable<GroupDefinition> defineGroupByStatus(BeatmapOnlineStatus status)
         {
             switch (status)
             {
                 case BeatmapOnlineStatus.Ranked:
                 case BeatmapOnlineStatus.Approved:
-                    return new GroupDefinition(0, BeatmapOnlineStatus.Ranked.GetDescription());
+                    return new GroupDefinition(0, BeatmapOnlineStatus.Ranked.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Qualified:
-                    return new GroupDefinition(1, status.GetDescription());
+                    return new GroupDefinition(1, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.WIP:
-                    return new GroupDefinition(2, status.GetDescription());
+                    return new GroupDefinition(2, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Pending:
-                    return new GroupDefinition(3, status.GetDescription());
+                    return new GroupDefinition(3, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Graveyard:
-                    return new GroupDefinition(4, status.GetDescription());
+                    return new GroupDefinition(4, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.LocallyModified:
-                    return new GroupDefinition(5, status.GetDescription());
+                    return new GroupDefinition(5, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.None:
-                    return new GroupDefinition(6, status.GetDescription());
+                    return new GroupDefinition(6, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Loved:
-                    return new GroupDefinition(7, status.GetDescription());
+                    return new GroupDefinition(7, status.GetDescription()).Yield();
 
                 default:
                     throw new ArgumentOutOfRangeException(nameof(status), status, null);
             }
         }
 
-        private GroupDefinition defineGroupByBPM(double bpm)
+        private IEnumerable<GroupDefinition> defineGroupByBPM(double bpm)
         {
-            for (int i = 1; i < 6; i++)
+            if (bpm < 60)
+                return new GroupDefinition(60, "Under 60 BPM").Yield();
+
+            for (int i = 70; i <= 300; i += 10)
             {
-                if (bpm < i * 60)
-                    return new GroupDefinition(i, $"Under {i * 60} BPM");
+                if (bpm < i)
+                    return new GroupDefinition(i, $"{i - 10} - {i} BPM").Yield();
             }
 
-            return new GroupDefinition(6, "Over 300 BPM");
+            return new GroupDefinition(301, "Over 300 BPM").Yield();
         }
 
-        private GroupDefinition defineGroupByStars(double stars)
+        private IEnumerable<GroupDefinition> defineGroupByStars(double stars)
         {
             // truncation is intentional - compare `FormatUtils.FormatStarRating()`
             int starInt = (int)stars;
             var starDifficulty = new StarDifficulty(starInt, 0);
 
             if (starInt == 0)
-                return new StarDifficultyGroupDefinition(0, "Below 1 Star", starDifficulty);
+                return new StarDifficultyGroupDefinition(0, "Below 1 Star", starDifficulty).Yield();
 
             if (starInt == 1)
-                return new StarDifficultyGroupDefinition(1, "1 Star", starDifficulty);
+                return new StarDifficultyGroupDefinition(1, "1 Star", starDifficulty).Yield();
 
-            return new StarDifficultyGroupDefinition(starInt, $"{starInt} Stars", starDifficulty);
+            return new StarDifficultyGroupDefinition(starInt, $"{starInt} Stars", starDifficulty).Yield();
         }
 
-        private GroupDefinition defineGroupByLength(double length)
+        private IEnumerable<GroupDefinition> defineGroupByLength(double length)
         {
             for (int i = 1; i < 6; i++)
             {
                 if (length <= i * 60_000)
                 {
                     if (i == 1)
-                        return new GroupDefinition(1, "1 minute or less");
+                        return new GroupDefinition(1, "1 minute or less").Yield();
 
-                    return new GroupDefinition(i, $"{i} minutes or less");
+                    return new GroupDefinition(i, $"{i} minutes or less").Yield();
                 }
             }
 
             if (length <= 10 * 60_000)
-                return new GroupDefinition(10, "10 minutes or less");
+                return new GroupDefinition(10, "10 minutes or less").Yield();
 
-            return new GroupDefinition(11, "Over 10 minutes");
+            return new GroupDefinition(11, "Over 10 minutes").Yield();
         }
 
-        private GroupDefinition defineGroupBySource(string source)
+        private IEnumerable<GroupDefinition> defineGroupBySource(string source)
         {
             if (string.IsNullOrEmpty(source))
-                return new GroupDefinition(1, "Unsourced");
+                return new GroupDefinition(1, "Unsourced").Yield();
 
-            return new GroupDefinition(0, source);
+            return new GroupDefinition(0, source).Yield();
         }
 
-        private static T? aggregateMax<T>(BeatmapInfo b, Func<BeatmapInfo, T> func)
+        private IEnumerable<GroupDefinition> defineGroupByCollection(BeatmapInfo beatmap, IEnumerable<BeatmapCollection> collections)
         {
-            var beatmaps = b.BeatmapSet!.Beatmaps.Where(bb => !bb.Hidden);
-            return beatmaps.Max(func);
+            bool anyCollections = false;
+
+            foreach (var collection in collections)
+            {
+                if (collection.BeatmapMD5Hashes.Contains(beatmap.MD5Hash))
+                {
+                    yield return new GroupDefinition(0, collection.Name);
+
+                    anyCollections = true;
+                }
+            }
+
+            if (anyCollections)
+                yield break;
+
+            yield return new GroupDefinition(1, "Not in collection");
+        }
+
+        private IEnumerable<GroupDefinition> defineGroupByOwnMaps(BeatmapInfo beatmap, int? localUserId, string? localUserUsername)
+        {
+            var author = beatmap.BeatmapSet!.Metadata.Author;
+
+            if (author.OnlineID == localUserId || (author.OnlineID <= 1 && author.Username == localUserUsername))
+                return new GroupDefinition(0, "My maps").Yield();
+
+            // discard beatmaps not owned by the user.
+            return [];
+        }
+
+        private IEnumerable<GroupDefinition> defineGroupByRankAchieved(BeatmapInfo beatmap, IReadOnlyDictionary<Guid, ScoreRank> topRankMapping)
+        {
+            if (topRankMapping.TryGetValue(beatmap.ID, out var rank))
+                return new GroupDefinition(-(int)rank, rank.GetDescription()).Yield();
+
+            return new GroupDefinition(int.MaxValue, "Unplayed").Yield();
         }
 
         private record GroupMapping(GroupDefinition? Group, List<CarouselItem> ItemsInGroup);
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
index f2f246093d..3eada92f9b 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
@@ -17,9 +17,6 @@ namespace osu.Game.Screens.SelectV2
     {
         private readonly Func<FilterCriteria> getCriteria;
 
-        /// <summary>
-        /// The total number of beatmap difficulties displayed post filter.
-        /// </summary>
         public int BeatmapItemsCount { get; private set; }
 
         public BeatmapCarouselFilterMatching(Func<FilterCriteria> getCriteria)
@@ -105,6 +102,20 @@ namespace osu.Game.Screens.SelectV2
                      criteria.Title.Matches(beatmap.Metadata.TitleUnicode);
             match &= !criteria.DifficultyName.HasFilter || criteria.DifficultyName.Matches(beatmap.DifficultyName);
             match &= !criteria.Source.HasFilter || criteria.Source.Matches(beatmap.Metadata.Source);
+
+            if (criteria.UserTags.Any())
+            {
+                foreach (var tagFilter in criteria.UserTags)
+                {
+                    bool anyTagMatched = false;
+
+                    foreach (string tag in beatmap.Metadata.UserTags)
+                        anyTagMatched |= tagFilter.Matches(tag);
+
+                    match &= anyTagMatched;
+                }
+            }
+
             match &= !criteria.UserStarDifficulty.HasFilter || criteria.UserStarDifficulty.IsInRange(beatmap.StarRating);
 
             if (!match) return false;
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
index 0ebfc084bd..e9d65f7108 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
@@ -16,6 +16,8 @@ namespace osu.Game.Screens.SelectV2
 {
     public class BeatmapCarouselFilterSorting : ICarouselFilter
     {
+        public int BeatmapItemsCount { get; private set; }
+
         private readonly Func<FilterCriteria> getCriteria;
 
         public BeatmapCarouselFilterSorting(Func<FilterCriteria> getCriteria)
@@ -29,6 +31,8 @@ namespace osu.Game.Screens.SelectV2
 
             bool groupedSets = BeatmapCarouselFilterGrouping.ShouldGroupBeatmapsTogether(criteria);
 
+            BeatmapItemsCount = items.Count();
+
             return items.Order(Comparer<CarouselItem>.Create((a, b) =>
             {
                 var ab = (BeatmapInfo)a.Model;
diff --git a/osu.Game/Screens/SelectV2/BeatmapDetailsArea.cs b/osu.Game/Screens/SelectV2/BeatmapDetailsArea.cs
index 99e3155a7a..7a2068b0cf 100644
--- a/osu.Game/Screens/SelectV2/BeatmapDetailsArea.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapDetailsArea.cs
@@ -87,6 +87,7 @@ namespace osu.Game.Screens.SelectV2
                     currentContent = new BeatmapLeaderboardWedge
                     {
                         Scope = { BindTarget = header.Scope },
+                        Sorting = { BindTarget = header.Sorting },
                         FilterBySelectedMods = { BindTarget = header.FilterBySelectedMods },
                     };
 
@@ -96,5 +97,11 @@ namespace osu.Game.Screens.SelectV2
             contentContainer.Add(currentContent);
             currentContent.Show();
         }
+
+        public void Refresh()
+        {
+            if (currentContent is BeatmapLeaderboardWedge leaderboardWedge)
+                leaderboardWedge.RefetchScores();
+        }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs b/osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs
index 76734e110f..f4a223985d 100644
--- a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs
@@ -4,12 +4,14 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Leaderboards;
 using osuTK;
@@ -24,6 +26,7 @@ namespace osu.Game.Screens.SelectV2
             private FillFlowContainer leaderboardControls = null!;
 
             private ShearedDropdown<BeatmapLeaderboardScope> scopeDropdown = null!;
+            private ShearedDropdown<LeaderboardSortMode> sortDropdown = null!;
             private ShearedToggleButton selectedModsToggle = null!;
 
             public IBindable<Selection> Type => tabControl.Current;
@@ -32,6 +35,10 @@ namespace osu.Game.Screens.SelectV2
 
             private readonly Bindable<BeatmapDetailTab> configDetailTab = new Bindable<BeatmapDetailTab>();
 
+            public IBindable<LeaderboardSortMode> Sorting => sortDropdown.Current;
+
+            private readonly Bindable<LeaderboardSortMode> configLeaderboardSortMode = new Bindable<LeaderboardSortMode>();
+
             public IBindable<bool> FilterBySelectedMods => selectedModsToggle.Active;
 
             [BackgroundDependencyLoader]
@@ -42,7 +49,7 @@ namespace osu.Game.Screens.SelectV2
                     new Container
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Left = SongSelect.WEDGE_CONTENT_MARGIN, Right = 20f },
+                        Padding = new MarginPadding { Left = SongSelect.WEDGE_CONTENT_MARGIN, Right = 5f },
                         Children = new Drawable[]
                         {
                             tabControl = new WedgeSelector<Selection>(20f)
@@ -58,44 +65,37 @@ namespace osu.Game.Screens.SelectV2
                             {
                                 Anchor = Anchor.CentreRight,
                                 Origin = Anchor.CentreRight,
-                                AutoSizeAxes = Axes.Both,
+                                RelativeSizeAxes = Axes.X,
+                                Height = 30,
                                 Spacing = new Vector2(5f, 0f),
+                                Direction = FillDirection.Horizontal,
+                                Padding = new MarginPadding { Left = 258 },
                                 Children = new Drawable[]
                                 {
-                                    new Container
+                                    selectedModsToggle = new ShearedToggleButton
                                     {
                                         Anchor = Anchor.CentreRight,
                                         Origin = Anchor.CentreRight,
-                                        Size = new Vector2(128f, 30f),
-                                        Child = selectedModsToggle = new ShearedToggleButton
-                                        {
-                                            Anchor = Anchor.Centre,
-                                            Origin = Anchor.Centre,
-                                            Text = @"Selected Mods",
-                                            Height = 30,
-                                        },
+                                        Text = UserInterfaceStrings.SelectedMods,
+                                        Height = 30f,
+                                        // Eyeballed to make spacing match. Because shear is silly and implemented in different ways between dropdown and button.
+                                        Margin = new MarginPadding { Left = -9.2f },
                                     },
-                                    // new Container
-                                    // {
-                                    //     Anchor = Anchor.CentreRight,
-                                    //     Origin = Anchor.CentreRight,
-                                    //     Size = new Vector2(150f, 33f),
-                                    //     Child = new ShearedDropdown<RankingsSort>(@"Sort")
-                                    //     {
-                                    //         Width = 150f,
-                                    //         Items = Enum.GetValues<RankingsSort>(),
-                                    //     },
-                                    // },
-                                    new Container
+                                    sortDropdown = new ShearedDropdown<LeaderboardSortMode>(BeatmapLeaderboardWedgeStrings.Sort)
                                     {
-                                        Anchor = Anchor.CentreRight,
-                                        Origin = Anchor.CentreRight,
-                                        Size = new Vector2(160f, 32f),
-                                        Child = scopeDropdown = new ScopeDropdown
-                                        {
-                                            Width = 160f,
-                                            Current = { Value = BeatmapLeaderboardScope.Global },
-                                        },
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        RelativeSizeAxes = Axes.X,
+                                        Width = 0.4f,
+                                        Items = Enum.GetValues<LeaderboardSortMode>(),
+                                    },
+                                    scopeDropdown = new ScopeDropdown
+                                    {
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        RelativeSizeAxes = Axes.X,
+                                        Width = 0.4f,
+                                        Current = { Value = BeatmapLeaderboardScope.Global },
                                     },
                                 },
                             },
@@ -104,6 +104,7 @@ namespace osu.Game.Screens.SelectV2
                 };
 
                 config.BindWith(OsuSetting.BeatmapDetailTab, configDetailTab);
+                config.BindWith(OsuSetting.BeatmapLeaderboardSortMode, configLeaderboardSortMode);
                 config.BindWith(OsuSetting.BeatmapDetailModsFilter, selectedModsToggle.Active);
             }
 
@@ -120,6 +121,23 @@ namespace osu.Game.Screens.SelectV2
                     leaderboardControls.FadeTo(v.NewValue == Selection.Ranking ? 1 : 0, 300, Easing.OutQuint);
                     updateConfigDetailTab();
                 }, true);
+
+                scopeDropdown.Current.BindValueChanged(scope =>
+                {
+                    sortDropdown.Current.Disabled = false;
+
+                    if (scope.NewValue == BeatmapLeaderboardScope.Local)
+                    {
+                        sortDropdown.Current.BindTo(configLeaderboardSortMode);
+                    }
+                    else
+                    {
+                        // future implementation when we have web-side support.
+                        sortDropdown.Current.UnbindFrom(configLeaderboardSortMode);
+                        sortDropdown.Current.Value = LeaderboardSortMode.Score;
+                        sortDropdown.Current.Disabled = true;
+                    }
+                }, true);
             }
 
             #region Reading / writing state from / to configuration
@@ -193,28 +211,22 @@ namespace osu.Game.Screens.SelectV2
 
             public enum Selection
             {
+                [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Details))]
                 Details,
+
+                [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.Ranking))]
                 Ranking,
             }
 
-            // public enum RankingsSort
-            // {
-            //     Score,
-            //     Accuracy,
-            //     Combo,
-            //     Misses,
-            //     Date,
-            // }
-
             private partial class ScopeDropdown : ShearedDropdown<BeatmapLeaderboardScope>
             {
                 public ScopeDropdown()
-                    : base("Scope")
+                    : base(BeatmapLeaderboardWedgeStrings.Scope)
                 {
                     Items = Enum.GetValues<BeatmapLeaderboardScope>();
                 }
 
-                protected override LocalisableString GenerateItemText(BeatmapLeaderboardScope item) => item.ToString();
+                protected override LocalisableString GenerateItemText(BeatmapLeaderboardScope item) => item.GetLocalisableDescription();
             }
         }
     }
diff --git a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs b/osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs
index 8d344d8be2..b5cdeee792 100644
--- a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs
@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
@@ -89,7 +90,7 @@ namespace osu.Game.Screens.SelectV2
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Text = value.ToString(),
+                            Text = value.GetLocalisableDescription(),
                             Font = OsuFont.Style.Body,
                         },
                         new HoverSounds(HoverSampleSet.TabSelect)
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
index be507e7b36..67f3075e0e 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
@@ -24,6 +24,7 @@ using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
@@ -621,7 +622,7 @@ namespace osu.Game.Screens.SelectV2
                 var copyableMods = Score.Mods.Where(m => IsValidMod.Invoke(m) && m.Type != ModType.System).ToArray();
 
                 if (copyableMods.Length > 0)
-                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => SelectedMods.Value = copyableMods));
+                    items.Add(new OsuMenuItem(SongSelectStrings.UseTheseMods, MenuItemType.Highlighted, () => SelectedMods.Value = copyableMods));
 
                 if (Score.OnlineID > 0)
                     items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => clipboard?.SetText($@"{api.Endpoints.WebsiteUrl}/scores/{Score.OnlineID}")));
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
index 11e1f281e5..d34c202640 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
@@ -7,6 +7,8 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.PolygonExtensions;
@@ -16,6 +18,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Threading;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
@@ -42,6 +45,8 @@ namespace osu.Game.Screens.SelectV2
 
         public IBindable<BeatmapLeaderboardScope> Scope { get; } = new Bindable<BeatmapLeaderboardScope>();
 
+        public IBindable<LeaderboardSortMode> Sorting { get; } = new Bindable<LeaderboardSortMode>();
+
         public IBindable<bool> FilterBySelectedMods { get; } = new BindableBool();
 
         [Resolved]
@@ -90,8 +95,12 @@ namespace osu.Game.Screens.SelectV2
 
         protected override bool OnMouseDown(MouseDownEvent e) => true;
 
+        private Sample? swishSample;
+
+        private readonly List<ScheduledDelegate> scoreSfxDelegates = new List<ScheduledDelegate>();
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio)
         {
             RelativeSizeAxes = Axes.Both;
 
@@ -140,27 +149,33 @@ namespace osu.Game.Screens.SelectV2
                         Children = new Drawable[]
                         {
                             new WedgeBackground(),
-                            new Container
+                            // Required because wedge background blocks input from passing through
+                            // to the main context menu container above.
+                            new OsuContextMenuContainer
                             {
-                                RelativeSizeAxes = Axes.X,
-                                AutoSizeAxes = Axes.Y,
                                 Shear = -OsuGame.SHEAR,
-                                Padding = new MarginPadding { Top = 5f, Bottom = 5f, Left = 70f, Right = 10f },
-                                Children = new Drawable[]
+                                RelativeSizeAxes = Axes.Both,
+                                Child = new Container
                                 {
-                                    personalBestText = new OsuSpriteText
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Padding = new MarginPadding { Top = 5f, Bottom = 5f, Left = 70f, Right = 10f },
+                                    Children = new Drawable[]
                                     {
-                                        Colour = colourProvider.Content2,
-                                        Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                    },
-                                    personalBestScoreContainer = new Container<BeatmapLeaderboardScore>
-                                    {
-                                        RelativeSizeAxes = Axes.X,
-                                        AutoSizeAxes = Axes.Y,
-                                        Margin = new MarginPadding { Top = 20f },
-                                    },
-                                }
-                            },
+                                        personalBestText = new OsuSpriteText
+                                        {
+                                            Colour = colourProvider.Content2,
+                                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                        },
+                                        personalBestScoreContainer = new Container<BeatmapLeaderboardScore>
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            AutoSizeAxes = Axes.Y,
+                                            Margin = new MarginPadding { Top = 20f },
+                                        },
+                                    }
+                                },
+                            }
                         },
                     },
                     placeholderContainer = new Container<Placeholder>
@@ -172,19 +187,22 @@ namespace osu.Game.Screens.SelectV2
                     loading = new LoadingLayer(),
                 }
             };
+
+            swishSample = audio.Samples.Get(@"SongSelect/leaderboard-score");
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            Scope.BindValueChanged(_ => refetchScores());
-            FilterBySelectedMods.BindValueChanged(_ => refetchScores());
-            beatmap.BindValueChanged(_ => refetchScores());
-            ruleset.BindValueChanged(_ => refetchScores());
+            Scope.BindValueChanged(_ => RefetchScores());
+            Sorting.BindValueChanged(_ => RefetchScores());
+            FilterBySelectedMods.BindValueChanged(_ => RefetchScores());
+            beatmap.BindValueChanged(_ => RefetchScores());
+            ruleset.BindValueChanged(_ => RefetchScores());
             mods.BindValueChanged(_ => refetchScoresFromMods());
 
-            refetchScores();
+            RefetchScores();
         }
 
         protected override void PopIn()
@@ -200,14 +218,14 @@ namespace osu.Game.Screens.SelectV2
         private void refetchScoresFromMods()
         {
             if (FilterBySelectedMods.Value)
-                refetchScores();
+                RefetchScores();
         }
 
         private bool initialFetchComplete;
 
         private ScheduledDelegate? refetchOperation;
 
-        private void refetchScores()
+        public void RefetchScores()
         {
             SetScores(Array.Empty<ScoreInfo>());
 
@@ -224,11 +242,12 @@ namespace osu.Game.Screens.SelectV2
             {
                 var fetchBeatmapInfo = beatmap.Value.BeatmapInfo;
                 var fetchRuleset = ruleset.Value ?? fetchBeatmapInfo.Ruleset;
+                var fetchSorting = Scope.Value == BeatmapLeaderboardScope.Local ? Sorting.Value : LeaderboardSortMode.Score;
 
                 // For now, we forcefully refresh to keep things simple.
                 // In the future, removing this requirement may be deemed useful, but will need ample testing of edge case scenarios
                 // (like returning from gameplay after setting a new score, returning to song select after main menu).
-                leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(fetchBeatmapInfo, fetchRuleset, Scope.Value, FilterBySelectedMods.Value ? mods.Value.ToArray() : null),
+                leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(fetchBeatmapInfo, fetchRuleset, Scope.Value, FilterBySelectedMods.Value ? mods.Value.ToArray() : null, fetchSorting),
                     forceRefresh: true);
 
                 if (!initialFetchComplete)
@@ -304,6 +323,23 @@ namespace osu.Game.Screens.SelectV2
                      .FadeIn(300, Easing.OutQuint)
                      .MoveToX(0f, 300, Easing.OutQuint);
 
+                    bool visible = d.ScreenSpaceDrawQuad.TopLeft.Y < d.Parent!.ChildMaskingBounds.BottomLeft.Y;
+
+                    if (visible)
+                    {
+                        var del = Scheduler.AddDelayed(() =>
+                        {
+                            var chan = swishSample?.GetChannel();
+                            if (chan == null) return;
+
+                            chan.Balance.Value = -OsuGameBase.SFX_STEREO_STRENGTH / 2;
+                            chan.Frequency.Value = 0.98f + RNG.NextDouble(0.04f);
+                            chan.Play();
+                        }, delay);
+
+                        scoreSfxDelegates.Add(del);
+                    }
+
                     delay += 30;
                     i++;
                 }
@@ -354,6 +390,9 @@ namespace osu.Game.Screens.SelectV2
             personalBestDisplay.MoveToX(-100, 300, Easing.OutQuint);
             personalBestDisplay.FadeOut(300, Easing.OutQuint);
             scoresScroll.TransformTo(nameof(scoresScroll.Padding), new MarginPadding(), 300, Easing.OutQuint);
+
+            scoreSfxDelegates.ForEach(d => d.Cancel());
+            scoreSfxDelegates.Clear();
         }
 
         private void onLeaderboardScoreClicked(ScoreInfo score) => songSelect?.PresentScore(score);
@@ -445,7 +484,7 @@ namespace osu.Game.Screens.SelectV2
                 case LeaderboardState.NetworkFailure:
                     return new ClickablePlaceholder(LeaderboardStrings.CouldntFetchScores, FontAwesome.Solid.Sync)
                     {
-                        Action = refetchScores
+                        Action = RefetchScores
                     };
 
                 case LeaderboardState.NoneSelected:
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs
index 8d1dd105a3..818176b3c4 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs
@@ -2,19 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Localisation;
 using osu.Game.Online;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Chat;
 using osu.Game.Resources.Localisation.Web;
 using osuTK;
@@ -48,9 +49,15 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
 
+        [Resolved]
+        private IBindable<SongSelect.BeatmapSetLookupResult> onlineLookupResult { get; set; } = null!;
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
         private IBindable<APIState> apiState = null!;
 
         [Resolved]
@@ -59,8 +66,11 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private ISongSelect? songSelect { get; set; }
 
+        private Sample? wedgeAppearSample;
+        private Sample? wedgeHideSample;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio)
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
@@ -230,12 +240,16 @@ namespace osu.Game.Screens.SelectV2
                     }),
                 }
             };
+
+            wedgeAppearSample = audio.Samples.Get(@"SongSelect/metadata-wedge-pop-in");
+            wedgeHideSample = audio.Samples.Get(@"SongSelect/metadata-wedge-pop-out");
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
             beatmap.BindValueChanged(_ => updateDisplay());
+            onlineLookupResult.BindValueChanged(_ => updateDisplay());
 
             apiState = api.State.GetBoundCopy();
             apiState.BindValueChanged(_ => Scheduler.AddOnce(updateDisplay), true);
@@ -265,10 +279,14 @@ namespace osu.Game.Screens.SelectV2
             // Needs some experimentation on what looks good.
 
             var beatmapInfo = beatmap.Value.BeatmapInfo;
-            var currentOnlineBeatmap = currentOnlineBeatmapSet?.Beatmaps.SingleOrDefault(b => b.OnlineID == beatmapInfo.OnlineID);
+            var currentOnlineBeatmap = onlineLookupResult.Value?.Result?.Beatmaps.SingleOrDefault(b => b.OnlineID == beatmapInfo.OnlineID);
 
             if (State.Value == Visibility.Visible && currentOnlineBeatmap != null)
             {
+                // play show sounds only if the wedges were previously hidden
+                if (ratingsWedge.Alpha < 1)
+                    playWedgeAppearSound();
+
                 ratingsWedge.FadeIn(transition_duration, Easing.OutQuint)
                             .MoveToX(0, transition_duration, Easing.OutQuint);
 
@@ -278,6 +296,10 @@ namespace osu.Game.Screens.SelectV2
             }
             else
             {
+                // play hide sounds only if the wedges were previously visible
+                if (ratingsWedge.Alpha > 0)
+                    playWedgeHideSound();
+
                 failRetryWedge.FadeOut(transition_duration, Easing.OutQuint)
                               .MoveToX(-50, transition_duration, Easing.OutQuint);
 
@@ -287,6 +309,38 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
+        private void playWedgeAppearSound()
+        {
+            var wedgeAppearChannel1 = wedgeAppearSample?.GetChannel();
+            if (wedgeAppearChannel1 == null)
+                return;
+
+            wedgeAppearChannel1.Balance.Value = -OsuGameBase.SFX_STEREO_STRENGTH / 2;
+            wedgeAppearChannel1.Frequency.Value = 0.98f + RNG.NextDouble(0.04f);
+            wedgeAppearChannel1.Play();
+
+            Scheduler.AddDelayed(() =>
+            {
+                var wedgeAppearChannel2 = wedgeAppearSample?.GetChannel();
+                if (wedgeAppearChannel2 == null)
+                    return;
+
+                wedgeAppearChannel2.Balance.Value = -OsuGameBase.SFX_STEREO_STRENGTH / 2;
+                wedgeAppearChannel2.Frequency.Value = 0.90f + RNG.NextDouble(0.05f);
+                wedgeAppearChannel2.Play();
+            }, 100);
+        }
+
+        private void playWedgeHideSound()
+        {
+            var wedgeHideChannel = wedgeHideSample?.GetChannel();
+            if (wedgeHideChannel == null)
+                return;
+
+            wedgeHideChannel.Balance.Value = -OsuGameBase.SFX_STEREO_STRENGTH / 2;
+            wedgeHideChannel.Play();
+        }
+
         private void updateDisplay()
         {
             var metadata = beatmap.Value.Metadata;
@@ -307,41 +361,12 @@ namespace osu.Game.Screens.SelectV2
             submitted.Date = beatmapSetInfo.DateSubmitted;
             ranked.Date = beatmapSetInfo.DateRanked;
 
-            if (currentOnlineBeatmapSet == null || currentOnlineBeatmapSet.OnlineID != beatmapSetInfo.OnlineID)
-                refetchBeatmapSet();
-
             updateOnlineDisplay();
         }
 
-        private APIBeatmapSet? currentOnlineBeatmapSet;
-        private GetBeatmapSetRequest? currentRequest;
-
-        private void refetchBeatmapSet()
-        {
-            var beatmapSetInfo = beatmap.Value.BeatmapSetInfo;
-
-            currentRequest?.Cancel();
-            currentRequest = null;
-            currentOnlineBeatmapSet = null;
-
-            if (beatmapSetInfo.OnlineID >= 1)
-            {
-                // todo: consider introducing a BeatmapSetLookupCache for caching benefits.
-                currentRequest = new GetBeatmapSetRequest(beatmapSetInfo.OnlineID);
-                currentRequest.Failure += _ => updateOnlineDisplay();
-                currentRequest.Success += s =>
-                {
-                    currentOnlineBeatmapSet = s;
-                    updateOnlineDisplay();
-                };
-
-                api.Queue(currentRequest);
-            }
-        }
-
         private void updateOnlineDisplay()
         {
-            if (currentRequest?.CompletionState == APIRequestCompletionState.Waiting)
+            if (onlineLookupResult.Value?.Status != SongSelect.BeatmapSetLookupStatus.Completed)
             {
                 genre.Data = null;
                 language.Data = null;
@@ -349,7 +374,7 @@ namespace osu.Game.Screens.SelectV2
                 return;
             }
 
-            if (currentOnlineBeatmapSet == null)
+            if (onlineLookupResult.Value.Result == null)
             {
                 genre.Data = ("-", null);
                 language.Data = ("-", null);
@@ -358,7 +383,7 @@ namespace osu.Game.Screens.SelectV2
             {
                 var beatmapInfo = beatmap.Value.BeatmapInfo;
 
-                var onlineBeatmapSet = currentOnlineBeatmapSet;
+                var onlineBeatmapSet = onlineLookupResult.Value.Result;
                 var onlineBeatmap = onlineBeatmapSet.Beatmaps.SingleOrDefault(b => b.OnlineID == beatmapInfo.OnlineID);
 
                 genre.Data = (onlineBeatmapSet.Genre.Name, () => songSelect?.Search(onlineBeatmapSet.Genre.Name));
@@ -379,28 +404,22 @@ namespace osu.Game.Screens.SelectV2
 
         private void updateUserTags()
         {
-            var beatmapInfo = beatmap.Value.BeatmapInfo;
-            var onlineBeatmapSet = currentOnlineBeatmapSet;
-            var onlineBeatmap = onlineBeatmapSet?.Beatmaps.SingleOrDefault(b => b.OnlineID == beatmapInfo.OnlineID);
+            string[] tags = realm.Run(r =>
+            {
+                // need to refetch because `beatmap.Value.BeatmapInfo` is not going to have the latest tags
+                r.Refresh();
+                var refetchedBeatmap = r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID);
+                return refetchedBeatmap?.Metadata.UserTags.ToArray() ?? [];
+            });
 
-            if (onlineBeatmap?.TopTags == null || onlineBeatmap.TopTags.Length == 0 || onlineBeatmapSet?.RelatedTags == null)
+            if (tags.Length == 0)
             {
                 userTags.FadeOut(transition_duration, Easing.OutQuint);
                 return;
             }
 
-            var tagsById = onlineBeatmapSet.RelatedTags.ToDictionary(t => t.Id);
-            string[] userTagsArray = onlineBeatmap.TopTags
-                                                  .Select(t => (topTag: t, relatedTag: tagsById.GetValueOrDefault(t.TagId)))
-                                                  .Where(t => t.relatedTag != null)
-                                                  // see https://github.com/ppy/osu-web/blob/bb3bd2e7c6f84f26066df5ea20a81c77ec9bb60a/resources/js/beatmapsets-show/controller.ts#L103-L106 for sort criteria
-                                                  .OrderByDescending(t => t.topTag.VoteCount)
-                                                  .ThenBy(t => t.relatedTag!.Name)
-                                                  .Select(t => t.relatedTag!.Name)
-                                                  .ToArray();
-
             userTags.FadeIn(transition_duration, Easing.OutQuint);
-            userTags.Tags = (userTagsArray, t => songSelect?.Search(t));
+            userTags.Tags = (tags, t => songSelect?.Search($@"tag=""{t}""!"));
         }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs
index a98c806634..1c3cf8f8eb 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs
@@ -56,12 +56,12 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            public (string[] tags, Action<string> linkAction)? Tags
+            public (string[] tags, Action<string> searchAction)? Tags
             {
                 set
                 {
                     if (value != null)
-                        setTags(value.Value.tags, value.Value.linkAction);
+                        setTags(value.Value.tags, value.Value.searchAction);
                     else
                         setLoading();
                 }
@@ -161,12 +161,12 @@ namespace osu.Game.Screens.SelectV2
                 contentDate.Date = date;
             }
 
-            private void setTags(string[] tags, Action<string> link)
+            private void setTags(string[] tags, Action<string> searchAction)
             {
                 clear();
 
+                contentTags.PerformSearch = searchAction;
                 contentTags.Tags = tags;
-                contentTags.Action = link;
             }
 
             private void setLoading()
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
index 683cd428e9..e48b4f20da 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
@@ -44,7 +44,7 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            public Action<string>? Action;
+            public Action<string>? PerformSearch { get; set; }
 
             [Resolved]
             private OverlayColourProvider colourProvider { get; set; } = null!;
@@ -103,7 +103,7 @@ namespace osu.Game.Screens.SelectV2
                 ChildrenEnumerable = tags.Select(t => new OsuHoverContainer
                 {
                     AutoSizeAxes = Axes.Both,
-                    Action = () => Action?.Invoke(t),
+                    Action = () => PerformSearch?.Invoke(t),
                     IdleColour = colourProvider.Light2,
                     AlwaysPresent = true,
                     Alpha = 0f,
@@ -117,6 +117,7 @@ namespace osu.Game.Screens.SelectV2
                 Add(overflowButton = new TagsOverflowButton(tags)
                 {
                     Alpha = 0f,
+                    PerformSearch = s => PerformSearch?.Invoke(s),
                 });
 
                 drawSizeLayout.Invalidate();
@@ -132,11 +133,10 @@ namespace osu.Game.Screens.SelectV2
                 [Resolved]
                 private OverlayColourProvider colourProvider { get; set; } = null!;
 
-                [Resolved]
-                private ISongSelect? songSelect { get; set; }
-
                 public float LineBaseHeight => text.LineBaseHeight;
 
+                public Action<string>? PerformSearch { get; init; }
+
                 public TagsOverflowButton(string[] tags)
                 {
                     this.tags = tags;
@@ -188,18 +188,18 @@ namespace osu.Game.Screens.SelectV2
                     return true;
                 }
 
-                public Popover GetPopover() => new TagsOverflowPopover(tags, songSelect);
+                public Popover GetPopover() => new TagsOverflowPopover(tags, PerformSearch);
             }
 
             public partial class TagsOverflowPopover : OsuPopover
             {
                 private readonly string[] tags;
-                private readonly ISongSelect? songSelect;
+                private readonly Action<string>? performSearch;
 
-                public TagsOverflowPopover(string[] tags, ISongSelect? songSelect)
+                public TagsOverflowPopover(string[] tags, Action<string>? performSearchAction)
                 {
                     this.tags = tags;
-                    this.songSelect = songSelect;
+                    performSearch = performSearchAction;
                 }
 
                 [BackgroundDependencyLoader]
@@ -215,7 +215,7 @@ namespace osu.Game.Screens.SelectV2
 
                     foreach (string tag in tags)
                     {
-                        textFlow.AddLink(tag, () => songSelect?.Search(tag));
+                        textFlow.AddLink(tag, () => performSearch?.Invoke(tag));
                         textFlow.AddText(" ");
                     }
                 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
index 6b80fc69c9..21ac04b18a 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
@@ -8,20 +8,17 @@ using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
@@ -43,6 +40,9 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IBindable<IReadOnlyList<Mod>> mods { get; set; } = null!;
 
+        [Resolved]
+        private IBindable<SongSelect.BeatmapSetLookupResult?> onlineLookupResult { get; set; } = null!;
+
         protected override bool StartHidden => true;
 
         private ModSettingChangeTracker? settingChangeTracker;
@@ -59,7 +59,7 @@ namespace osu.Game.Screens.SelectV2
         internal string DisplayedArtist => artistLabel.Text.ToString();
 
         private StatisticPlayCount playCount = null!;
-        private Statistic favouritesStatistic = null!;
+        private FavouriteButton favouriteButton = null!;
         private Statistic lengthStatistic = null!;
         private Statistic bpmStatistic = null!;
 
@@ -70,10 +70,7 @@ namespace osu.Game.Screens.SelectV2
         private LocalisationManager localisation { get; set; } = null!;
 
         [Resolved]
-        private IAPIProvider api { get; set; } = null!;
-
-        private APIBeatmapSet? currentOnlineBeatmapSet;
-        private GetBeatmapSetRequest? currentRequest;
+        private RealmAccess realm { get; set; } = null!;
 
         private FillFlowContainer statisticsFlow = null!;
 
@@ -157,10 +154,7 @@ namespace osu.Game.Screens.SelectV2
                                 {
                                     Margin = new MarginPadding { Left = -SongSelect.WEDGE_CONTENT_MARGIN },
                                 },
-                                favouritesStatistic = new Statistic(OsuIcon.Heart, background: true, minSize: 25f)
-                                {
-                                    TooltipText = BeatmapsStrings.StatusFavourites,
-                                },
+                                favouriteButton = new FavouriteButton(),
                                 lengthStatistic = new Statistic(OsuIcon.Clock),
                                 bpmStatistic = new Statistic(OsuIcon.Metronome)
                                 {
@@ -189,6 +183,7 @@ namespace osu.Game.Screens.SelectV2
 
             working.BindValueChanged(_ => updateDisplay());
             ruleset.BindValueChanged(_ => updateDisplay());
+            onlineLookupResult.BindValueChanged(_ => updateDisplay());
 
             mods.BindValueChanged(m =>
             {
@@ -229,7 +224,6 @@ namespace osu.Game.Screens.SelectV2
         {
             var metadata = working.Value.Metadata;
             var beatmapInfo = working.Value.BeatmapInfo;
-            var beatmapSetInfo = working.Value.BeatmapSetInfo;
 
             statusPill.Status = beatmapInfo.Status;
 
@@ -242,10 +236,6 @@ namespace osu.Game.Screens.SelectV2
             artistLink.Action = () => songSelect?.Search(artistText.GetPreferred(localisation.CurrentParameters.Value.PreferOriginalScript));
 
             updateLengthAndBpmStatistics();
-
-            if (currentOnlineBeatmapSet == null || currentOnlineBeatmapSet.OnlineID != beatmapSetInfo.OnlineID)
-                refetchBeatmapSet();
-
             updateOnlineDisplay();
         }
 
@@ -288,48 +278,33 @@ namespace osu.Game.Screens.SelectV2
             }, token);
         }
 
-        private void refetchBeatmapSet()
-        {
-            var beatmapSetInfo = working.Value.BeatmapSetInfo;
-
-            currentRequest?.Cancel();
-            currentRequest = null;
-            currentOnlineBeatmapSet = null;
-
-            if (beatmapSetInfo.OnlineID >= 1)
-            {
-                // todo: consider introducing a BeatmapSetLookupCache for caching benefits.
-                currentRequest = new GetBeatmapSetRequest(beatmapSetInfo.OnlineID);
-                currentRequest.Failure += _ => updateOnlineDisplay();
-                currentRequest.Success += s =>
-                {
-                    currentOnlineBeatmapSet = s;
-                    updateOnlineDisplay();
-                };
-
-                api.Queue(currentRequest);
-            }
-        }
-
         private void updateOnlineDisplay()
         {
-            if (currentRequest?.CompletionState == APIRequestCompletionState.Waiting)
+            if (onlineLookupResult.Value?.Status != SongSelect.BeatmapSetLookupStatus.Completed)
             {
                 playCount.Value = null;
-                favouritesStatistic.Text = null;
-            }
-            else if (currentOnlineBeatmapSet == null)
-            {
-                playCount.Value = new StatisticPlayCount.Data(-1, -1);
-                favouritesStatistic.Text = "-";
+                favouriteButton.SetLoading();
             }
             else
             {
-                var onlineBeatmapSet = currentOnlineBeatmapSet;
-                var onlineBeatmap = currentOnlineBeatmapSet.Beatmaps.SingleOrDefault(b => b.OnlineID == working.Value.BeatmapInfo.OnlineID);
-
+                var onlineBeatmap = onlineLookupResult.Value.Result?.Beatmaps.SingleOrDefault(b => b.OnlineID == working.Value.BeatmapInfo.OnlineID);
                 playCount.Value = new StatisticPlayCount.Data(onlineBeatmap?.PlayCount ?? -1, onlineBeatmap?.UserPlayCount ?? -1);
-                favouritesStatistic.Text = onlineBeatmapSet.FavouriteCount.ToLocalisableString(@"N0");
+                favouriteButton.SetBeatmapSet(onlineLookupResult.Value.Result);
+
+                // the online fetch may have also updated the beatmap's status.
+                // this needs to be checked against the *local* beatmap model rather than the online one, because it's not known here whether the status change has occurred or not
+                // (think scenarios like the beatmap being locally modified).
+                // it also has to be handled explicitly like this because the working beatmap's `BeatmapInfo` will not receive these updates due to being detached
+                // (and because of https://github.com/ppy/osu/blob/4b73afd1957a9161e2956fc4191c8114d9958372/osu.Game/Screens/SelectV2/SongSelect.cs#L487-L488
+                // which prevents working beatmap refetches caused by changes to the realm model of perceived low importance).
+                var status = realm.Run(r =>
+                {
+                    r.Refresh();
+                    var refetchedBeatmap = r.Find<BeatmapInfo>(working.Value.BeatmapInfo.ID);
+                    return refetchedBeatmap?.Status;
+                });
+                if (status != null)
+                    statusPill.Status = status.Value;
             }
         }
     }
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
index 7c7c3872cd..55ed488d87 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
@@ -11,7 +11,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
@@ -23,10 +22,8 @@ using osu.Game.Localisation;
 using osu.Game.Online;
 using osu.Game.Online.Chat;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Utils;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
@@ -63,7 +60,7 @@ namespace osu.Game.Screens.SelectV2
 
             private GridContainer ratingAndNameContainer = null!;
             private DifficultyStatisticsDisplay countStatisticsDisplay = null!;
-            private AdjustableDifficultyStatisticsDisplay difficultyStatisticsDisplay = null!;
+            private DifficultyStatisticsDisplay difficultyStatisticsDisplay = null!;
 
             private CancellationTokenSource? cancellationSource;
 
@@ -196,7 +193,7 @@ namespace osu.Game.Screens.SelectV2
                                                         RelativeSizeAxes = Axes.X,
                                                     },
                                                     Empty(),
-                                                    difficultyStatisticsDisplay = new AdjustableDifficultyStatisticsDisplay(autoSize: true),
+                                                    difficultyStatisticsDisplay = new DifficultyStatisticsDisplay(autoSize: true),
                                                 }
                                             },
                                         }
@@ -242,7 +239,7 @@ namespace osu.Game.Screens.SelectV2
                 if (beatmap.IsDefault)
                 {
                     ratingAndNameContainer.FadeOut(300, Easing.OutQuint);
-                    countStatisticsDisplay.Statistics = Array.Empty<StatisticDifficulty.Data>();
+                    countStatisticsDisplay.FadeOut(300, Easing.OutQuint);
                 }
                 else
                 {
@@ -252,7 +249,7 @@ namespace osu.Game.Screens.SelectV2
                     mapperText.Text = beatmap.Value.Metadata.Author.Username;
                 }
 
-                starRatingDisplay.Current = (Bindable<StarDifficulty>)difficultyCache.GetBindableDifficulty(beatmap.Value.BeatmapInfo, cancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+                starRatingDisplay.Current = (Bindable<StarDifficulty>)difficultyCache.GetBindableDifficulty(beatmap.Value.BeatmapInfo, cancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
 
                 updateCountStatistics(cancellationSource.Token);
                 updateDifficultyStatistics();
@@ -262,7 +259,7 @@ namespace osu.Game.Screens.SelectV2
             {
                 if (beatmap.IsDefault)
                 {
-                    countStatisticsDisplay.Statistics = Array.Empty<StatisticDifficulty.Data>();
+                    countStatisticsDisplay.FadeOut(300, Easing.OutQuint);
                     return;
                 }
 
@@ -280,6 +277,7 @@ namespace osu.Game.Screens.SelectV2
                         if (cancellationToken.IsCancellationRequested)
                             return;
 
+                        countStatisticsDisplay.FadeIn(200, Easing.OutQuint);
                         countStatisticsDisplay.Statistics = statistics;
                     });
                 }, cancellationToken);
@@ -289,53 +287,14 @@ namespace osu.Game.Screens.SelectV2
             {
                 if (beatmap.IsDefault || ruleset.Value == null)
                 {
-                    difficultyStatisticsDisplay.TooltipContent = null;
                     difficultyStatisticsDisplay.Statistics = Array.Empty<StatisticDifficulty.Data>();
                     return;
                 }
 
-                BeatmapDifficulty originalDifficulty = beatmap.Value.BeatmapInfo.Difficulty;
-                BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(originalDifficulty);
-
-                foreach (var mod in mods.Value.OfType<IApplicableToDifficulty>())
-                    mod.ApplyToDifficulty(adjustedDifficulty);
-
                 Ruleset rulesetInstance = ruleset.Value.CreateInstance();
 
-                double rate = ModUtils.CalculateRateWithMods(mods.Value);
-
-                adjustedDifficulty = rulesetInstance.GetRateAdjustedDisplayDifficulty(adjustedDifficulty, rate);
-                difficultyStatisticsDisplay.TooltipContent = new AdjustedAttributesTooltip.Data(originalDifficulty, adjustedDifficulty);
-
-                StatisticDifficulty.Data firstStatistic;
-
-                switch (ruleset.Value.OnlineID)
-                {
-                    case 3:
-                        // Account for mania differences locally for now.
-                        // Eventually this should be handled in a more modular way, allowing rulesets to return arbitrary difficulty attributes.
-                        ILegacyRuleset legacyRuleset = (ILegacyRuleset)rulesetInstance;
-
-                        // For the time being, the key count is static no matter what, because:
-                        // - The method doesn't have knowledge of the active keymods. Doing so may require considerations for filtering.
-                        // - 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(SongSelectStrings.KeyCount, keyCount, keyCount, 10);
-                        break;
-
-                    default:
-                        firstStatistic = new StatisticDifficulty.Data(SongSelectStrings.CircleSize, originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
-                        break;
-                }
-
-                difficultyStatisticsDisplay.Statistics = new[]
-                {
-                    firstStatistic,
-                    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),
-                };
+                var displayAttributes = rulesetInstance.GetBeatmapAttributesForDisplay(beatmap.Value.BeatmapInfo, mods.Value).ToList();
+                difficultyStatisticsDisplay.Statistics = displayAttributes.Select(a => new StatisticDifficulty.Data(a)).ToList();
             });
 
             protected override void Update()
@@ -362,21 +321,6 @@ namespace osu.Game.Screens.SelectV2
                     IdleColour = overlayColourProvider?.Light2 ?? colours.Blue;
                 }
             }
-
-            private partial class AdjustableDifficultyStatisticsDisplay : DifficultyStatisticsDisplay, IHasCustomTooltip<AdjustedAttributesTooltip.Data>
-            {
-                [Resolved]
-                private OverlayColourProvider colourProvider { get; set; } = null!;
-
-                public ITooltip<AdjustedAttributesTooltip.Data> GetCustomTooltip() => new AdjustedAttributesTooltip(colourProvider);
-
-                public AdjustedAttributesTooltip.Data? TooltipContent { get; set; }
-
-                public AdjustableDifficultyStatisticsDisplay(bool autoSize)
-                    : base(autoSize)
-                {
-                }
-            }
         }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
index 365ed9977b..595959cfce 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
@@ -144,11 +144,13 @@ namespace osu.Game.Screens.SelectV2
                     if (tiny)
                     {
                         statisticsFlow.Hide();
+                        // Slow fade hides fill flow layout weirdness.
                         tinyStatisticsGrid.FadeIn(200, Easing.InQuint);
                     }
                     else
                     {
                         tinyStatisticsGrid.Hide();
+                        // Slow fade hides fill flow layout weirdness.
                         statisticsFlow.FadeIn(200, Easing.InQuint);
                     }
 
@@ -164,12 +166,16 @@ namespace osu.Game.Screens.SelectV2
                 float statisticWidth = Math.Max(65, statisticsFlow.Max(s => s.LabelWidth));
 
                 foreach (var statistic in statisticsFlow)
+                {
                     statistic.Width = statisticWidth;
+                    // Slow fade hides fill flow layout weirdness.
+                    statistic.FadeIn(200, Easing.InQuint);
+                }
 
                 drawSizeLayout.Invalidate();
             });
 
-            private void updateStatistics()
+            private void updateStatistics() => Scheduler.AddOnce(() =>
             {
                 if (statisticsFlow.Select(s => s.Value.Label)
                                   .SequenceEqual(statistics.Select(s => s.Label)))
@@ -181,12 +187,13 @@ namespace osu.Game.Screens.SelectV2
                 {
                     statisticsFlow.ChildrenEnumerable = statistics.Select(d => new StatisticDifficulty
                     {
+                        Alpha = 0,
                         AccentColour = accentColour,
                         Value = d
                     });
                     updateStatisticsSizing();
                 }
-            }
+            });
 
             private void updateTinyStatistics()
             {
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_FavouriteButton.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_FavouriteButton.cs
new file mode 100644
index 0000000000..2db3ed7613
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_FavouriteButton.cs
@@ -0,0 +1,371 @@
+// 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.Diagnostics;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+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;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Resources.Localisation.Web;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.SelectV2
+{
+    public partial class BeatmapTitleWedge
+    {
+        public partial class FavouriteButton : OsuClickableContainer
+        {
+            private readonly BindableBool isFavourite = new BindableBool();
+
+            private Box background = null!;
+            private OsuSpriteText valueText = null!;
+            private LoadingSpinner loadingSpinner = null!;
+            private Box hoverLayer = null!;
+            private HeartIcon icon = null!;
+
+            private APIBeatmapSet? onlineBeatmapSet;
+            private PostBeatmapFavouriteRequest? favouriteRequest;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
+            [Resolved]
+            private IAPIProvider api { get; set; } = null!;
+
+            [Resolved]
+            private INotificationOverlay? notifications { get; set; }
+
+            internal LocalisableString Text => valueText.Text;
+
+            public FavouriteButton()
+            {
+                AutoSizeAxes = Axes.Both;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Masking = true;
+                CornerRadius = 5;
+                Shear = OsuGame.SHEAR;
+
+                AddRange(new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Black.Opacity(0.2f),
+                    },
+                    new FillFlowContainer
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Horizontal,
+                        Margin = new MarginPadding { Left = 10, Right = 10, Vertical = 5f },
+                        Spacing = new Vector2(4f, 0f),
+                        Shear = -OsuGame.SHEAR,
+                        Children = new Drawable[]
+                        {
+                            icon = new HeartIcon
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Size = new Vector2(OsuFont.Style.Heading2.Size),
+                            },
+                            new Container
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                AutoSizeAxes = Axes.X,
+                                Height = 20,
+                                Children = new Drawable[]
+                                {
+                                    loadingSpinner = new LoadingSpinner
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Size = new Vector2(12f),
+                                        State = { Value = Visibility.Visible },
+                                    },
+                                    new GridContainer
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        AutoSizeAxes = Axes.Both,
+                                        RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
+                                        ColumnDimensions = new[]
+                                        {
+                                            new Dimension(GridSizeMode.AutoSize, minSize: 25),
+                                        },
+                                        Content = new[]
+                                        {
+                                            new[]
+                                            {
+                                                valueText = new OsuSpriteText
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Font = OsuFont.Style.Heading2,
+                                                    Colour = colourProvider.Content2,
+                                                    Margin = new MarginPadding { Bottom = 2f },
+                                                    AlwaysPresent = true,
+                                                },
+                                            }
+                                        }
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    hoverLayer = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        Colour = Colour4.White.Opacity(0.1f),
+                        Blending = BlendingParameters.Additive,
+                    },
+                });
+                Action = toggleFavourite;
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                hoverLayer.FadeIn(500, Easing.OutQuint);
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                base.OnHoverLost(e);
+                hoverLayer.FadeOut(500, Easing.OutQuint);
+            }
+
+            public override LocalisableString TooltipText => isFavourite.Value ? BeatmapsetsStrings.ShowDetailsUnfavourite.ToSentence() : BeatmapsetsStrings.ShowDetailsFavourite.ToSentence();
+
+            // Note: `setLoading()` and `setBeatmapSet()` are called externally via their public counterparts by song select when the beatmap changes,
+            // as well as internally in order to display the progress and result of the (un)favourite operation when the button is clicked.
+            // In case of external calls, we want to cancel pending favourite requests, primarily to avoid a situation when a late success callback from an (un)favourite
+            // could show the favourite count from a prior beatmap.
+
+            public void SetLoading()
+            {
+                if (favouriteRequest?.CompletionState == APIRequestCompletionState.Waiting)
+                    favouriteRequest.Cancel();
+                setLoading();
+            }
+
+            private void setLoading()
+            {
+                loadingSpinner.State.Value = Visibility.Visible;
+                valueText.FadeOut(120, Easing.OutQuint);
+
+                onlineBeatmapSet = null;
+                updateFavouriteState();
+            }
+
+            public void SetBeatmapSet(APIBeatmapSet? beatmapSet)
+            {
+                if (favouriteRequest?.CompletionState == APIRequestCompletionState.Waiting)
+                    favouriteRequest.Cancel();
+                setBeatmapSet(beatmapSet);
+            }
+
+            private void setBeatmapSet(APIBeatmapSet? beatmapSet, bool withHeartAnimation = false)
+            {
+                loadingSpinner.State.Value = Visibility.Hidden;
+                valueText.FadeIn(120, Easing.OutQuint);
+
+                onlineBeatmapSet = beatmapSet;
+                updateFavouriteState(withHeartAnimation);
+            }
+
+            private void updateFavouriteState(bool withAnimation = false)
+            {
+                Enabled.Value = onlineBeatmapSet != null;
+
+                if (loadingSpinner.State.Value == Visibility.Hidden)
+                    valueText.Text = onlineBeatmapSet?.FavouriteCount.ToLocalisableString(@"N0") ?? "-";
+
+                isFavourite.Value = onlineBeatmapSet?.HasFavourited == true;
+
+                background.FadeColour(isFavourite.Value ? colours.Pink4.Darken(1f).Opacity(0.5f) : Color4.Black.Opacity(0.2f), 500, Easing.OutQuint);
+                valueText.FadeColour(isFavourite.Value ? colours.Pink1 : colourProvider.Content2, 500, Easing.OutQuint);
+                icon.SetActive(isFavourite.Value, withAnimation);
+            }
+
+            private void toggleFavourite()
+            {
+                Debug.Assert(onlineBeatmapSet != null);
+
+                // having this copy locally is important to capture this particular beatmap set instance rather than the field in the request success callback,
+                // because if it was captured via the field / `this`, it could change value due to an external `setLoading()` or `setBeatmapSet()` call.
+                // there's also the part where we want to call `setLoading()` here to show the spinner, but that also sets `onlineBeatmapSet` to null.
+                var beatmapSet = onlineBeatmapSet;
+
+                favouriteRequest = new PostBeatmapFavouriteRequest(beatmapSet.OnlineID, isFavourite.Value ? BeatmapFavouriteAction.UnFavourite : BeatmapFavouriteAction.Favourite);
+                favouriteRequest.Success += () =>
+                {
+                    bool hasFavourited = favouriteRequest.Action == BeatmapFavouriteAction.Favourite;
+                    beatmapSet.HasFavourited = hasFavourited;
+                    beatmapSet.FavouriteCount += hasFavourited ? 1 : -1;
+
+                    // if the beatmap set reference changed under the callback, abort visual updates to avoid showing stale data
+                    if (onlineBeatmapSet == null || ReferenceEquals(beatmapSet, onlineBeatmapSet))
+                        setBeatmapSet(beatmapSet, withHeartAnimation: hasFavourited);
+                };
+                favouriteRequest.Failure += e =>
+                {
+                    notifications?.Post(new SimpleNotification
+                    {
+                        Text = e.Message,
+                        Icon = FontAwesome.Solid.Times,
+                    });
+
+                    // if the beatmap set reference changed under the callback, abort visual updates to avoid showing stale data
+                    if (onlineBeatmapSet == null || ReferenceEquals(beatmapSet, onlineBeatmapSet))
+                        setBeatmapSet(beatmapSet, withHeartAnimation: false);
+                };
+                api.Queue(favouriteRequest);
+                setLoading();
+            }
+        }
+
+        private partial class HeartIcon : CompositeDrawable
+        {
+            private readonly SpriteIcon icon;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
+            public HeartIcon()
+            {
+                InternalChildren = new Drawable[]
+                {
+                    icon = new SpriteIcon
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Icon = FontAwesome.Regular.Heart,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+            }
+
+            private const double pop_out_duration = 100;
+            private const double pop_in_duration = 500;
+
+            private bool active;
+
+            public void SetActive(bool active, bool withAnimation = false)
+            {
+                if (this.active == active)
+                    return;
+
+                this.active = active;
+
+                FinishTransforms(true);
+
+                if (active)
+                {
+                    transitionIcon(FontAwesome.Solid.Heart, colours.Pink1, emphasised: withAnimation);
+
+                    if (withAnimation)
+                        playFavouriteAnimation();
+                }
+                else
+                {
+                    transitionIcon(FontAwesome.Regular.Heart, colourProvider.Content2);
+                }
+            }
+
+            private void transitionIcon(IconUsage newIcon, Color4 colour, bool emphasised = false)
+            {
+                icon.ScaleTo(emphasised ? 0.5f : 0.8f, pop_out_duration, Easing.OutQuad)
+                    .Then()
+                    .FadeColour(colour)
+                    .Schedule(() => icon.Icon = newIcon)
+                    .ScaleTo(1, pop_in_duration, Easing.OutElasticHalf);
+            }
+
+            private void playFavouriteAnimation()
+            {
+                var circle = new FastCircle
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(0.5f),
+                    Blending = BlendingParameters.Additive,
+                    Alpha = 0,
+                    Depth = float.MinValue,
+                };
+
+                AddInternal(circle);
+
+                circle.Delay(pop_out_duration)
+                      .FadeTo(0.35f)
+                      .FadeOut(1400, Easing.OutCubic)
+                      .ScaleTo(10f, 750, Easing.OutQuint)
+                      .Expire();
+
+                const int num_particles = 8;
+
+                static float randomFloat(float min, float max) => min + Random.Shared.NextSingle() * (max - min);
+
+                for (int i = 0; i < num_particles; i++)
+                {
+                    double duration = randomFloat(600, 1000);
+                    float angle = (i + randomFloat(0, 0.75f)) / num_particles * MathF.PI * 2;
+                    var direction = new Vector2(MathF.Cos(angle), MathF.Sin(angle));
+                    float distance = randomFloat(DrawWidth / 2, DrawWidth);
+
+                    var particle = new FastCircle
+                    {
+                        Position = direction * DrawWidth / 4,
+                        Size = new Vector2(3),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Blending = BlendingParameters.Additive,
+                        Alpha = 0,
+                        Depth = 2,
+                        Colour = colours.Pink,
+                    };
+
+                    AddInternal(particle);
+
+                    particle
+                        .Delay(pop_out_duration)
+                        .FadeTo(0.5f)
+                        .MoveTo(direction * distance, 1300, Easing.OutQuint)
+                        .FadeOut(duration, Easing.Out)
+                        .ScaleTo(0.5f, duration)
+                        .Expire();
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
index d0b6acca88..bcce78246d 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
@@ -7,12 +7,15 @@ using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Difficulty;
 using osuTK;
 using osuTK.Graphics;
 
@@ -20,7 +23,7 @@ namespace osu.Game.Screens.SelectV2
 {
     public partial class BeatmapTitleWedge
     {
-        public partial class StatisticDifficulty : CompositeDrawable, IHasAccentColour
+        public partial class StatisticDifficulty : CompositeDrawable, IHasAccentColour, IHasCustomTooltip<RulesetBeatmapAttribute?>
         {
             private Data value = new Data(string.Empty, 0, 0, 0);
 
@@ -191,7 +194,16 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            public record Data(LocalisableString Label, float Value, float AdjustedValue, float Maximum, string? Content = null);
+            public record Data(LocalisableString Label, float Value, float AdjustedValue, float Maximum, string? Content = null, RulesetBeatmapAttribute? BeatmapAttribute = null)
+            {
+                public Data(RulesetBeatmapAttribute attribute)
+                    : this(attribute.Label, attribute.OriginalValue, attribute.AdjustedValue, attribute.MaxValue, BeatmapAttribute: attribute)
+                {
+                }
+            }
+
+            public ITooltip<RulesetBeatmapAttribute?> GetCustomTooltip() => new BeatmapAttributeTooltip();
+            public RulesetBeatmapAttribute? TooltipContent => value.BeatmapAttribute;
         }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs
index 87f7c30d17..d193cbe286 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs
@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
@@ -102,7 +103,7 @@ namespace osu.Game.Screens.SelectV2
                                         {
                                             Colour = colourProvider.Content2,
                                             Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                            Text = "Total Plays",
+                                            Text = SongSelectStrings.TotalPlays,
                                         },
                                         totalPlaysText = new OsuSpriteText
                                         {
@@ -121,7 +122,7 @@ namespace osu.Game.Screens.SelectV2
                                         {
                                             Colour = colourProvider.Content2,
                                             Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                            Text = "Personal Plays",
+                                            Text = SongSelectStrings.PersonalPlays,
                                         },
                                         personalPlaysText = new OsuSpriteText
                                         {
diff --git a/osu.Game/Screens/SelectV2/CollectionDropdown.cs b/osu.Game/Screens/SelectV2/CollectionDropdown.cs
index a2a2ec1c93..a333be5776 100644
--- a/osu.Game/Screens/SelectV2/CollectionDropdown.cs
+++ b/osu.Game/Screens/SelectV2/CollectionDropdown.cs
@@ -18,6 +18,7 @@ using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
 using osuTK;
 using Realms;
 
@@ -33,8 +34,6 @@ namespace osu.Game.Screens.SelectV2
         /// </summary>
         protected virtual bool ShowManageCollectionsItem => true;
 
-        public Action? RequestFilter { private get; set; }
-
         private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
 
         [Resolved]
@@ -48,7 +47,7 @@ namespace osu.Game.Screens.SelectV2
         private readonly CollectionFilterMenuItem allBeatmapsItem = new AllBeatmapsCollectionFilterMenuItem();
 
         public CollectionDropdown()
-            : base("Collection")
+            : base(CollectionsStrings.Collection)
         {
             ItemSource = filters;
 
@@ -109,16 +108,12 @@ namespace osu.Game.Screens.SelectV2
                             Current.Value = filters.SingleOrDefault(f => f.Collection?.ID == selectedItem.Collection?.ID) ?? filters[0];
                         });
 
-                        // Trigger an external re-filter if the current item was in the change set.
-                        RequestFilter?.Invoke();
                         break;
                     }
                 }
             }
         }
 
-        private Live<BeatmapCollection>? lastFiltered;
-
         private void selectionChanged(ValueChangedEvent<CollectionFilterMenuItem> filter)
         {
             // May be null during .Clear().
@@ -131,17 +126,6 @@ namespace osu.Game.Screens.SelectV2
             {
                 Current.Value = filter.OldValue;
                 manageCollectionsDialog?.Show();
-                return;
-            }
-
-            var newCollection = filter.NewValue.Collection;
-
-            // This dropdown be weird.
-            // We only care about filtering if the actual collection has changed.
-            if (newCollection != lastFiltered)
-            {
-                RequestFilter?.Invoke();
-                lastFiltered = newCollection;
             }
         }
 
@@ -214,7 +198,7 @@ namespace osu.Game.Screens.SelectV2
 
                         addOrRemoveButton.Enabled.Value = !beatmap.IsDefault;
                         addOrRemoveButton.Icon = beatmapInCollection ? FontAwesome.Solid.MinusSquare : FontAwesome.Solid.PlusSquare;
-                        addOrRemoveButton.TooltipText = beatmapInCollection ? "Remove selected beatmap" : "Add selected beatmap";
+                        addOrRemoveButton.TooltipText = beatmapInCollection ? CollectionsStrings.RemoveSelectedBeatmap : CollectionsStrings.AddSelectedBeatmap;
 
                         updateButtonVisibility();
                     }, true);
diff --git a/osu.Game/Screens/SelectV2/FilterControl.cs b/osu.Game/Screens/SelectV2/FilterControl.cs
index fdc61ad37e..c845a9e146 100644
--- a/osu.Game/Screens/SelectV2/FilterControl.cs
+++ b/osu.Game/Screens/SelectV2/FilterControl.cs
@@ -12,11 +12,15 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Collections;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select;
@@ -49,6 +53,11 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
 
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        private IBindable<APIUser> localUser = null!;
+
         public LocalisableString StatusText
         {
             get => searchTextBox.StatusText;
@@ -59,8 +68,10 @@ namespace osu.Game.Screens.SelectV2
 
         private FilterCriteria currentCriteria = null!;
 
+        private IDisposable? collectionsSubscription;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(IAPIProvider api)
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
@@ -151,14 +162,13 @@ namespace osu.Game.Screens.SelectV2
                             {
                                 new[]
                                 {
-                                    sortDropdown = new ShearedDropdown<SortMode>("Sort")
+                                    sortDropdown = new ShearedDropdown<SortMode>(SongSelectStrings.Sort)
                                     {
                                         RelativeSizeAxes = Axes.X,
                                         Items = Enum.GetValues<SortMode>(),
                                     },
                                     Empty(),
-                                    // todo: pending localisation
-                                    groupDropdown = new ShearedDropdown<GroupMode>("Group")
+                                    groupDropdown = new ShearedDropdown<GroupMode>(SongSelectStrings.Group)
                                     {
                                         RelativeSizeAxes = Axes.X,
                                         Items = Enum.GetValues<GroupMode>(),
@@ -174,6 +184,8 @@ namespace osu.Game.Screens.SelectV2
                     },
                 }
             };
+
+            localUser = api.LocalUser.GetBoundCopy();
         }
 
         protected override void LoadComplete()
@@ -209,16 +221,39 @@ namespace osu.Game.Screens.SelectV2
             showConvertedBeatmapsButton.Active.BindValueChanged(_ => updateCriteria());
             sortDropdown.Current.BindValueChanged(_ => updateCriteria());
             groupDropdown.Current.BindValueChanged(_ => updateCriteria());
-            collectionDropdown.Current.BindValueChanged(_ => updateCriteria());
+            collectionDropdown.Current.BindValueChanged(v =>
+            {
+                // The hope would be that this never arrives here, but due to bindings receiving changes before
+                // local ValueChanged events, that's not the case (see https://github.com/ppy/osu-framework/pull/1545).
+                if (v.NewValue is ManageCollectionsFilterMenuItem || v.OldValue is ManageCollectionsFilterMenuItem)
+                    return;
+
+                updateCriteria();
+            });
+            collectionsSubscription = realm.RegisterForNotifications(r => r.All<BeatmapCollection>(), (collections, changeSet) =>
+            {
+                if (changeSet != null && groupDropdown.Current.Value == GroupMode.Collections)
+                    updateCriteria();
+            });
+
+            localUser.BindValueChanged(_ => updateCriteria());
+
             updateCriteria();
         }
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            collectionsSubscription?.Dispose();
+        }
+
         /// <summary>
         /// Creates a <see cref="FilterCriteria"/> based on the current state of the controls.
         /// </summary>
         public FilterCriteria CreateCriteria()
         {
             string query = searchTextBox.Current.Value;
+            bool isValidUser = localUser.Value.Id > 1;
 
             var criteria = new FilterCriteria
             {
@@ -227,7 +262,9 @@ namespace osu.Game.Screens.SelectV2
                 AllowConvertedBeatmaps = showConvertedBeatmapsButton.Active.Value,
                 Ruleset = ruleset.Value,
                 Mods = mods.Value,
-                CollectionBeatmapMD5Hashes = collectionDropdown.Current.Value?.Collection?.PerformRead(c => c.BeatmapMD5Hashes).ToImmutableHashSet()
+                CollectionBeatmapMD5Hashes = collectionDropdown.Current.Value?.Collection?.PerformRead(c => c.BeatmapMD5Hashes).ToImmutableHashSet(),
+                LocalUserId = isValidUser ? localUser.Value.Id : null,
+                LocalUserUsername = isValidUser ? localUser.Value.Username : null,
             };
 
             if (!difficultyRangeSlider.LowerBound.IsDefault)
diff --git a/osu.Game/Screens/SelectV2/FooterButtonMods.cs b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
index 9de06988a5..4720c11731 100644
--- a/osu.Game/Screens/SelectV2/FooterButtonMods.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
@@ -73,7 +73,7 @@ namespace osu.Game.Screens.SelectV2
         [BackgroundDependencyLoader]
         private void load()
         {
-            Text = "Mods";
+            Text = SongSelectStrings.Mods;
             Icon = FontAwesome.Solid.ExchangeAlt;
             AccentColour = colours.Lime1;
 
diff --git a/osu.Game/Screens/SelectV2/FooterButtonOptions.cs b/osu.Game/Screens/SelectV2/FooterButtonOptions.cs
index 5b646312d2..3371785dd2 100644
--- a/osu.Game/Screens/SelectV2/FooterButtonOptions.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonOptions.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Screens.Footer;
 
@@ -28,7 +29,7 @@ namespace osu.Game.Screens.SelectV2
         [BackgroundDependencyLoader]
         private void load(OsuColour colour)
         {
-            Text = "Options";
+            Text = SongSelectStrings.Options;
             Icon = FontAwesome.Solid.Cog;
             AccentColour = colour.Purple1;
             Hotkey = GlobalAction.ToggleBeatmapOptions;
diff --git a/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs b/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
index 039020d7c4..022f19e6af 100644
--- a/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Screens.SelectV2
                 };
 
                 addHeader(CommonStrings.General);
-                addButton(SongSelectStrings.ManageCollections, FontAwesome.Solid.Book, () => SongSelect?.ManageCollections());
+                addButton(CollectionsStrings.ManageCollections, FontAwesome.Solid.Book, () => SongSelect?.ManageCollections());
 
                 addHeader(SongSelectStrings.ForAllDifficulties, beatmap.BeatmapSetInfo.ToString());
                 addButton(SongSelectStrings.DeleteBeatmap, FontAwesome.Solid.Trash, () => SongSelect?.Delete(beatmap.BeatmapSetInfo), colours.Red1);
diff --git a/osu.Game/Screens/SelectV2/FooterButtonRandom.cs b/osu.Game/Screens/SelectV2/FooterButtonRandom.cs
index 88b139da97..4bd42497eb 100644
--- a/osu.Game/Screens/SelectV2/FooterButtonRandom.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonRandom.cs
@@ -10,6 +10,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
 using osu.Game.Screens.Footer;
 using osuTK;
 using osuTK.Input;
@@ -46,7 +47,7 @@ namespace osu.Game.Screens.SelectV2
                         AlwaysPresent = true,
                         Anchor = Anchor.TopCentre,
                         Origin = Anchor.TopCentre,
-                        Text = "Random",
+                        Text = SongSelectStrings.Random,
                     },
                     rewindSpriteText = new OsuSpriteText
                     {
@@ -54,7 +55,7 @@ namespace osu.Game.Screens.SelectV2
                         AlwaysPresent = true,
                         Anchor = Anchor.TopCentre,
                         Origin = Anchor.TopCentre,
-                        Text = "Rewind",
+                        Text = SongSelectStrings.Rewind,
                         Alpha = 0f,
                     }
                 }
@@ -121,7 +122,7 @@ namespace osu.Game.Screens.SelectV2
 
         protected override void OnMouseUp(MouseUpEvent e)
         {
-            if (e.Button == MouseButton.Right)
+            if (e.Button == MouseButton.Right && IsHovered)
             {
                 rewindSearch = true;
                 TriggerClick();
diff --git a/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs b/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
index f3637f9949..597b6de851 100644
--- a/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
+++ b/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
@@ -87,7 +87,7 @@ namespace osu.Game.Screens.SelectV2
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
                             Font = OsuFont.Style.Title,
-                            Text = "No matching beatmaps"
+                            Text = SongSelectStrings.NoMatchingBeatmaps
                         },
                         textFlow = new LinkFlowContainer
                         {
@@ -148,7 +148,7 @@ namespace osu.Game.Screens.SelectV2
             }
             else
             {
-                textFlow.AddParagraph("No beatmaps match your filter criteria!");
+                textFlow.AddParagraph(SongSelectStrings.NoMatchingBeatmapsDescription);
                 textFlow.AddParagraph(string.Empty);
 
                 if (!string.IsNullOrEmpty(filter?.SearchText))
@@ -185,8 +185,8 @@ namespace osu.Game.Screens.SelectV2
                 {
                     addBulletPoint();
                     textFlow.AddText("Try ");
-                    textFlow.AddLink("enabling ", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
-                    textFlow.AddText("automatic conversion!");
+                    textFlow.AddLink("enabling", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
+                    textFlow.AddText(" automatic conversion!");
                 }
             }
 
diff --git a/osu.Game/Screens/SelectV2/Panel.cs b/osu.Game/Screens/SelectV2/Panel.cs
index 6a1b5cc3a6..241002fa76 100644
--- a/osu.Game/Screens/SelectV2/Panel.cs
+++ b/osu.Game/Screens/SelectV2/Panel.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.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
@@ -27,7 +28,7 @@ namespace osu.Game.Screens.SelectV2
 {
     public abstract partial class Panel : PoolableDrawable, ICarouselPanel, IHasContextMenu
     {
-        private const float corner_radius = 10;
+        public const float CORNER_RADIUS = 10;
 
         private const float active_x_offset = 25f;
 
@@ -35,9 +36,6 @@ namespace osu.Game.Screens.SelectV2
 
         protected float PanelXOffset { get; init; }
 
-        private Box backgroundBorder = null!;
-        private Box backgroundGradient = null!;
-        private Container backgroundLayerHorizontalPadding = null!;
         private Container backgroundContainer = null!;
         private Container iconContainer = null!;
 
@@ -50,6 +48,7 @@ namespace osu.Game.Screens.SelectV2
 
         public Container TopLevelContent { get; private set; } = null!;
 
+        private Container contentPaddingContainer = null!;
         protected Container Content { get; private set; } = null!;
 
         public Drawable Background
@@ -109,42 +108,14 @@ namespace osu.Game.Screens.SelectV2
             InternalChild = TopLevelContent = new Container
             {
                 Masking = true,
-                CornerRadius = corner_radius,
+                CornerRadius = CORNER_RADIUS,
                 RelativeSizeAxes = Axes.Both,
-                X = corner_radius,
-                EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Shadow,
-                    Hollow = true,
-                    Radius = 2,
-                },
+                X = CORNER_RADIUS,
                 Children = new[]
                 {
-                    backgroundBorder = new Box
+                    backgroundContainer = new Container
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.Black,
-                    },
-                    backgroundLayerHorizontalPadding = new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Child = new Container
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Masking = true,
-                            CornerRadius = corner_radius,
-                            Children = new Drawable[]
-                            {
-                                backgroundGradient = new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
-                                backgroundContainer = new Container
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
-                            }
-                        },
                     },
                     iconContainer = new Container
                     {
@@ -152,10 +123,15 @@ namespace osu.Game.Screens.SelectV2
                         Origin = Anchor.CentreLeft,
                         AutoSizeAxes = Axes.Both,
                     },
-                    Content = new Container
+                    contentPaddingContainer = new Container
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Right = PanelXOffset + corner_radius },
+                        Child = Content = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            CornerRadius = CORNER_RADIUS,
+                            Masking = true,
+                        },
                     },
                     hoverLayer = new Box
                     {
@@ -190,19 +166,17 @@ namespace osu.Game.Screens.SelectV2
                     new HoverSounds(),
                 }
             };
-
-            backgroundGradient.Colour = ColourInfo.GradientHorizontal(colourProvider.Background3, colourProvider.Background4);
         }
 
         public partial class PulsatingBox : BeatSyncedContainer
         {
-            public double FlashOffset;
+            public int FlashOffset;
 
             private readonly Box box;
 
             public PulsatingBox()
             {
-                EarlyActivationMilliseconds = 50;
+                EarlyActivationMilliseconds = 40;
 
                 InternalChildren = new Drawable[]
                 {
@@ -213,27 +187,20 @@ namespace osu.Game.Screens.SelectV2
                 };
             }
 
-            private int separation = 1;
-
             protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
             {
                 base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
 
-                if (beatIndex % separation != 0)
+                if (beatIndex % Math.Pow(2, FlashOffset) != 0)
                     return;
 
                 double length = timingPoint.BeatLength;
-                separation = 1;
 
-                while (length < 500)
-                {
+                while (length < 250)
                     length *= 2;
-                    separation *= 2;
-                }
 
                 box
-                    .Delay(FlashOffset)
-                    .FadeTo(0.8f, length / 6, Easing.Out)
+                    .FadeTo(0.8f, 40, Easing.Out)
                     .Then()
                     .FadeTo(0.4f, length, Easing.Out);
             }
@@ -276,7 +243,7 @@ namespace osu.Game.Screens.SelectV2
 
             // Slightly offset the flash animation based on the panel depth.
             // This assumes a minimum depth of -2 (groups).
-            selectionLayer.FlashOffset = (2 + Item!.DepthLayer) * 50;
+            selectionLayer.FlashOffset = -Item!.DepthLayer;
 
             updateAccentColour();
 
@@ -306,8 +273,6 @@ namespace osu.Game.Screens.SelectV2
         {
             var backgroundColour = accentColour ?? Color4.White;
 
-            backgroundBorder.Colour = backgroundColour;
-
             selectionLayer.Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), backgroundColour.Opacity(0.5f));
 
             updateSelectedState(animated: false);
@@ -318,7 +283,28 @@ namespace osu.Game.Screens.SelectV2
             bool selectedOrExpanded = Expanded.Value || Selected.Value;
 
             var edgeEffectColour = accentColour ?? Color4Extensions.FromHex(@"4EBFFF");
-            TopLevelContent.FadeEdgeEffectTo(selectedOrExpanded ? edgeEffectColour.Opacity(0.8f) : Color4.Black.Opacity(0.4f), animated ? DURATION : 0, Easing.OutQuint);
+
+            if (selectedOrExpanded)
+            {
+                TopLevelContent.EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Shadow,
+                    Radius = 2f,
+                    Hollow = true,
+                };
+            }
+            else
+            {
+                TopLevelContent.EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Shadow,
+                    Radius = 4f,
+                    Hollow = true,
+                    Offset = new Vector2(0f, 1f),
+                };
+            }
+
+            TopLevelContent.FadeEdgeEffectTo(selectedOrExpanded ? edgeEffectColour.Opacity(0.8f) : Color4.Black.Opacity(0.2f), animated ? DURATION : 0, Easing.OutQuint);
 
             if (selectedOrExpanded)
                 selectionLayer.FadeIn(100, Easing.OutQuint);
@@ -328,7 +314,7 @@ namespace osu.Game.Screens.SelectV2
 
         private void updateXOffset(bool animated = true)
         {
-            float x = PanelXOffset + corner_radius;
+            float x = PanelXOffset + CORNER_RADIUS;
 
             if (!Expanded.Value && !Selected.Value)
             {
@@ -359,8 +345,7 @@ namespace osu.Game.Screens.SelectV2
         protected override void Update()
         {
             base.Update();
-            Content.Padding = Content.Padding with { Left = iconContainer.DrawWidth };
-            backgroundLayerHorizontalPadding.Padding = new MarginPadding { Left = iconContainer.DrawWidth };
+            contentPaddingContainer.Padding = contentPaddingContainer.Padding with { Left = iconContainer.DrawWidth };
         }
 
         public abstract MenuItem[]? ContextMenuItems { get; }
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmap.cs b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
index a06c77448f..59603e145d 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmap.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -12,6 +11,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
@@ -45,10 +45,14 @@ namespace osu.Game.Screens.SelectV2
         private IBindable<StarDifficulty>? starDifficultyBindable;
         private CancellationTokenSource? starDifficultyCancellationSource;
 
-        private Box backgroundAccentGradient = null!;
+        private Box backgroundBorder = null!;
+        private Box backgroundDifficultyTint = null!;
 
         private TrianglesV2 triangles = null!;
 
+        [Resolved]
+        private IRulesetStore rulesets { get; set; } = null!;
+
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
@@ -67,6 +71,8 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private ISongSelect? songSelect { get; set; }
 
+        private BeatmapInfo beatmap => ((GroupedBeatmap)Item!.Model).Beatmap;
+
         public PanelBeatmap()
         {
             PanelXOffset = 60;
@@ -84,100 +90,105 @@ namespace osu.Game.Screens.SelectV2
                 Colour = colourProvider.Background5,
             };
 
-            Background = new Container
+            Background = backgroundBorder = new Box
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    backgroundAccentGradient = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    triangles = new TrianglesV2
-                    {
-                        ScaleAdjust = 1.2f,
-                        Thickness = 0.01f,
-                        Velocity = 0.3f,
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                }
             };
 
-            Content.Child = new FillFlowContainer
+            Content.Children = new Drawable[]
             {
-                AutoSizeAxes = Axes.Both,
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.CentreLeft,
-                Spacing = new Vector2(5),
-                Margin = new MarginPadding { Left = 6.5f },
-                Direction = FillDirection.Horizontal,
-                Children = new Drawable[]
+                new Box
                 {
-                    localRank = new PanelLocalRankDisplay
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background3, colourProvider.Background4),
+                },
+                backgroundDifficultyTint = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                triangles = new TrianglesV2
+                {
+                    ScaleAdjust = 1.2f,
+                    Thickness = 0.01f,
+                    Velocity = 0.3f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Spacing = new Vector2(5),
+                    Margin = new MarginPadding { Left = 6.5f },
+                    Direction = FillDirection.Horizontal,
+                    Children = new Drawable[]
                     {
-                        Scale = new Vector2(0.8f),
-                        Origin = Anchor.CentreLeft,
-                        Anchor = Anchor.CentreLeft,
-                    },
-                    mainFill = new FillFlowContainer
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Direction = FillDirection.Vertical,
-                        AutoSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Bottom = 3.5f },
-                        Children = new Drawable[]
+                        localRank = new PanelLocalRankDisplay
                         {
-                            new FillFlowContainer
+                            Scale = new Vector2(0.8f),
+                            Origin = Anchor.CentreLeft,
+                            Anchor = Anchor.CentreLeft,
+                        },
+                        mainFill = new FillFlowContainer
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Direction = FillDirection.Vertical,
+                            AutoSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Bottom = 3.5f },
+                            Children = new Drawable[]
                             {
-                                Direction = FillDirection.Horizontal,
-                                AutoSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Bottom = 4 },
-                                Children = new Drawable[]
+                                new FillFlowContainer
                                 {
-                                    keyCountText = new OsuSpriteText
+                                    Direction = FillDirection.Horizontal,
+                                    AutoSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding { Bottom = 4 },
+                                    Children = new Drawable[]
                                     {
-                                        Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft,
-                                        Alpha = 0,
-                                    },
-                                    difficultyText = new OsuSpriteText
-                                    {
-                                        Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft,
-                                        Margin = new MarginPadding { Right = 3f },
-                                    },
-                                    authorText = new OsuSpriteText
-                                    {
-                                        Colour = colourProvider.Content2,
-                                        Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft
-                                    }
-                                }
-                            },
-                            new FillFlowContainer
-                            {
-                                Direction = FillDirection.Horizontal,
-                                Spacing = new Vector2(3),
-                                AutoSizeAxes = Axes.Both,
-                                Children = new Drawable[]
-                                {
-                                    starRatingDisplay = new StarRatingDisplay(default, StarRatingDisplaySize.Small, animated: true)
-                                    {
-                                        Origin = Anchor.CentreLeft,
-                                        Anchor = Anchor.CentreLeft,
-                                        Scale = new Vector2(0.875f),
-                                    },
-                                    starCounter = new StarCounter
-                                    {
-                                        Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.CentreLeft,
-                                        Scale = new Vector2(0.4f)
+                                        keyCountText = new OsuSpriteText
+                                        {
+                                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            Alpha = 0,
+                                        },
+                                        difficultyText = new OsuSpriteText
+                                        {
+                                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            Margin = new MarginPadding { Right = 3f },
+                                        },
+                                        authorText = new OsuSpriteText
+                                        {
+                                            Colour = colourProvider.Content2,
+                                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft
+                                        }
                                     }
                                 },
+                                new FillFlowContainer
+                                {
+                                    Direction = FillDirection.Horizontal,
+                                    Spacing = new Vector2(3),
+                                    AutoSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
+                                    {
+                                        starRatingDisplay = new StarRatingDisplay(default, StarRatingDisplaySize.Small, animated: true)
+                                        {
+                                            Origin = Anchor.CentreLeft,
+                                            Anchor = Anchor.CentreLeft,
+                                            Scale = new Vector2(0.875f),
+                                        },
+                                        starCounter = new StarCounter
+                                        {
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                            Scale = new Vector2(0.4f)
+                                        }
+                                    },
+                                }
                             }
                         }
                     }
@@ -189,27 +200,15 @@ namespace osu.Game.Screens.SelectV2
         {
             base.LoadComplete();
 
-            ruleset.BindValueChanged(_ =>
-            {
-                computeStarRating();
-                updateKeyCount();
-            });
-
-            mods.BindValueChanged(_ =>
-            {
-                computeStarRating();
-                updateKeyCount();
-            }, true);
+            ruleset.BindValueChanged(_ => updateKeyCount());
+            mods.BindValueChanged(_ => updateKeyCount(), true);
         }
 
         protected override void PrepareForUse()
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-            var beatmap = (BeatmapInfo)Item.Model;
-
-            difficultyIcon.Icon = beatmap.Ruleset.CreateInstance().CreateIcon();
+            difficultyIcon.Icon = getRulesetIcon(beatmap.Ruleset);
 
             localRank.Beatmap = beatmap;
             difficultyText.Text = beatmap.DifficultyName;
@@ -219,6 +218,16 @@ namespace osu.Game.Screens.SelectV2
             updateKeyCount();
         }
 
+        private Drawable getRulesetIcon(RulesetInfo rulesetInfo)
+        {
+            var rulesetInstance = rulesets.GetRuleset(rulesetInfo.ShortName)?.CreateInstance();
+
+            if (rulesetInstance is null)
+                return new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle };
+
+            return rulesetInstance.CreateIcon();
+        }
+
         protected override void FreeAfterUse()
         {
             base.FreeAfterUse();
@@ -237,9 +246,7 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
-            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
             starDifficultyBindable.BindValueChanged(starDifficulty =>
             {
                 starRatingDisplay.Current.Value = starDifficulty.NewValue;
@@ -268,7 +275,8 @@ namespace osu.Game.Screens.SelectV2
                 AccentColour = diffColour;
                 starCounter.Colour = diffColour;
 
-                backgroundAccentGradient.Colour = ColourInfo.GradientHorizontal(diffColour.Opacity(0.25f), diffColour.Opacity(0f));
+                backgroundBorder.Colour = diffColour;
+                backgroundDifficultyTint.Colour = ColourInfo.GradientHorizontal(diffColour.Opacity(0.25f), diffColour.Opacity(0f));
 
                 difficultyIcon.Colour = starRatingDisplay.DisplayedStars.Value > OsuColour.STAR_DIFFICULTY_DEFINED_COLOUR_CUTOFF ? colours.Orange1 : colourProvider.Background5;
 
@@ -281,8 +289,6 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
             if (ruleset.Value.OnlineID == 3)
             {
                 // Account for mania differences locally for now.
@@ -307,7 +313,7 @@ namespace osu.Game.Screens.SelectV2
                 List<MenuItem> items = new List<MenuItem>();
 
                 if (songSelect != null)
-                    items.AddRange(songSelect.GetForwardActions((BeatmapInfo)Item.Model));
+                    items.AddRange(songSelect.GetForwardActions(beatmap));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
index 2864980fce..1a6e886cb7 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
@@ -7,8 +7,10 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
@@ -25,6 +27,8 @@ using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osuTK;
+using osuTK.Graphics;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -32,7 +36,8 @@ namespace osu.Game.Screens.SelectV2
     {
         public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.6f;
 
-        private PanelSetBackground background = null!;
+        private Box chevronBackground = null!;
+        private PanelSetBackground setBackground = null!;
 
         private OsuSpriteText titleText = null!;
         private OsuSpriteText artistText = null!;
@@ -62,6 +67,15 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; } = null!;
 
+        private GroupedBeatmapSet groupedBeatmapSet
+        {
+            get
+            {
+                Debug.Assert(Item != null);
+                return (GroupedBeatmapSet)Item!.Model;
+            }
+        }
+
         public PanelBeatmapSet()
         {
             PanelXOffset = 20f;
@@ -86,13 +100,16 @@ namespace osu.Game.Screens.SelectV2
                 },
             };
 
-            Background = background = new PanelSetBackground
+            Background = chevronBackground = new Box
             {
                 RelativeSizeAxes = Axes.Both,
+                Colour = Color4.White,
+                Alpha = 0f,
             };
 
-            Content.Children = new[]
+            Content.Children = new Drawable[]
             {
+                setBackground = new PanelSetBackground(),
                 new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,
@@ -155,11 +172,13 @@ namespace osu.Game.Screens.SelectV2
         {
             if (Expanded.Value)
             {
-                chevronIcon.ResizeWidthTo(18, 600, Easing.OutElasticQuarter);
+                chevronBackground.FadeIn(DURATION / 2, Easing.OutQuint);
+                chevronIcon.ResizeWidthTo(18, DURATION * 1.5f, Easing.OutElasticQuarter);
                 chevronIcon.FadeTo(1f, DURATION, Easing.OutQuint);
             }
             else
             {
+                chevronBackground.FadeOut(DURATION, Easing.OutQuint);
                 chevronIcon.ResizeWidthTo(0f, DURATION, Easing.OutQuint);
                 chevronIcon.FadeTo(0f, DURATION, Easing.OutQuint);
             }
@@ -169,12 +188,10 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-
-            var beatmapSet = (BeatmapSetInfo)Item.Model;
+            var beatmapSet = groupedBeatmapSet.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));
+            setBackground.Beatmap = beatmaps.GetWorkingBeatmap(beatmapSet.Beatmaps.MinBy(b => b.OnlineID));
 
             titleText.Text = new RomanisableString(beatmapSet.Metadata.TitleUnicode, beatmapSet.Metadata.Title);
             artistText.Text = new RomanisableString(beatmapSet.Metadata.ArtistUnicode, beatmapSet.Metadata.Artist);
@@ -187,7 +204,7 @@ namespace osu.Game.Screens.SelectV2
         {
             base.FreeAfterUse();
 
-            background.Beatmap = null;
+            setBackground.Beatmap = null;
             updateButton.BeatmapSet = null;
             difficultiesDisplay.BeatmapSet = null;
         }
@@ -205,19 +222,31 @@ namespace osu.Game.Screens.SelectV2
                 if (Item == null)
                     return Array.Empty<MenuItem>();
 
-                var beatmapSet = (BeatmapSetInfo)Item.Model;
+                var beatmapSet = groupedBeatmapSet.BeatmapSet;
 
                 List<MenuItem> items = new List<MenuItem>();
 
-                if (!Expanded.Value)
+                if (Expanded.Value)
                 {
-                    items.Add(new OsuMenuItem("Expand", MenuItemType.Highlighted, () => TriggerClick()));
+                    if (songSelect is SoloSongSelect soloSongSelect)
+                    {
+                        // Assume the current set has one of its beatmaps selected since it is expanded.
+                        items.Add(new OsuMenuItem(ButtonSystemStrings.Edit.ToSentence(), MenuItemType.Standard, () => soloSongSelect.Edit(soloSongSelect.Beatmap.Value.BeatmapInfo))
+                        {
+                            Icon = FontAwesome.Solid.PencilAlt
+                        });
+                        items.Add(new OsuMenuItemSpacer());
+                    }
+                }
+                else
+                {
+                    items.Add(new OsuMenuItem(WebCommonStrings.ButtonsExpand.ToSentence(), MenuItemType.Highlighted, () => TriggerClick()));
                     items.Add(new OsuMenuItemSpacer());
                 }
 
                 if (beatmapSet.OnlineID > 0)
                 {
-                    items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmapSet(beatmapSet.OnlineID)));
+                    items.Add(new OsuMenuItem(CommonStrings.Details, MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmapSet(beatmapSet.OnlineID)));
 
                     if (beatmapSet.GetOnlineURL(api, ruleset.Value) is string url)
                         items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => game?.CopyToClipboard(url)));
@@ -232,23 +261,21 @@ namespace osu.Game.Screens.SelectV2
                                            .ToList();
 
                 if (manageCollectionsDialog != null)
-                    collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, manageCollectionsDialog.Show));
+                    collectionItems.Add(new OsuMenuItem(CommonStrings.Manage, MenuItemType.Standard, manageCollectionsDialog.Show));
 
                 items.Add(new OsuMenuItem(CommonStrings.Collections) { Items = collectionItems });
 
                 if (beatmapSet.Beatmaps.Any(b => b.Hidden))
-                    items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => songSelect?.RestoreAllHidden(beatmapSet)));
+                    items.Add(new OsuMenuItem(SongSelectStrings.RestoreAllHidden, MenuItemType.Standard, () => songSelect?.RestoreAllHidden(beatmapSet)));
 
-                items.Add(new OsuMenuItem("Delete...", MenuItemType.Destructive, () => songSelect?.Delete(beatmapSet)));
+                items.Add(new OsuMenuItem(SongSelectStrings.DeleteBeatmap, MenuItemType.Destructive, () => songSelect?.Delete(beatmapSet)));
                 return items.ToArray();
             }
         }
 
         private MenuItem createCollectionMenuItem(BeatmapCollection collection)
         {
-            var beatmapSet = (BeatmapSetInfo)Item!.Model;
-
-            Debug.Assert(beatmapSet != null);
+            var beatmapSet = groupedBeatmapSet.BeatmapSet;
 
             TernaryState state;
 
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
index 28a6bfc83a..4ac05c0308 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
@@ -3,13 +3,12 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -55,7 +54,7 @@ namespace osu.Game.Screens.SelectV2
         private IBindable<StarDifficulty>? starDifficultyBindable;
         private CancellationTokenSource? starDifficultyCancellationSource;
 
-        private PanelSetBackground background = null!;
+        private PanelSetBackground beatmapBackground = null!;
 
         private OsuSpriteText titleText = null!;
         private OsuSpriteText artistText = null!;
@@ -71,6 +70,10 @@ namespace osu.Game.Screens.SelectV2
         private OsuSpriteText authorText = null!;
         private FillFlowContainer mainFill = null!;
 
+        private Box backgroundBorder = null!;
+
+        private BeatmapInfo beatmap => ((GroupedBeatmap)Item!.Model).Beatmap;
+
         public PanelBeatmapStandalone()
         {
             PanelXOffset = 20;
@@ -88,110 +91,114 @@ namespace osu.Game.Screens.SelectV2
                 Colour = colourProvider.Background5,
             };
 
-            Background = background = new PanelSetBackground
+            Background = backgroundBorder = new Box
             {
                 RelativeSizeAxes = Axes.Both,
             };
 
-            Content.Child = new FillFlowContainer
+            Content.Children = new Drawable[]
             {
-                AutoSizeAxes = Axes.Both,
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.CentreLeft,
-                Spacing = new Vector2(5),
-                Margin = new MarginPadding { Left = 6.5f },
-                Direction = FillDirection.Horizontal,
-                Children = new Drawable[]
+                beatmapBackground = new PanelSetBackground(),
+                new FillFlowContainer
                 {
-                    localRank = new PanelLocalRankDisplay
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Spacing = new Vector2(5),
+                    Margin = new MarginPadding { Left = 6.5f },
+                    Direction = FillDirection.Horizontal,
+                    Children = new Drawable[]
                     {
-                        Scale = new Vector2(0.8f),
-                        Origin = Anchor.CentreLeft,
-                        Anchor = Anchor.CentreLeft,
-                    },
-                    mainFill = new FillFlowContainer
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Direction = FillDirection.Vertical,
-                        Padding = new MarginPadding { Bottom = 4.8f },
-                        AutoSizeAxes = Axes.Both,
-                        Children = new Drawable[]
+                        localRank = new PanelLocalRankDisplay
                         {
-                            titleText = new OsuSpriteText
+                            Scale = new Vector2(0.8f),
+                            Origin = Anchor.CentreLeft,
+                            Anchor = Anchor.CentreLeft,
+                        },
+                        mainFill = new FillFlowContainer
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Direction = FillDirection.Vertical,
+                            Padding = new MarginPadding { Bottom = 4.8f },
+                            AutoSizeAxes = Axes.Both,
+                            Children = new Drawable[]
                             {
-                                Font = OsuFont.Style.Heading2.With(typeface: Typeface.TorusAlternate, weight: FontWeight.Bold),
-                            },
-                            artistText = new OsuSpriteText
-                            {
-                                Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                Padding = new MarginPadding { Top = -2 },
-                            },
-                            new FillFlowContainer
-                            {
-                                Direction = FillDirection.Horizontal,
-                                AutoSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Top = 2, Bottom = 2 },
-                                Children = new Drawable[]
+                                titleText = new OsuSpriteText
                                 {
-                                    statusPill = new BeatmapSetOnlineStatusPill
-                                    {
-                                        Animated = false,
-                                        Origin = Anchor.BottomLeft,
-                                        Anchor = Anchor.BottomLeft,
-                                        TextSize = OsuFont.Style.Caption2.Size,
-                                        Margin = new MarginPadding { Right = 4f },
-                                    },
-                                    updateButton = new PanelUpdateBeatmapButton
-                                    {
-                                        Scale = new Vector2(0.8f),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft,
-                                        Margin = new MarginPadding { Right = 4f, Bottom = -1f },
-                                    },
-                                    keyCountText = new OsuSpriteText
-                                    {
-                                        Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft,
-                                        Alpha = 0,
-                                    },
-                                    difficultyText = new OsuSpriteText
-                                    {
-                                        Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft,
-                                        Margin = new MarginPadding { Right = 3f },
-                                    },
-                                    authorText = new OsuSpriteText
-                                    {
-                                        Colour = colourProvider.Content2,
-                                        Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
-                                        Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft
-                                    }
-                                }
-                            },
-                            new FillFlowContainer
-                            {
-                                Direction = FillDirection.Horizontal,
-                                Spacing = new Vector2(3),
-                                AutoSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                    Font = OsuFont.Style.Heading2.With(typeface: Typeface.TorusAlternate, weight: FontWeight.Bold),
+                                },
+                                artistText = new OsuSpriteText
                                 {
-                                    starRatingDisplay = new StarRatingDisplay(default, StarRatingDisplaySize.Small, animated: true)
+                                    Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                    Padding = new MarginPadding { Top = -2 },
+                                },
+                                new FillFlowContainer
+                                {
+                                    Direction = FillDirection.Horizontal,
+                                    AutoSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding { Top = 2, Bottom = 2 },
+                                    Children = new Drawable[]
                                     {
-                                        Origin = Anchor.CentreLeft,
-                                        Anchor = Anchor.CentreLeft,
-                                        Scale = new Vector2(0.875f),
-                                    },
-                                    starCounter = new StarCounter
-                                    {
-                                        Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.CentreLeft,
-                                        Scale = new Vector2(0.4f)
+                                        statusPill = new BeatmapSetOnlineStatusPill
+                                        {
+                                            Animated = false,
+                                            Origin = Anchor.BottomLeft,
+                                            Anchor = Anchor.BottomLeft,
+                                            TextSize = OsuFont.Style.Caption2.Size,
+                                            Margin = new MarginPadding { Right = 4f },
+                                        },
+                                        updateButton = new PanelUpdateBeatmapButton
+                                        {
+                                            Scale = new Vector2(0.8f),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            Margin = new MarginPadding { Right = 4f, Bottom = -1f },
+                                        },
+                                        keyCountText = new OsuSpriteText
+                                        {
+                                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            Alpha = 0,
+                                        },
+                                        difficultyText = new OsuSpriteText
+                                        {
+                                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            Margin = new MarginPadding { Right = 3f },
+                                        },
+                                        authorText = new OsuSpriteText
+                                        {
+                                            Colour = colourProvider.Content2,
+                                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft
+                                        }
                                     }
                                 },
+                                new FillFlowContainer
+                                {
+                                    Direction = FillDirection.Horizontal,
+                                    Spacing = new Vector2(3),
+                                    AutoSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
+                                    {
+                                        starRatingDisplay = new StarRatingDisplay(default, StarRatingDisplaySize.Small, animated: true)
+                                        {
+                                            Origin = Anchor.CentreLeft,
+                                            Anchor = Anchor.CentreLeft,
+                                            Scale = new Vector2(0.875f),
+                                        },
+                                        starCounter = new StarCounter
+                                        {
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                            Scale = new Vector2(0.4f)
+                                        }
+                                    },
+                                }
                             }
                         }
                     }
@@ -203,17 +210,8 @@ namespace osu.Game.Screens.SelectV2
         {
             base.LoadComplete();
 
-            ruleset.BindValueChanged(_ =>
-            {
-                computeStarRating();
-                updateKeyCount();
-            });
-
-            mods.BindValueChanged(_ =>
-            {
-                computeStarRating();
-                updateKeyCount();
-            }, true);
+            ruleset.BindValueChanged(_ => updateKeyCount());
+            mods.BindValueChanged(_ => updateKeyCount(), true);
 
             Selected.BindValueChanged(s => Expanded.Value = s.NewValue, true);
         }
@@ -222,18 +220,14 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-
-            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));
+            beatmapBackground.Beatmap = beatmaps.GetWorkingBeatmap(beatmap);
 
             titleText.Text = new RomanisableString(beatmapSet.Metadata.TitleUnicode, beatmapSet.Metadata.Title);
             artistText.Text = new RomanisableString(beatmapSet.Metadata.ArtistUnicode, beatmapSet.Metadata.Artist);
             updateButton.BeatmapSet = beatmapSet;
-            statusPill.Status = beatmapSet.Status;
+            statusPill.Status = beatmap.Status;
 
             difficultyIcon.Icon = beatmap.Ruleset.CreateInstance().CreateIcon();
             difficultyIcon.Show();
@@ -250,7 +244,7 @@ namespace osu.Game.Screens.SelectV2
         {
             base.FreeAfterUse();
 
-            background.Beatmap = null;
+            beatmapBackground.Beatmap = null;
             updateButton.BeatmapSet = null;
             localRank.Beatmap = null;
             starDifficultyBindable = null;
@@ -266,9 +260,7 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
-            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
             starDifficultyBindable.BindValueChanged(starDifficulty =>
             {
                 starRatingDisplay.Current.Value = starDifficulty.NewValue;
@@ -295,6 +287,7 @@ namespace osu.Game.Screens.SelectV2
             AccentColour = diffColour;
             starCounter.Colour = diffColour;
 
+            backgroundBorder.Colour = diffColour;
             difficultyIcon.Colour = starRatingDisplay.DisplayedStars.Value > OsuColour.STAR_DIFFICULTY_DEFINED_COLOUR_CUTOFF ? colours.Orange1 : colourProvider.Background5;
         }
 
@@ -303,8 +296,6 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
             if (ruleset.Value.OnlineID == 3)
             {
                 // Account for mania differences locally for now.
@@ -329,7 +320,7 @@ namespace osu.Game.Screens.SelectV2
                 List<MenuItem> items = new List<MenuItem>();
 
                 if (songSelect != null)
-                    items.AddRange(songSelect.GetForwardActions((BeatmapInfo)Item.Model));
+                    items.AddRange(songSelect.GetForwardActions(beatmap));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Screens/SelectV2/PanelGroup.cs b/osu.Game/Screens/SelectV2/PanelGroup.cs
index b7288f1da4..d2ae495610 100644
--- a/osu.Game/Screens/SelectV2/PanelGroup.cs
+++ b/osu.Game/Screens/SelectV2/PanelGroup.cs
@@ -5,6 +5,7 @@ using System;
 using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
@@ -19,6 +20,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -45,6 +47,7 @@ namespace osu.Game.Screens.SelectV2
             {
                 AlwaysPresent = true,
                 RelativeSizeAxes = Axes.Y,
+                Alpha = 0f,
                 Child = new SpriteIcon
                 {
                     Anchor = Anchor.Centre,
@@ -54,34 +57,34 @@ namespace osu.Game.Screens.SelectV2
                     Colour = colourProvider.Background3,
                 },
             };
-            Background = new Container
+
+            Background = new Box
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colourProvider.Background5,
-                    },
-                    triangles = new TrianglesV2
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Thickness = 0.02f,
-                        SpawnRatio = 0.6f,
-                        Colour = ColourInfo.GradientHorizontal(colourProvider.Background6, colourProvider.Background5)
-                    },
-                    glow = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Width = 0.5f,
-                        Colour = ColourInfo.GradientHorizontal(colourProvider.Highlight1, colourProvider.Highlight1.Opacity(0f)),
-                    },
-                },
+                Colour = colourProvider.Highlight1,
             };
+
             AccentColour = colourProvider.Highlight1;
             Content.Children = new Drawable[]
             {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5,
+                },
+                triangles = new TrianglesV2
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Thickness = 0.02f,
+                    SpawnRatio = 0.6f,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background6, colourProvider.Background5)
+                },
+                glow = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Highlight1, colourProvider.Highlight1.Opacity(0f)),
+                },
                 titleText = new OsuSpriteText
                 {
                     Anchor = Anchor.CentreLeft,
@@ -167,7 +170,7 @@ namespace osu.Game.Screens.SelectV2
 
                 return new MenuItem[]
                 {
-                    new OsuMenuItem(Expanded.Value ? "Collapse" : "Expand", MenuItemType.Highlighted, () => TriggerClick())
+                    new OsuMenuItem(Expanded.Value ? WebCommonStrings.ButtonsCollapse.ToSentence() : WebCommonStrings.ButtonsExpand.ToSentence(), MenuItemType.Highlighted, () => TriggerClick())
                 };
             }
         }
diff --git a/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs b/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
index 622fbaa37e..e6b59334cd 100644
--- a/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
+++ b/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
@@ -19,6 +19,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -33,6 +34,7 @@ namespace osu.Game.Screens.SelectV2
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
         private Drawable iconContainer = null!;
+        private Box backgroundBorder = null!;
         private Box contentBackground = null!;
         private OsuSpriteText starRatingText = null!;
         private CircularContainer countPill = null!;
@@ -49,6 +51,7 @@ namespace osu.Game.Screens.SelectV2
             {
                 AlwaysPresent = true,
                 RelativeSizeAxes = Axes.Y,
+                Alpha = 0f,
                 Child = new SpriteIcon
                 {
                     Anchor = Anchor.Centre,
@@ -57,31 +60,33 @@ namespace osu.Game.Screens.SelectV2
                     Size = new Vector2(12),
                 },
             };
-            Background = new Container
+
+            Background = backgroundBorder = new Box
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    contentBackground = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                    triangles = new TrianglesV2
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Thickness = 0.02f,
-                        SpawnRatio = 0.6f,
-                    },
-                    glow = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Width = 0.5f,
-                    },
-                },
+                Colour = colourProvider.Highlight1,
             };
+
             AccentColour = colourProvider.Highlight1;
             Content.Children = new Drawable[]
             {
+                contentBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                triangles = new TrianglesV2
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Thickness = 0.02f,
+                    SpawnRatio = 0.6f,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background6, colourProvider.Background5)
+                },
+                glow = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Highlight1, colourProvider.Highlight1.Opacity(0f)),
+                },
                 new FillFlowContainer
                 {
                     Anchor = Anchor.CentreLeft,
@@ -147,6 +152,7 @@ namespace osu.Game.Screens.SelectV2
             ratingColour = starNumber >= 9 ? OsuColour.Gray(0.2f) : colours.ForStarDifficulty(starNumber);
 
             AccentColour = ratingColour;
+            backgroundBorder.Colour = ratingColour;
             contentBackground.Colour = ratingColour.Darken(1f);
             glow.Colour = ColourInfo.GradientHorizontal(ratingColour, ratingColour.Opacity(0f));
 
@@ -210,7 +216,7 @@ namespace osu.Game.Screens.SelectV2
 
                 return new MenuItem[]
                 {
-                    new OsuMenuItem(Expanded.Value ? "Collapse" : "Expand", MenuItemType.Highlighted, () => TriggerClick())
+                    new OsuMenuItem(Expanded.Value ? WebCommonStrings.ButtonsCollapse.ToSentence() : WebCommonStrings.ButtonsExpand.ToSentence(), MenuItemType.Highlighted, () => TriggerClick())
                 };
             }
         }
diff --git a/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
index 130c1cd05a..c72835144f 100644
--- a/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
+++ b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Rulesets;
@@ -54,7 +53,7 @@ namespace osu.Game.Screens.SelectV2
         {
             AutoSizeAxes = Axes.Both;
 
-            InternalChild = updateable = new UpdateableRank
+            InternalChild = updateable = new UpdateableRank(animate: false)
             {
                 Size = new Vector2(40, 20),
                 Alpha = 0,
@@ -78,12 +77,9 @@ namespace osu.Game.Screens.SelectV2
                 return;
 
             scoreSubscription = realm.RegisterForNotifications(r =>
-                    r.All<ScoreInfo>()
-                     .Filter($"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                             + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                             + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                             + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $2"
-                             + $" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, beatmap.ID, ruleset.Value.ShortName),
+                    r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                     .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
+                             + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1", beatmap.ID, ruleset.Value.ShortName),
                 localScoresChanged);
         }
 
diff --git a/osu.Game/Screens/SelectV2/PanelSetBackground.cs b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
index ea82755810..1b49f48ea6 100644
--- a/osu.Game/Screens/SelectV2/PanelSetBackground.cs
+++ b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
+using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
 
@@ -36,7 +37,21 @@ namespace osu.Game.Screens.SelectV2
             get => working;
             set
             {
-                if (value == working)
+                if (working == null && value == null)
+                    return;
+
+                // this guard papers over excessive refreshes of the background asset which occur if `working == value` type guards are used.
+                // the root cause of why `working == value` type guards fail here is that `SongSelect` will invalidate working beatmaps very often
+                // (via https://github.com/ppy/osu/blob/d3ae20dd882381e109c20ca00ee5237e4dd1750d/osu.Game/Screens/SelectV2/SongSelect.cs#L506-L507),
+                // due to a variety of causes, ranging from "someone typed a letter in the search box" (which triggers a refilter -> presentation of new items -> `ensureGlobalBeatmapValid()`),
+                // to "someone just went into the editor and replaced every single file in the set, including the background".
+                // the following guard approximates the most appropriate debounce criterion, which is the contents of the actual asset that is supposed to be displayed in the background,
+                // i.e. if the hash of the new background file matches the old, then we do not bother updating the working beatmap here.
+                //
+                // note that this is basically a reimplementation of the caching scheme in `WorkingBeatmapCache.getBackgroundFromStore()`,
+                // which cannot be used directly by retrieving the texture and checking texture reference equality,
+                // because missing the cache would incur a synchronous texture load on the update thread.
+                if (getBackgroundFileHash(working) == getBackgroundFileHash(value))
                     return;
 
                 working = value;
@@ -51,9 +66,17 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
+        private static string? getBackgroundFileHash(WorkingBeatmap? working)
+            => working?.BeatmapSetInfo.GetFile(working.Metadata.BackgroundFile)?.File.Hash;
+
         public PanelSetBackground()
         {
             RelativeSizeAxes = Axes.Both;
+            CornerRadius = Panel.CORNER_RADIUS;
+            Masking = true;
+
+            // Add some level of smoothness around the rounded edges to give more visual polish (make it anti-aliased).
+            MaskingSmoothness = 2f;
         }
 
         protected override void Update()
@@ -64,10 +87,16 @@ namespace osu.Game.Screens.SelectV2
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider colourProvider)
         {
             InternalChildren = new Drawable[]
             {
+                new Box
+                {
+                    Depth = 1,
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background3, colourProvider.Background4),
+                },
                 new FillFlowContainer
                 {
                     Depth = -1,
@@ -133,7 +162,6 @@ namespace osu.Game.Screens.SelectV2
 
             LoadComponentAsync(new PanelBeatmapBackground(working)
             {
-                Depth = float.MaxValue,
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
diff --git a/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
index b133da71f7..e7204eefaf 100644
--- a/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
+++ b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
@@ -9,16 +9,19 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Screens.Select.Carousel;
 using osuTK;
 using osuTK.Graphics;
+using CommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -55,7 +58,8 @@ namespace osu.Game.Screens.SelectV2
 
         public PanelUpdateBeatmapButton()
         {
-            Size = new Vector2(72, 22f);
+            AutoSizeAxes = Axes.X;
+            Height = 22f;
         }
 
         private Bindable<bool> preferNoVideo = null!;
@@ -109,7 +113,7 @@ namespace osu.Game.Screens.SelectV2
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
                             Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
-                            Text = "Update",
+                            Text = CommonStrings.ButtonsUpdate,
                         }
                     }
                 },
@@ -132,16 +136,18 @@ namespace osu.Game.Screens.SelectV2
 
         protected override bool OnHover(HoverEvent e)
         {
-            icon.Spin(400, RotationDirection.Clockwise);
+            icon.Spin(400, RotationDirection.Clockwise, icon.Rotation);
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            icon.Spin(4000, RotationDirection.Clockwise);
+            icon.Spin(4000, RotationDirection.Clockwise, icon.Rotation);
             base.OnHoverLost(e);
         }
 
+        public override LocalisableString TooltipText => Enabled.Value ? SongSelectStrings.UpdateBeatmapTooltip : string.Empty;
+
         private bool updateConfirmed;
 
         private void performUpdate()
@@ -179,7 +185,6 @@ namespace osu.Game.Screens.SelectV2
             if (download != null)
             {
                 Enabled.Value = false;
-                TooltipText = string.Empty;
 
                 download.DownloadProgressed += progress => progressFill.ResizeWidthTo(progress, 100, Easing.OutQuint);
                 download.Failure += _ => attachExistingDownload();
@@ -187,7 +192,6 @@ namespace osu.Game.Screens.SelectV2
             else
             {
                 Enabled.Value = true;
-                TooltipText = "Update beatmap with online changes";
 
                 progressFill.ResizeWidthTo(0, 100, Easing.OutQuint);
             }
diff --git a/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs b/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs
new file mode 100644
index 0000000000..832095058a
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs
@@ -0,0 +1,118 @@
+// 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 System.Threading;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Extensions;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using Realms;
+
+namespace osu.Game.Screens.SelectV2
+{
+    /// <summary>
+    /// This component is designed to perform lookups of online data
+    /// and store portions of it for later local use to the realm database.
+    /// </summary>
+    /// <example>
+    /// This component is designed to locally persist potentially-volatile online information such as:
+    /// <list type="bullet">
+    /// <item>user tags assigned to difficulties of a beatmap,</item>
+    /// <item>the beatmap's <see cref="BeatmapInfo.Status"/>,</item>
+    /// <item>guest mappers assigned to difficulties of a beatmap,</item>
+    /// <item>the local user's best score on a given beatmap.</item>
+    /// </list>
+    /// </example>
+    public partial class RealmPopulatingOnlineLookupSource : Component
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        public Task<APIBeatmapSet?> GetBeatmapSetAsync(int id, CancellationToken token = default)
+        {
+            var request = new GetBeatmapSetRequest(id);
+            var tcs = new TaskCompletionSource<APIBeatmapSet?>();
+
+            token.Register(() => request.Cancel());
+
+            // async request success callback is a bit of a dangerous game, but there's some reasoning for it.
+            // - don't really want to use `IAPIAccess.PerformAsync()` because we still want to respect request queueing & online status checks
+            // - we want the realm write here to be async because it is known to be slow for some users with large beatmap collections
+            // - at the time of writing `RealmAccess.WriteAsync()` can only be safely called from update thread,
+            //   and API request completion callbacks are automatically marshaled onto update thread scheduler,
+            //   so calling `WriteAsync()` within the callback is a somewhat "nice" way of guaranteeing that the call is safe
+            //   (rather than having to enforce that `GetBeatmapSetAsync()` can only be called from update thread, or locally scheduling)
+            request.Success += async onlineBeatmapSet =>
+            {
+                if (token.IsCancellationRequested)
+                {
+                    tcs.SetCanceled(token);
+                    return;
+                }
+
+                await realm.WriteAsync(r => updateRealmBeatmapSet(r, onlineBeatmapSet)).ConfigureAwait(true);
+                tcs.SetResult(onlineBeatmapSet);
+            };
+            request.Failure += tcs.SetException;
+            api.Queue(request);
+            return tcs.Task;
+        }
+
+        private static void updateRealmBeatmapSet(Realm r, APIBeatmapSet onlineBeatmapSet)
+        {
+            var tagsById = (onlineBeatmapSet.RelatedTags ?? []).ToDictionary(t => t.Id);
+            var onlineBeatmaps = onlineBeatmapSet.Beatmaps.ToDictionary(b => b.OnlineID);
+
+            var dbBeatmapSets = r.All<BeatmapSetInfo>().Where(b => b.OnlineID == onlineBeatmapSet.OnlineID);
+
+            foreach (var dbBeatmapSet in dbBeatmapSets)
+            {
+                // note that every single write to realm models is preceded by a guard, even if it technically would write the same value back.
+                // the reason this matters is that doing so avoids triggering realm subscription callbacks.
+                // unfortunately in terms of subscriptions realm treats *every* write to any realm object as a modification,
+                // even if the write was redundant and had no observable effect.
+
+                if (dbBeatmapSet.Status != onlineBeatmapSet.Status)
+                    dbBeatmapSet.Status = onlineBeatmapSet.Status;
+
+                foreach (var dbBeatmap in dbBeatmapSet.Beatmaps)
+                {
+                    if (onlineBeatmaps.TryGetValue(dbBeatmap.OnlineID, out var onlineBeatmap))
+                    {
+                        // compare `BeatmapUpdaterMetadataLookup`
+                        if (dbBeatmap.OnlineMD5Hash != onlineBeatmap.MD5Hash)
+                            dbBeatmap.OnlineMD5Hash = onlineBeatmap.MD5Hash;
+
+                        if (dbBeatmap.LastOnlineUpdate != onlineBeatmap.LastUpdated)
+                            dbBeatmap.LastOnlineUpdate = onlineBeatmap.LastUpdated;
+
+                        if (dbBeatmap.MatchesOnlineVersion && dbBeatmap.Status != onlineBeatmap.Status)
+                            dbBeatmap.Status = onlineBeatmap.Status;
+
+                        HashSet<string> userTags = onlineBeatmap.TopTags?
+                                                                .Select(t => (topTag: t, relatedTag: tagsById.GetValueOrDefault(t.TagId)))
+                                                                .Where(t => t.relatedTag != null)
+                                                                .Select(t => t.relatedTag!.Name)
+                                                                .ToHashSet() ?? [];
+
+                        if (!userTags.SetEquals(dbBeatmap.Metadata.UserTags))
+                        {
+                            dbBeatmap.Metadata.UserTags.Clear();
+                            dbBeatmap.Metadata.UserTags.AddRange(userTags);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/SoloSongSelect.cs b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
index 4c4df7f389..d39b5abe57 100644
--- a/osu.Game/Screens/SelectV2/SoloSongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
@@ -20,6 +20,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Select;
+using osu.Game.Users;
 using osu.Game.Utils;
 using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
@@ -27,6 +28,8 @@ namespace osu.Game.Screens.SelectV2
 {
     public partial class SoloSongSelect : SongSelect
     {
+        protected override UserActivity InitialActivity => new UserActivity.ChoosingBeatmap();
+
         private PlayerLoader? playerLoader;
         private IReadOnlyList<Mod>? modsAtGameplayStart;
 
@@ -67,7 +70,7 @@ namespace osu.Game.Screens.SelectV2
 
             if (beatmap.OnlineID > 0)
             {
-                yield return new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmap(beatmap.OnlineID));
+                yield return new OsuMenuItem(CommonStrings.Details, MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmap(beatmap.OnlineID));
 
                 if (beatmap.GetOnlineURL(api, Ruleset.Value) is string url)
                     yield return new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => game?.CopyToClipboard(url));
@@ -84,7 +87,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..cc8c6afec2 100644
--- a/osu.Game/Screens/SelectV2/SongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -5,11 +5,15 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
+using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -34,6 +38,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Volume;
@@ -59,9 +64,20 @@ namespace osu.Game.Screens.SelectV2
     [Cached(typeof(ISongSelect))]
     public abstract partial class SongSelect : ScreenWithBeatmapBackground, IKeyBindingHandler<GlobalAction>, ISongSelect
     {
-        // this is intentionally slightly higher than key repeat, but low enough to not impede user experience.
-        // this avoids rapid churn loading when iterating the carousel using keyboard.
-        public const int SELECTION_DEBOUNCE = 100;
+        /// <summary>
+        /// A debounce that governs how long after a panel is selected before the rest of song select (and the game at large)
+        /// updates to show that selection.
+        ///
+        /// This is intentionally slightly higher than key repeat, but low enough to not impede user experience.
+        /// </summary>
+        public const int SELECTION_DEBOUNCE = 150;
+
+        /// <summary>
+        /// A general "global" debounce to be applied to anything aggressive difficulty calculation at song select,
+        /// either after selection or after a panel comes on screen. Value should be low enough that users don't complain,
+        /// but otherwise as high as possible to reduce overheads.
+        /// </summary>
+        public const int DIFFICULTY_CALCULATION_DEBOUNCE = 150;
 
         private const float logo_scale = 0.4f;
         private const double fade_duration = 300;
@@ -133,6 +149,8 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
+        private readonly RealmPopulatingOnlineLookupSource onlineLookupSource = new RealmPopulatingOnlineLookupSource();
+
         private Bindable<bool> configBackgroundBlur = null!;
 
         [BackgroundDependencyLoader]
@@ -143,6 +161,7 @@ namespace osu.Game.Screens.SelectV2
             AddRangeInternal(new Drawable[]
             {
                 new GlobalScrollAdjustsVolume(),
+                onlineLookupSource,
                 mainContent = new Container
                 {
                     Anchor = Anchor.Centre,
@@ -163,15 +182,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 +257,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 +301,12 @@ namespace osu.Game.Screens.SelectV2
             });
         }
 
+        private void requestRecommendedSelection(IEnumerable<GroupedBeatmap> groupedBeatmaps)
+        {
+            var recommendedBeatmap = difficultyRecommender?.GetRecommendedBeatmap(groupedBeatmaps.Select(gb => gb.Beatmap)) ?? groupedBeatmaps.First().Beatmap;
+            queueBeatmapSelection(groupedBeatmaps.First(bug => bug.Beatmap.Equals(recommendedBeatmap)));
+        }
+
         /// <summary>
         /// Called when a selection is made to progress away from the song select screen.
         ///
@@ -343,9 +362,10 @@ namespace osu.Game.Screens.SelectV2
 
                 ensureGlobalBeatmapValid();
 
-                ensurePlayingSelected(true);
+                ensurePlayingSelected();
                 updateBackgroundDim();
                 updateWedgeVisibility();
+                fetchOnlineInfo();
             });
         }
 
@@ -354,8 +374,72 @@ 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),
+            };
+
+            if (this.IsCurrentScreen())
+                updateDebounce();
         }
 
+        #region Selection debounce
+
+        private BeatmapInfo? debounceQueuedSelection;
+        private double debounceElapsedTime;
+
+        private void debounceQueueSelection(BeatmapInfo beatmap)
+        {
+            debounceQueuedSelection = beatmap;
+            debounceElapsedTime = 0;
+        }
+
+        private void updateDebounce()
+        {
+            if (debounceQueuedSelection == null) return;
+
+            double elapsed = Clock.ElapsedFrameTime;
+
+            // avoid debounce running early if there's a single long frame.
+            if (!DebugUtils.IsNUnitRunning && Clock.FramesPerSecond > 0)
+                elapsed = Math.Min(1000 / Clock.FramesPerSecond, elapsed);
+
+            debounceElapsedTime += elapsed;
+
+            if (debounceElapsedTime >= SELECTION_DEBOUNCE)
+                performDebounceSelection();
+        }
+
+        private void performDebounceSelection()
+        {
+            if (debounceQueuedSelection == null) return;
+
+            try
+            {
+                if (Beatmap.Value.BeatmapInfo.Equals(debounceQueuedSelection))
+                    return;
+
+                Beatmap.Value = beatmaps.GetWorkingBeatmap(debounceQueuedSelection);
+            }
+            finally
+            {
+                cancelDebounceSelection();
+            }
+        }
+
+        private void cancelDebounceSelection()
+        {
+            debounceQueuedSelection = null;
+            debounceElapsedTime = 0;
+        }
+
+        #endregion
+
         #region Audio
 
         [Resolved]
@@ -367,7 +451,7 @@ namespace osu.Game.Screens.SelectV2
         /// Ensures some music is playing for the current track.
         /// Will resume playback from a manual user pause if the track has changed.
         /// </summary>
-        private void ensurePlayingSelected(bool restart)
+        private void ensurePlayingSelected()
         {
             if (!ControlGlobalMusic)
                 return;
@@ -379,7 +463,10 @@ namespace osu.Game.Screens.SelectV2
             if (!track.IsRunning && (music.UserPauseRequested != true || isNewTrack))
             {
                 Logger.Log($"Song select decided to {nameof(ensurePlayingSelected)}");
-                music.Play(restart);
+
+                // Only restart playback if a new track.
+                // This is important so that when exiting gameplay, the track is not restarted back to the preview point.
+                music.Play(isNewTrack);
             }
 
             lastTrack.SetTarget(track);
@@ -389,9 +476,6 @@ namespace osu.Game.Screens.SelectV2
 
         private void beginLooping()
         {
-            if (!ControlGlobalMusic)
-                return;
-
             Debug.Assert(!isHandlingLooping);
 
             isHandlingLooping = true;
@@ -419,8 +503,6 @@ namespace osu.Game.Screens.SelectV2
 
         #region Selection handling
 
-        private ScheduledDelegate? selectionDebounce;
-
         /// <summary>
         /// Finalises selection on the given <see cref="BeatmapInfo"/> and runs the provided action if possible.
         /// </summary>
@@ -436,7 +518,7 @@ namespace osu.Game.Screens.SelectV2
 
             // To ensure sanity, cancel any pending selection as we are about to force a selection.
             // Carousel selection will update to the forced selection via a call of `ensureGlobalBeatmapValid` below, or when song select becomes current again.
-            selectionDebounce?.Cancel();
+            cancelDebounceSelection();
 
             // Forced refetch is important here to guarantee correct invalidation across all difficulties (editor specific).
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, true);
@@ -455,34 +537,17 @@ namespace osu.Game.Screens.SelectV2
         /// - Immediately update the selection the carousel.
         /// - After <see cref="SELECTION_DEBOUNCE"/>, update the global beatmap. This in turn causes song select visuals (title, details, leaderboard) to update.
         ///   This debounce is intended to avoid high overheads from churning lookups while a user is changing selection via rapid keyboard operations.
-        ///   To complete the operation immediately, call <see cref="finaliseBeatmapSelection"/>.
         /// </remarks>
-        /// <param name="beatmap">The beatmap to be selected.</param>
-        private void queueBeatmapSelection(BeatmapInfo beatmap)
+        /// <param name="groupedBeatmap">The beatmap to be selected.</param>
+        private void queueBeatmapSelection(GroupedBeatmap groupedBeatmap)
         {
             if (!this.IsCurrentScreen())
                 return;
 
-            carousel.CurrentSelection = beatmap;
+            carousel.CurrentGroupedBeatmap = groupedBeatmap;
 
             // Debounce consideration is to avoid beatmap churn on key repeat selection.
-            selectionDebounce?.Cancel();
-            selectionDebounce = Scheduler.AddDelayed(() =>
-            {
-                if (Beatmap.Value.BeatmapInfo.Equals(beatmap))
-                    return;
-
-                Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap);
-            }, SELECTION_DEBOUNCE);
-        }
-
-        /// <summary>
-        /// If any pending selection exists from <see cref="queueBeatmapSelection"/>, run it immediately.
-        /// </summary>
-        private void finaliseBeatmapSelection()
-        {
-            if (selectionDebounce?.State == ScheduledDelegate.RunState.Waiting)
-                selectionDebounce?.RunTask();
+            debounceQueueSelection(groupedBeatmap.Beatmap);
         }
 
         private bool ensureGlobalBeatmapValid()
@@ -490,28 +555,50 @@ namespace osu.Game.Screens.SelectV2
             if (!this.IsCurrentScreen())
                 return false;
 
-            finaliseBeatmapSelection();
+            performDebounceSelection();
 
             // While filtering, let's not ever attempt to change selection.
             // This will be resolved after the filter completes, see `newItemsPresented`.
-            bool carouselStateIsValid = filterDebounce?.State != ScheduledDelegate.RunState.Waiting && !carousel.IsFiltering;
-            if (!carouselStateIsValid)
+            if (IsFiltering)
                 return false;
 
             // Refetch to be confident that the current selection is still valid. It may have been deleted or hidden.
             var currentBeatmap = beatmaps.GetWorkingBeatmap(Beatmap.Value.BeatmapInfo, true);
             bool validSelection = checkBeatmapValidForSelection(currentBeatmap.BeatmapInfo, filterControl.CreateCriteria());
 
-            if (Beatmap.IsDefault || !validSelection)
+            if (validSelection)
             {
-                validSelection = carousel.NextRandom();
-                finaliseBeatmapSelection();
+                carousel.CurrentBeatmap = currentBeatmap.BeatmapInfo;
+                return true;
             }
 
-            if (validSelection)
-                carousel.CurrentSelection = Beatmap.Value.BeatmapInfo;
-            else
-                Beatmap.SetDefault();
+            // If there was no beatmap selected, pick a random one.
+            if (Beatmap.IsDefault)
+            {
+                validSelection = carousel.NextRandom();
+                performDebounceSelection();
+                return validSelection;
+            }
+
+            // 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())
+                {
+                    carousel.CurrentBeatmap = difficultyRecommender?.GetRecommendedBeatmap(validBeatmaps) ?? validBeatmaps.First();
+                    return true;
+                }
+            }
+
+            // If all else fails, use the default beatmap.
+            Beatmap.SetDefault();
+            performDebounceSelection();
 
             return validSelection;
         }
@@ -557,6 +644,8 @@ namespace osu.Game.Screens.SelectV2
 
             ensureGlobalBeatmapValid();
 
+            detailsArea.Refresh();
+
             if (ControlGlobalMusic)
             {
                 // restart playback on returning to song select, regardless.
@@ -595,12 +684,29 @@ namespace osu.Game.Screens.SelectV2
 
             updateWedgeVisibility();
 
-            beginLooping();
+            if (ControlGlobalMusic)
+            {
+                // Avoid abruptly starting playback at preview point.
+                // Importantly, this should be done before looping is setup to ensure we get the correct imminent `IsPlaying` state.
+                if (!music.IsPlaying)
+                {
+                    music.DuckMomentarily(0, new DuckParameters
+                    {
+                        DuckDuration = 0,
+                        DuckVolumeTo = 0,
+                        RestoreDuration = 800,
+                        RestoreEasing = Easing.OutQuint
+                    });
+                }
+
+                beginLooping();
+            }
 
             ensureGlobalBeatmapValid();
 
-            ensurePlayingSelected(false);
+            ensurePlayingSelected();
             updateBackgroundDim();
+            fetchOnlineInfo();
         }
 
         private void onLeavingScreen()
@@ -700,6 +806,11 @@ namespace osu.Game.Screens.SelectV2
         /// </summary>
         public bool CarouselItemsPresented { get; private set; }
 
+        /// <summary>
+        /// Whether the carousel is or will be undergoing a filter operation.
+        /// </summary>
+        public bool IsFiltering => carousel.IsFiltering || filterDebounce?.State == ScheduledDelegate.RunState.Waiting;
+
         private const double filter_delay = 250;
 
         private ScheduledDelegate? filterDebounce;
@@ -714,7 +825,7 @@ namespace osu.Game.Screens.SelectV2
             // Criteria change may have included a ruleset change which made the current selection invalid.
             bool isSelectionValid = checkBeatmapValidForSelection(Beatmap.Value.BeatmapInfo, criteria);
 
-            filterDebounce = Scheduler.AddDelayed(() => { carousel.Filter(criteria, !isSelectionValid); }, isFirstFilter || !isSelectionValid ? 0 : filter_delay);
+            filterDebounce = Scheduler.AddDelayed(() => carousel.Filter(criteria, !isSelectionValid), isFirstFilter || !isSelectionValid ? 0 : filter_delay);
         }
 
         private void newItemsPresented(IEnumerable<CarouselItem> carouselItems)
@@ -732,7 +843,12 @@ namespace osu.Game.Screens.SelectV2
             // but also in this case we want support for formatting a number within a string).
             filterControl.StatusText = count != 1 ? $"{count:#,0} matches" : $"{count:#,0} match";
 
-            ensureGlobalBeatmapValid();
+            // If there's already a selection update in progress, let's not interrupt it.
+            // Interrupting could cause the debounce interval to be reduced.
+            //
+            // `ensureGlobalBeatmapValid` is run post-selection which will resolve any pending incompatibilities (see `Beatmap` bindable callback).
+            if (debounceQueuedSelection == null)
+                ensureGlobalBeatmapValid();
 
             updateWedgeVisibility();
         }
@@ -777,6 +893,8 @@ namespace osu.Game.Screens.SelectV2
 
         private ScheduledDelegate? revealingBackground;
 
+        private GridContainer mainGridContainer = null!;
+
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             var containingInputManager = GetContainingInputManager();
@@ -790,7 +908,7 @@ namespace osu.Game.Screens.SelectV2
             // For simplicity, disable this functionality on mobile.
             bool isTouchInput = e.CurrentState.Mouse.LastSource is ISourcedFromTouch;
 
-            if (e.Button == MouseButton.Left && !isTouchInput && mouseDownPriority)
+            if (!carousel.AbsoluteScrolling && !isTouchInput && mouseDownPriority && revealingBackground == null)
             {
                 revealingBackground = Scheduler.AddDelayed(() =>
                 {
@@ -894,6 +1012,75 @@ namespace osu.Game.Screens.SelectV2
 
         #endregion
 
+        #region Online lookups
+
+        public enum BeatmapSetLookupStatus
+        {
+            InProgress,
+            Completed,
+        }
+
+        public class BeatmapSetLookupResult
+        {
+            public BeatmapSetLookupStatus Status { get; }
+            public APIBeatmapSet? Result { get; }
+
+            private BeatmapSetLookupResult(BeatmapSetLookupStatus status, APIBeatmapSet? result)
+            {
+                Status = status;
+                Result = result;
+            }
+
+            public static BeatmapSetLookupResult InProgress() => new BeatmapSetLookupResult(BeatmapSetLookupStatus.InProgress, null);
+            public static BeatmapSetLookupResult Completed(APIBeatmapSet? beatmapSet) => new BeatmapSetLookupResult(BeatmapSetLookupStatus.Completed, beatmapSet);
+        }
+
+        /// <summary>
+        /// Result of the latest online beatmap set lookup.
+        /// Note that this being <see langword="null"/> or <see cref="BeatmapSetLookupResult.InProgress"/> is different from
+        /// being a <see cref="BeatmapSetLookupResult.Completed"/> with a <see cref="BeatmapSetLookupResult.Result"/> of null.
+        /// The former indicates a lookup never occurring or being in progress, while the latter indicates a completed lookup with no result.
+        /// </summary>
+        [Cached(typeof(IBindable<BeatmapSetLookupResult?>))]
+        private readonly Bindable<BeatmapSetLookupResult?> lastLookupResult = new Bindable<BeatmapSetLookupResult?>();
+
+        private CancellationTokenSource? onlineLookupCancellation;
+        private Task<APIBeatmapSet?>? currentOnlineLookup;
+
+        private void fetchOnlineInfo()
+        {
+            var beatmapSetInfo = Beatmap.Value.BeatmapSetInfo;
+
+            if (lastLookupResult.Value?.Result?.OnlineID == beatmapSetInfo.OnlineID)
+                return;
+
+            onlineLookupCancellation?.Cancel();
+            onlineLookupCancellation = null;
+
+            if (beatmapSetInfo.OnlineID < 0)
+            {
+                lastLookupResult.Value = BeatmapSetLookupResult.Completed(null);
+                return;
+            }
+
+            lastLookupResult.Value = BeatmapSetLookupResult.InProgress();
+            onlineLookupCancellation = new CancellationTokenSource();
+            currentOnlineLookup = onlineLookupSource.GetBeatmapSetAsync(beatmapSetInfo.OnlineID, onlineLookupCancellation.Token);
+            currentOnlineLookup.ContinueWith(t =>
+            {
+                if (t.IsCompletedSuccessfully)
+                    Schedule(() => lastLookupResult.Value = BeatmapSetLookupResult.Completed(t.GetResultSafely()));
+
+                if (t.Exception != null)
+                {
+                    Logger.Log($"Error when fetching online beatmap set: {t.Exception}", LoggingTarget.Network);
+                    Schedule(() => lastLookupResult.Value = BeatmapSetLookupResult.Completed(null));
+                }
+            });
+        }
+
+        #endregion
+
         #region Implementation of ISongSelect
 
         void ISongSelect.Search(string query) => filterControl.Search(query);
@@ -918,7 +1105,7 @@ namespace osu.Game.Screens.SelectV2
 
         public virtual IEnumerable<OsuMenuItem> GetForwardActions(BeatmapInfo beatmap)
         {
-            yield return new OsuMenuItem("Select", MenuItemType.Highlighted, () => SelectAndRun(beatmap, OnStart))
+            yield return new OsuMenuItem(GlobalActionKeyBindingStrings.Select, MenuItemType.Highlighted, () => SelectAndRun(beatmap, OnStart))
             {
                 Icon = FontAwesome.Solid.Check
             };
@@ -927,7 +1114,7 @@ namespace osu.Game.Screens.SelectV2
 
             if (beatmap.OnlineID > 0)
             {
-                yield return new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmap(beatmap.OnlineID));
+                yield return new OsuMenuItem(CommonStrings.Details, MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmap(beatmap.OnlineID));
 
                 if (beatmap.GetOnlineURL(api, Ruleset.Value) is string url)
                     yield return new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => (game as OsuGame)?.CopyToClipboard(url));
@@ -946,7 +1133,7 @@ namespace osu.Game.Screens.SelectV2
                                        .AsEnumerable()
                                        .Select(c => new CollectionToggleMenuItem(c.ToLive(realm), beatmap)).Cast<OsuMenuItem>().ToList();
 
-            collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
+            collectionItems.Add(new OsuMenuItem(CommonStrings.Manage, MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
 
             yield return new OsuMenuItem(CommonStrings.Collections) { Items = collectionItems };
         }
diff --git a/osu.Game/Screens/SelectV2/WedgeBackground.cs b/osu.Game/Screens/SelectV2/WedgeBackground.cs
index ecfbd51260..3fa21beee2 100644
--- a/osu.Game/Screens/SelectV2/WedgeBackground.cs
+++ b/osu.Game/Screens/SelectV2/WedgeBackground.cs
@@ -5,13 +5,13 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
 using osu.Game.Overlays;
 
 namespace osu.Game.Screens.SelectV2
 {
-    internal partial class WedgeBackground : CompositeDrawable
+    internal sealed partial class WedgeBackground : InputBlockingContainer
     {
         public float StartAlpha { get; init; } = 0.9f;
 
diff --git a/osu.Game/Skinning/Components/ArgonJudgementCounter.cs b/osu.Game/Skinning/Components/ArgonJudgementCounter.cs
new file mode 100644
index 0000000000..9d0e369682
--- /dev/null
+++ b/osu.Game/Skinning/Components/ArgonJudgementCounter.cs
@@ -0,0 +1,74 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osuTK.Graphics;
+
+namespace osu.Game.Skinning.Components
+{
+    public sealed partial class ArgonJudgementCounter : VisibilityContainer
+    {
+        public readonly JudgementCount Result;
+
+        public IBindable<float> WireframeOpacity => textComponent.WireframeOpacity;
+
+        public IBindable<int?> WireframeDigits { get; } = new Bindable<int?>();
+
+        public IBindable<bool> ShowLabel => textComponent.ShowLabel;
+
+        private readonly ArgonCounterTextComponent textComponent;
+        private readonly BindableInt displayedValue = new BindableInt();
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public ArgonJudgementCounter(JudgementCount result)
+        {
+            Result = result;
+
+            AutoSizeAxes = Axes.Both;
+            AddInternal(textComponent = new ArgonCounterTextComponent(Anchor.TopRight, result.DisplayName.ToUpper()));
+        }
+
+        private void updateWireframe()
+        {
+            textComponent.WireframeTemplate = new string('#', WireframeDigits.Value ?? Math.Max(2, textComponent.Text.ToString().Length));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            WireframeDigits.BindValueChanged(_ => updateWireframe());
+
+            displayedValue.BindTo(Result.ResultCount);
+            displayedValue.BindValueChanged(v =>
+            {
+                textComponent.Text = v.NewValue.ToString();
+                updateWireframe();
+            }, true);
+
+            var result = Result.Types.First();
+            textComponent.LabelColour.Value = getJudgementColor(result);
+            textComponent.ShowLabel.BindValueChanged(v => textComponent.TextColour.Value = !v.NewValue ? getJudgementColor(result) : Color4.White);
+        }
+
+        private Color4 getJudgementColor(HitResult result)
+        {
+            return result.IsBasic() ? colours.ForHitResult(result) : !result.IsBonus() ? colours.PurpleLight : colours.PurpleLighter;
+        }
+
+        protected override void PopIn() => this.FadeIn(JudgementCounterDisplay.TRANSFORM_DURATION, Easing.OutQuint);
+        protected override void PopOut() => this.FadeOut();
+    }
+}
diff --git a/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs b/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs
new file mode 100644
index 0000000000..62b6d8ecc7
--- /dev/null
+++ b/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs
@@ -0,0 +1,165 @@
+// 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.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Localisation.HUD;
+using osu.Game.Localisation.SkinComponents;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osuTK;
+
+namespace osu.Game.Skinning.Components
+{
+    [UsedImplicitly]
+    public partial class ArgonJudgementCounterDisplay : CompositeDrawable, ISerialisableDrawable
+    {
+        [Resolved]
+        private JudgementCountController judgementCountController { get; set; } = null!;
+
+        [SettingSource("Wireframe opacity", "Controls the opacity of the wireframes behind the digits.")]
+        public BindableFloat WireframeOpacity { get; } = new BindableFloat(0.25f)
+        {
+            Precision = 0.01f,
+            MinValue = 0,
+            MaxValue = 1,
+        };
+
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
+        public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.ShowMaxJudgement))]
+        public BindableBool ShowMaxJudgement { get; } = new BindableBool(true);
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayMode))]
+        public Bindable<DisplayMode> Mode { get; } = new Bindable<DisplayMode>();
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.FlowDirection))]
+        public Bindable<Direction> FlowDirection { get; } = new Bindable<Direction>();
+
+        private readonly Bindable<int?> wireframeDigits = new Bindable<int?>();
+
+        protected FillFlowContainer<ArgonJudgementCounter> CounterFlow = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AutoSizeAxes = Axes.Both;
+            InternalChild = CounterFlow = new FillFlowContainer<ArgonJudgementCounter>
+            {
+                Direction = getFillDirection(FlowDirection.Value),
+                Spacing = new Vector2(16),
+                AutoSizeAxes = Axes.Both,
+            };
+
+            foreach (var counter in judgementCountController.Counters)
+            {
+                counter.ResultCount.BindValueChanged(_ => updateWireframeDigits());
+                ArgonJudgementCounter counterComponent = new ArgonJudgementCounter(counter)
+                {
+                    WireframeOpacity = { BindTarget = WireframeOpacity },
+                    WireframeDigits = { BindTarget = wireframeDigits },
+                    ShowLabel = { BindTarget = ShowLabel },
+                };
+                CounterFlow.Add(counterComponent);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Mode.BindValueChanged(_ => updateVisibility());
+            ShowMaxJudgement.BindValueChanged(_ => updateVisibility(), true);
+            FlowDirection.BindValueChanged(_ => updateFlowDirection(), true);
+        }
+
+        private void updateVisibility()
+        {
+            for (int i = 0; i < CounterFlow.Children.Count; i++)
+            {
+                ArgonJudgementCounter counter = CounterFlow.Children[i];
+
+                if (shouldBeVisible(i, counter))
+                    counter.Show();
+                else
+                    counter.Hide();
+            }
+
+            updateWireframeDigits();
+        }
+
+        private void updateFlowDirection()
+        {
+            CounterFlow.Direction = getFillDirection(FlowDirection.Value);
+            updateWireframeDigits();
+        }
+
+        private void updateWireframeDigits()
+        {
+            wireframeDigits.Value = FlowDirection.Value == Direction.Vertical
+                ? Math.Max(2, CounterFlow.Children.Where(counter => counter.State.Value == Visibility.Visible).Max(counter => counter.Result.ResultCount.Value).ToString().Length)
+                : null;
+        }
+
+        private bool shouldBeVisible(int index, ArgonJudgementCounter counter)
+        {
+            if (index == 0 && !ShowMaxJudgement.Value)
+                return false;
+
+            var hitResult = counter.Result.Types.First();
+            if (hitResult.IsBasic())
+                return true;
+
+            switch (Mode.Value)
+            {
+                case DisplayMode.Simple:
+                    return false;
+
+                case DisplayMode.Normal:
+                    return !hitResult.IsBonus();
+
+                case DisplayMode.All:
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(Mode), Mode.Value, null);
+            }
+        }
+
+        private FillDirection getFillDirection(Direction flow)
+        {
+            switch (flow)
+            {
+                case Direction.Horizontal:
+                    return FillDirection.Horizontal;
+
+                case Direction.Vertical:
+                    return FillDirection.Vertical;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(flow), flow, null);
+            }
+        }
+
+        public enum DisplayMode
+        {
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeSimple))]
+            Simple,
+
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeNormal))]
+            Normal,
+
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeAll))]
+            All
+        }
+
+        public bool UsesFixedAnchor { get; set; }
+    }
+}
diff --git a/osu.Game/Skinning/Components/BeatmapAttributeText.cs b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
index 58821f869a..3935277dfb 100644
--- a/osu.Game/Skinning/Components/BeatmapAttributeText.cs
+++ b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -237,18 +236,9 @@ namespace osu.Game.Skinning.Components
 
             BeatmapDifficulty computeDifficulty()
             {
-                BeatmapDifficulty difficulty = new BeatmapDifficulty(beatmap.Value.BeatmapInfo.Difficulty);
-
-                foreach (var mod in mods.Value.OfType<IApplicableToDifficulty>())
-                    mod.ApplyToDifficulty(difficulty);
-
-                if (ruleset.Value is RulesetInfo rulesetInfo)
-                {
-                    double rate = ModUtils.CalculateRateWithMods(mods.Value);
-                    difficulty = rulesetInfo.CreateInstance().GetRateAdjustedDisplayDifficulty(difficulty, rate);
-                }
-
-                return difficulty;
+                return ruleset.Value is RulesetInfo rulesetInfo
+                    ? rulesetInfo.CreateInstance().GetAdjustedDisplayDifficulty(beatmap.Value.BeatmapInfo, mods.Value)
+                    : new BeatmapDifficulty(beatmap.Value.BeatmapInfo.Difficulty);
             }
         }
 
diff --git a/osu.Game/Skinning/LegacyRankDisplay.cs b/osu.Game/Skinning/LegacyRankDisplay.cs
index 7c2f8ffdef..3109f68e9f 100644
--- a/osu.Game/Skinning/LegacyRankDisplay.cs
+++ b/osu.Game/Skinning/LegacyRankDisplay.cs
@@ -34,10 +34,12 @@ namespace osu.Game.Skinning
         private SkinnableSound rankDownSample = null!;
         private SkinnableSound rankUpSample = null!;
 
-        private Bindable<double?> lastSamplePlaybackTime = null!;
+        private Bindable<double?> lastSamplePlayback = null!;
+        private double timeSinceChange;
 
-        private IBindable<ScoreRank> rank = null!;
-        private ScoreRank lastRank;
+        private ScoreRank? displayedRank;
+
+        private const int time_before_commit = 1500;
 
         public LegacyRankDisplay()
         {
@@ -62,51 +64,72 @@ namespace osu.Game.Skinning
             if (skinEditor != null)
                 PlaySamples.Value = false;
 
-            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
+            lastSamplePlayback = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
         }
 
         protected override void LoadComplete()
         {
-            rank = scoreProcessor.Rank.GetBoundCopy();
-            rank.BindValueChanged(r =>
+            base.LoadComplete();
+
+            updateRank(scoreProcessor.Rank.Value);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var currentRank = scoreProcessor.Rank.Value;
+
+            if (currentRank == displayedRank)
             {
-                var texture = source.GetTexture($"ranking-{r.NewValue}-small");
+                timeSinceChange = 0;
+                return;
+            }
 
-                rankDisplay.Texture = texture;
+            if ((timeSinceChange += Time.Elapsed) >= time_before_commit || scoreProcessor.HasCompleted.Value || currentRank == ScoreRank.F)
+                updateRank(currentRank);
+        }
 
-                if (texture != null)
+        private void updateRank(ScoreRank rank)
+        {
+            var texture = source.GetTexture($"ranking-{rank}-small");
+
+            rankDisplay.Texture = texture;
+
+            if (texture != null && displayedRank != null)
+            {
+                var transientRank = new Sprite
                 {
-                    var transientRank = new Sprite
-                    {
-                        Texture = texture,
-                        Blending = BlendingParameters.Additive,
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        BypassAutoSizeAxes = Axes.Both,
-                    };
-                    AddInternal(transientRank);
-                    transientRank.FadeOutFromOne(500, Easing.Out)
-                                 .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
-                                 .Expire();
-                }
+                    Texture = texture,
+                    Blending = BlendingParameters.Additive,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    BypassAutoSizeAxes = Axes.Both,
+                };
 
-                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+                AddInternal(transientRank);
 
-                // Don't play rank-down sfx on quit/retry
-                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F && PlaySamples.Value && enoughTimeElapsed)
-                {
-                    if (r.NewValue > lastRank)
-                        rankUpSample.Play();
-                    else
-                        rankDownSample.Play();
+                transientRank.FadeOutFromOne(500, Easing.Out)
+                             .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
+                             .Expire();
+            }
 
-                    lastSamplePlaybackTime.Value = Time.Current;
-                }
+            // Check sample time separately to ensure two copies of the rank display don't both play samples on a change.
+            bool enoughSampleTimeElapsed = !lastSamplePlayback.Value.HasValue || Time.Current - lastSamplePlayback.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
 
-                lastRank = r.NewValue;
-            }, true);
+            // Also don't play rank-down sfx on quit/retry/initial update.
+            if (displayedRank != null && rank > ScoreRank.F && PlaySamples.Value && enoughSampleTimeElapsed)
+            {
+                if (rank > displayedRank)
+                    rankUpSample.Play();
+                else
+                    rankDownSample.Play();
 
-            FinishTransforms(true);
+                lastSamplePlayback.Value = Time.Current;
+            }
+
+            displayedRank = rank;
+            timeSinceChange = 0;
         }
     }
 }
diff --git a/osu.Game/Skinning/Skin.cs b/osu.Game/Skinning/Skin.cs
index e93a10d50b..07902106ef 100644
--- a/osu.Game/Skinning/Skin.cs
+++ b/osu.Game/Skinning/Skin.cs
@@ -221,6 +221,7 @@ namespace osu.Game.Skinning
             jsonContent = jsonContent.Replace(@"osu.Game.Screens.Play.HUD.LegacyComboCounter", @"osu.Game.Skinning.LegacyComboCounter");
             jsonContent = jsonContent.Replace(@"osu.Game.Skinning.LegacyComboCounter", @"osu.Game.Skinning.LegacyDefaultComboCounter");
             jsonContent = jsonContent.Replace(@"osu.Game.Screens.Play.HUD.PerformancePointsCounter", @"osu.Game.Skinning.Triangles.TrianglesPerformancePointsCounter");
+            jsonContent = jsonContent.Replace(@"osu.Game.Screens.Play.HUD.UnstableRateCounter", @"osu.Game.Skinning.Triangles.TrianglesUnstableRateCounter");
 
             try
             {
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 825d2f59c5..1be6f1bc4a 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -349,6 +349,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/Skinning/Triangles/TrianglesUnstableRateCounter.cs b/osu.Game/Skinning/Triangles/TrianglesUnstableRateCounter.cs
new file mode 100644
index 0000000000..7c6046914d
--- /dev/null
+++ b/osu.Game/Skinning/Triangles/TrianglesUnstableRateCounter.cs
@@ -0,0 +1,79 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Screens.Play.HUD;
+using osuTK;
+
+namespace osu.Game.Skinning.Triangles
+{
+    public partial class TrianglesUnstableRateCounter : UnstableRateCounter, ISerialisableDrawable
+    {
+        private const float alpha_when_invalid = 0.3f;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.BlueLighter;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            IsValid.BindValueChanged(e =>
+                DrawableCount.FadeTo(e.NewValue ? 1 : alpha_when_invalid, 1000, Easing.OutQuint), true);
+            FinishTransforms(true);
+        }
+
+        protected override IHasText CreateText() => new TextComponent
+        {
+            Alpha = alpha_when_invalid
+        };
+
+        private partial class TextComponent : CompositeDrawable, IHasText
+        {
+            public LocalisableString Text
+            {
+                get => text.Text;
+                set => text.Text = value;
+            }
+
+            private readonly OsuSpriteText text;
+
+            public TextComponent()
+            {
+                AutoSizeAxes = Axes.Both;
+
+                InternalChild = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(2),
+                    Children = new Drawable[]
+                    {
+                        text = new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            Font = OsuFont.Numeric.With(size: 16, fixedWidth: true)
+                        },
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            Font = OsuFont.Numeric.With(size: 8, fixedWidth: true),
+                            Text = @"UR",
+                            Padding = new MarginPadding { Bottom = 1.5f },
+                        }
+                    }
+                };
+            }
+        }
+    }
+}
diff --git a/osu.Game/Tests/Gameplay/TestGameplayState.cs b/osu.Game/Tests/Gameplay/TestGameplayState.cs
index 8fad6d1e23..2f1439f129 100644
--- a/osu.Game/Tests/Gameplay/TestGameplayState.cs
+++ b/osu.Game/Tests/Gameplay/TestGameplayState.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Bindables;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -18,7 +19,7 @@ namespace osu.Game.Tests.Gameplay
         /// <summary>
         /// Creates a correctly-initialised <see cref="GameplayState"/> instance for use in testing.
         /// </summary>
-        public static GameplayState Create(Ruleset ruleset, IReadOnlyList<Mod>? mods = null, Score? score = null)
+        public static GameplayState Create(Ruleset ruleset, IReadOnlyList<Mod>? mods = null, Score? score = null, IBindable<LocalUserPlayingState>? playState = null)
         {
             var beatmap = new TestBeatmap(ruleset.RulesetInfo);
             var workingBeatmap = new TestWorkingBeatmap(beatmap);
@@ -29,7 +30,7 @@ namespace osu.Game.Tests.Gameplay
 
             var healthProcessor = ruleset.CreateHealthProcessor(beatmap.HitObjects[0].StartTime);
 
-            return new GameplayState(playableBeatmap, ruleset, mods, score, scoreProcessor, healthProcessor);
+            return new GameplayState(playableBeatmap, ruleset, mods, score, scoreProcessor, healthProcessor, localUserPlayingState: playState);
         }
     }
 }
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
index 3843460add..806dc63aed 100644
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
@@ -508,7 +508,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             if (item == null)
                 throw new InvalidOperationException("Item does not exist in the room.");
 
-            if (item == currentItem)
+            if (item.Equals(currentItem))
                 throw new InvalidOperationException("The room's current item cannot be removed.");
 
             if (item.OwnerID != userId)
diff --git a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
index 914d187864..c687815270 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
@@ -95,7 +95,7 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         /// </remarks>
         protected virtual OnlinePlayTestSceneDependencies CreateOnlinePlayDependencies() => new OnlinePlayTestSceneDependencies();
 
-        protected Room[] GenerateRooms(int count, RulesetInfo? ruleset = null, bool withPassword = false, bool withSpotlightRooms = false)
+        protected Room[] GenerateRooms(int count, RulesetInfo? ruleset = null, bool withPassword = false, bool withPinnedRooms = false)
         {
             Room[] rooms = new Room[count];
 
@@ -110,10 +110,10 @@ namespace osu.Game.Tests.Visual.OnlinePlay
                     Name = $@"Room {currentRoomId}",
                     Host = new APIUser { Username = @"Host" },
                     Duration = TimeSpan.FromSeconds(10),
-                    Category = withSpotlightRooms && i % 2 == 0 ? RoomCategory.Spotlight : RoomCategory.Normal,
                     Password = withPassword ? @"password" : null,
                     PlaylistItemStats = new Room.RoomPlaylistItemStats { RulesetIDs = [ruleset.OnlineID] },
-                    Playlist = [new PlaylistItem(new BeatmapInfo { Metadata = new BeatmapMetadata() }) { RulesetID = ruleset.OnlineID }]
+                    Playlist = [new PlaylistItem(new BeatmapInfo { Metadata = new BeatmapMetadata() }) { RulesetID = ruleset.OnlineID }],
+                    Pinned = withPinnedRooms && i % 2 == 0,
                 };
             }
 
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/Tests/Visual/PlayerTestScene.cs b/osu.Game/Tests/Visual/PlayerTestScene.cs
index 43d779261c..709ff1d62e 100644
--- a/osu.Game/Tests/Visual/PlayerTestScene.cs
+++ b/osu.Game/Tests/Visual/PlayerTestScene.cs
@@ -70,14 +70,6 @@ namespace osu.Game.Tests.Visual
 
             AddStep($"Load player for {CreatePlayerRuleset().Description}", LoadPlayer);
             AddUntilStep("player loaded", () => Player.IsLoaded && Player.Alpha == 1);
-
-            if (AllowBackwardsSeeks)
-            {
-                AddStep("allow backwards seeking", () =>
-                {
-                    Player.DrawableRuleset.AllowBackwardsSeeks = AllowBackwardsSeeks;
-                });
-            }
         }
 
         protected virtual bool AllowFail => false;
diff --git a/osu.Game/Tests/Visual/ScreenTestScene.cs b/osu.Game/Tests/Visual/ScreenTestScene.cs
index f780b1a8f8..42199faa4d 100644
--- a/osu.Game/Tests/Visual/ScreenTestScene.cs
+++ b/osu.Game/Tests/Visual/ScreenTestScene.cs
@@ -7,7 +7,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Logging;
+using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
@@ -32,7 +34,7 @@ namespace osu.Game.Tests.Visual
         protected DialogOverlay DialogOverlay { get; private set; }
 
         [Cached]
-        private ScreenFooter footer;
+        protected ScreenFooter Footer { get; private set; }
 
         protected ScreenTestScene()
         {
@@ -43,17 +45,32 @@ namespace osu.Game.Tests.Visual
                     Name = nameof(ScreenTestScene),
                     RelativeSizeAxes = Axes.Both
                 },
-                content = new Container { RelativeSizeAxes = Axes.Both },
+                new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        content = new Container { RelativeSizeAxes = Axes.Both },
+                        Footer = new ScreenFooter(),
+                    }
+                },
                 overlayContent = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
                     Child = DialogOverlay = new DialogOverlay()
                 },
-                footer = new ScreenFooter(),
             });
 
-            Stack.ScreenPushed += (_, newScreen) => Logger.Log($"{nameof(ScreenTestScene)} screen changed → {newScreen}");
-            Stack.ScreenExited += (_, newScreen) => Logger.Log($"{nameof(ScreenTestScene)} screen changed ← {newScreen}");
+            Stack.ScreenPushed += (oldScreen, newScreen) =>
+            {
+                updateFooter(oldScreen, newScreen);
+                Logger.Log($"{nameof(ScreenTestScene)} screen changed → {newScreen}");
+            };
+            Stack.ScreenExited += (oldScreen, newScreen) =>
+            {
+                updateFooter(oldScreen, newScreen);
+                Logger.Log($"{nameof(ScreenTestScene)} screen changed ← {newScreen}");
+            };
         }
 
         protected void LoadScreen(OsuScreen screen) => Stack.Push(screen);
@@ -79,6 +96,39 @@ namespace osu.Game.Tests.Visual
             });
         }
 
+        private void updateFooter(IScreen? _, IScreen? newScreen)
+        {
+            if (newScreen is OsuScreen osuScreen && osuScreen.ShowFooter)
+            {
+                Footer.Show();
+
+                if (osuScreen.IsLoaded)
+                    updateFooterButtons();
+                else
+                {
+                    // ensure the current buttons are immediately disabled on screen change (so they can't be pressed).
+                    Footer.SetButtons(Array.Empty<ScreenFooterButton>());
+
+                    osuScreen.OnLoadComplete += _ => updateFooterButtons();
+                }
+
+                void updateFooterButtons()
+                {
+                    var buttons = osuScreen.CreateFooterButtons();
+
+                    osuScreen.LoadComponentsAgainstScreenDependencies(buttons);
+
+                    Footer.SetButtons(buttons);
+                    Footer.Show();
+                }
+            }
+            else
+            {
+                Footer.Hide();
+                Footer.SetButtons(Array.Empty<ScreenFooterButton>());
+            }
+        }
+
         #region IOverlayManager
 
         IBindable<OverlayActivation> IOverlayManager.OverlayActivationMode { get; } = new Bindable<OverlayActivation>(OverlayActivation.All);
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/Users/ExtendedUserPanel.cs b/osu.Game/Users/ExtendedUserPanel.cs
index 0185165b36..70a96b730a 100644
--- a/osu.Game/Users/ExtendedUserPanel.cs
+++ b/osu.Game/Users/ExtendedUserPanel.cs
@@ -111,21 +111,21 @@ namespace osu.Game.Users
             else
                 LastVisitMessage.FadeTo(0);
 
-            // Set status message based on activity (if we have one) and status is not offline
-            if (activity != null && status != UserStatus.Offline)
-            {
-                statusMessage.Text = activity.GetStatus();
-                statusMessage.TooltipText = activity.GetDetails() ?? string.Empty;
-                statusIcon.FadeColour(activity.GetAppropriateColour(Colours), 500, Easing.OutQuint);
-            }
-
-            // Otherwise use only status
-            else
+            if (activity == null || status == UserStatus.Offline)
             {
                 statusMessage.Text = status.GetLocalisableDescription();
                 statusMessage.TooltipText = string.Empty;
-                statusIcon.FadeColour(status.GetAppropriateColour(Colours), 500, Easing.OutQuint);
             }
+            else
+            {
+                statusMessage.Text = activity.GetStatus();
+                statusMessage.TooltipText = activity.GetDetails() ?? string.Empty;
+            }
+
+            if (activity == null || status != UserStatus.Online)
+                statusIcon.FadeColour(status.GetAppropriateColour(Colours), 500, Easing.OutQuint);
+            else
+                statusIcon.FadeColour(activity.GetAppropriateColour(Colours), 500, Easing.OutQuint);
 
             lastStatus = status;
             lastActivity = activity;
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 107f54d4ac..32e1b41ad8 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -35,8 +35,8 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="20.1.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2025.704.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.707.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2025.903.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.905.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" />
diff --git a/osu.iOS.props b/osu.iOS.props
index bb5e3da49e..8e269d292d 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.903.0" />
   </ItemGroup>
 </Project>
diff --git a/osu.iOS/OsuGameIOS.cs b/osu.iOS/OsuGameIOS.cs
index 96b8fb9804..fff781f38f 100644
--- a/osu.iOS/OsuGameIOS.cs
+++ b/osu.iOS/OsuGameIOS.cs
@@ -19,8 +19,11 @@ namespace osu.iOS
     public partial class OsuGameIOS : OsuGame
     {
         private readonly AppDelegate appDelegate;
+
         public override Version AssemblyVersion => new Version(NSBundle.MainBundle.InfoDictionary["CFBundleVersion"].ToString());
 
+        public override string Version => NSBundle.MainBundle.InfoDictionary["OsuVersion"].ToString();
+
         public override bool HideUnlicensedContent => true;
 
         public override Vector2 ScalingContainerTargetDrawSize => new Vector2(1024, 1024 * DrawHeight / DrawWidth);
diff --git a/osu.iOS/osu.iOS.csproj b/osu.iOS/osu.iOS.csproj
index 19c0c610b5..3e8beddaa4 100644
--- a/osu.iOS/osu.iOS.csproj
+++ b/osu.iOS/osu.iOS.csproj
@@ -4,8 +4,12 @@
     <SupportedOSPlatformVersion>13.4</SupportedOSPlatformVersion>
     <OutputType>Exe</OutputType>
     <Version>0.1.0</Version>
-    <ApplicationVersion Condition=" '$(ApplicationVersion)' == '' ">$(Version)</ApplicationVersion>
-    <ApplicationDisplayVersion Condition=" '$(ApplicationDisplayVersion)' == '' ">$(Version)</ApplicationDisplayVersion>
+
+    <!-- Incoming version string will be e.g. 2025.723.0-tachyon -->
+    <VersionNoSuffix>$([System.String]::Copy('$(Version)').Split('-')[0])</VersionNoSuffix>
+
+    <ApplicationVersion Condition=" '$(ApplicationVersion)' == '' ">$(VersionNoSuffix)</ApplicationVersion>
+    <ApplicationDisplayVersion Condition=" '$(ApplicationDisplayVersion)' == '' ">$(VersionNoSuffix)</ApplicationDisplayVersion>
   </PropertyGroup>
   <Import Project="..\osu.iOS.props" />
   <ItemGroup>
@@ -18,4 +22,14 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Maui.Essentials" Version="8.0.3" />
   </ItemGroup>
+  <!-- https://github.com/dotnet/macios/blob/eabcdee2ac43a0cc8324396a1bf75f8797d71810/msbuild/Xamarin.Shared/Xamarin.Shared.targets#L1328 -->
+  <Target Name="AddOsuVersionToBundle" AfterTargets="_CreateAppBundle">
+    <PropertyGroup>
+      <PlistFilePath>$(AppBundleDir)/Info.plist</PlistFilePath>
+      <OsuVersionKey>OsuVersion</OsuVersionKey>
+    </PropertyGroup>
+    <Exec Command="bash -c &quot;(/usr/libexec/PlistBuddy -c 'Print :$(OsuVersionKey)' '$(PlistFilePath)' &gt;/dev/null 2&gt;&amp;1 \
+                                 &amp;&amp; /usr/libexec/PlistBuddy -c 'Set :$(OsuVersionKey) $(Version)' '$(PlistFilePath)') \
+                                 || /usr/libexec/PlistBuddy -c 'Add :$(OsuVersionKey) string $(Version)' '$(PlistFilePath)'&quot;"/>
+  </Target>
 </Project>