diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 0000000000..1a921b21ae
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,87 @@
+name: Pack and nuget
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  notify_pending_production_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit pending deployment notification
+        run: |
+          export TITLE="Pending osu Production Deployment: $GITHUB_REF_NAME"
+          export URL="https://github.com/ppy/osu/actions/runs/$GITHUB_RUN_ID"
+          export DESCRIPTION="Awaiting approval for building NuGet packages for tag $GITHUB_REF_NAME:
+          [View Workflow Run]($URL)"
+          export ACTOR_ICON="https://avatars.githubusercontent.com/u/$GITHUB_ACTOR_ID"
+
+          BODY="$(jq --null-input '{
+            "embeds": [
+              {
+                "title": env.TITLE,
+                "color": 15098112,
+                "description": env.DESCRIPTION,
+                "url": env.URL,
+                "author": {
+                  "name": env.GITHUB_ACTOR,
+                  "icon_url": env.ACTOR_ICON
+                }
+              }
+            ]
+          }')"
+
+          curl \
+            -H "Content-Type: application/json" \
+            -d "$BODY" \
+            "${{ secrets.DISCORD_INFRA_WEBHOOK_URL }}"
+
+  pack:
+    name: Pack
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set artifacts directory
+        id: artifactsPath
+        run: echo "::set-output name=nuget_artifacts::${{github.workspace}}/artifacts"
+
+      - name: Install .NET 8.0.x
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Pack
+        run: |
+          # Replace project references in templates with package reference, because they're included as source files.
+          dotnet remove Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game/osu.Game.csproj
+          dotnet remove Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj reference osu.Game/osu.Game.csproj
+
+          dotnet add Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+          dotnet add Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -n -v ${{ github.ref_name }}
+
+          # Pack
+          dotnet pack -c Release osu.Game /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Osu /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Taiko /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Catch /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release osu.Game.Rulesets.Mania /p:Version=${{ github.ref_name }} /p:GenerateDocumentationFile=true /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+          dotnet pack -c Release Templates /p:Version=${{ github.ref_name }} -o ${{steps.artifactsPath.outputs.nuget_artifacts}}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: osu
+          path: |
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg
+            ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.snupkg
+
+      - name: Publish packages to nuget.org
+        run: dotnet nuget push ${{steps.artifactsPath.outputs.nuget_artifacts}}/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json
diff --git a/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Replays/EmptyFreeformReplayFrame.cs b/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Replays/EmptyFreeformReplayFrame.cs
index c84101ca70..c6be5d6861 100644
--- a/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Replays/EmptyFreeformReplayFrame.cs
+++ b/Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/Replays/EmptyFreeformReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Replays;
 using osuTK;
 
@@ -17,5 +18,8 @@ namespace osu.Game.Rulesets.EmptyFreeform.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is EmptyFreeformReplayFrame freeformFrame && Time == freeformFrame.Time && Position == freeformFrame.Position && Actions.SequenceEqual(freeformFrame.Actions);
     }
 }
diff --git a/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs b/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
index 949ca160be..c434b62257 100644
--- a/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
+++ b/Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
@@ -9,5 +9,8 @@ namespace osu.Game.Rulesets.Pippidon.Replays
     public class PippidonReplayFrame : ReplayFrame
     {
         public Vector2 Position;
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is PippidonReplayFrame pippidonFrame && Time == pippidonFrame.Time && Position == pippidonFrame.Position;
     }
 }
diff --git a/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/Replays/EmptyScrollingReplayFrame.cs b/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/Replays/EmptyScrollingReplayFrame.cs
index 2f19cffd2a..722eff6f05 100644
--- a/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/Replays/EmptyScrollingReplayFrame.cs
+++ b/Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/Replays/EmptyScrollingReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.EmptyScrolling.Replays
@@ -15,5 +16,8 @@ namespace osu.Game.Rulesets.EmptyScrolling.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is EmptyScrollingReplayFrame scrollingFrame && Time == scrollingFrame.Time && Actions.SequenceEqual(scrollingFrame.Actions);
     }
 }
diff --git a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
index 468ac9c725..c8df06f6d7 100644
--- a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
+++ b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Replays/PippidonReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Pippidon.Replays
@@ -15,5 +16,8 @@ namespace osu.Game.Rulesets.Pippidon.Replays
             if (button.HasValue)
                 Actions.Add(button.Value);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is PippidonReplayFrame pippidonFrame && Time == pippidonFrame.Time && Actions.SequenceEqual(pippidonFrame.Actions);
     }
 }
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index ed48a997e8..0000000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,32 +0,0 @@
-clone_depth: 1
-version: '{branch}-{build}'
-image: Visual Studio 2022
-cache:
-  - '%LOCALAPPDATA%\NuGet\v3-cache -> appveyor.yml'
-
-dotnet_csproj:
-  patch: true
-  file: 'osu.Game\osu.Game.csproj' # Use wildcard when it's able to exclude Xamarin projects
-  version: '0.0.{build}'
-
-before_build:
-  - cmd: dotnet --info # Useful when version mismatch between CI and local
-  - cmd: dotnet workload install maui-android # Change to `dotnet workload restore` once there's no old projects
-  - cmd: dotnet workload install maui-ios # Change to `dotnet workload restore` once there's no old projects
-  - cmd: nuget restore -verbosity quiet # Only nuget.exe knows both new (.NET Core) and old (Xamarin) projects
-
-build:
-  project: osu.sln
-  parallel: true
-  verbosity: minimal
-  publish_nuget: true
-
-after_build:
-  - ps: .\InspectCode.ps1
-
-test:
-  assemblies:
-    except:
-      - '**\*Android*'
-      - '**\*iOS*'
-      - 'build\**\*'
diff --git a/appveyor_deploy.yml b/appveyor_deploy.yml
deleted file mode 100644
index 175c8d0f1b..0000000000
--- a/appveyor_deploy.yml
+++ /dev/null
@@ -1,86 +0,0 @@
-clone_depth: 1
-version: '{build}'
-image: Visual Studio 2022
-test: off
-skip_non_tags: true
-configuration: Release
-
-environment:
-  matrix:
-    - job_name: osu-game
-    - job_name: osu-ruleset
-      job_depends_on: osu-game
-    - job_name: taiko-ruleset
-      job_depends_on: osu-game
-    - job_name: catch-ruleset
-      job_depends_on: osu-game
-    - job_name: mania-ruleset
-      job_depends_on: osu-game
-    - job_name: templates
-      job_depends_on: osu-game
-
-nuget:
-  project_feed: true
-
-for:
-  -
-    matrix:
-      only:
-        - job_name: osu-game
-    build_script:
-      - cmd: dotnet pack osu.Game\osu.Game.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: osu-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Osu\osu.Game.Rulesets.Osu.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: taiko-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: catch-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Catch\osu.Game.Rulesets.Catch.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: mania-ruleset
-    build_script:
-      - cmd: dotnet remove osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet add osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet pack osu.Game.Rulesets.Mania\osu.Game.Rulesets.Mania.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-  -
-    matrix:
-      only:
-        - job_name: templates
-    build_script:
-      - cmd: dotnet remove Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj reference osu.Game\osu.Game.csproj
-      - cmd: dotnet remove Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj reference osu.Game\osu.Game.csproj
-
-      - cmd: dotnet add Templates\Rulesets\ruleset-empty\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-empty\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-      - cmd: dotnet add Templates\Rulesets\ruleset-scrolling-example\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj package ppy.osu.Game -v %APPVEYOR_REPO_TAG_NAME%
-
-      - cmd: dotnet pack Templates\osu.Game.Templates.csproj /p:Version=%APPVEYOR_REPO_TAG_NAME%
-
-artifacts:
-  - path: '**\*.nupkg'
-
-deploy:
-  - provider: Environment
-    name: nuget
diff --git a/osu.Android.props b/osu.Android.props
index 92e3312fd8..de3fe31ee6 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.512.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.704.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Desktop/Program.cs b/osu.Desktop/Program.cs
index a311e42d6d..50d0f06150 100644
--- a/osu.Desktop/Program.cs
+++ b/osu.Desktop/Program.cs
@@ -184,7 +184,7 @@ namespace osu.Desktop
 
             var app = VelopackApp.Build();
 
-            app.WithFirstRun(_ => isFirstRun = true);
+            app.OnFirstRun(_ => isFirstRun = true);
 
             if (OperatingSystem.IsWindows())
                 configureWindows(app);
@@ -195,9 +195,9 @@ namespace osu.Desktop
         [SupportedOSPlatform("windows")]
         private static void configureWindows(VelopackApp app)
         {
-            app.WithFirstRun(_ => WindowsAssociationManager.InstallAssociations());
-            app.WithAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
-            app.WithBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
+            app.OnFirstRun(_ => WindowsAssociationManager.InstallAssociations());
+            app.OnAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
+            app.OnBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
         }
     }
 }
diff --git a/osu.Desktop/Updater/VelopackUpdateManager.cs b/osu.Desktop/Updater/VelopackUpdateManager.cs
index 6f22fd5940..3b79313f8c 100644
--- a/osu.Desktop/Updater/VelopackUpdateManager.cs
+++ b/osu.Desktop/Updater/VelopackUpdateManager.cs
@@ -2,21 +2,22 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Logging;
+using osu.Framework.Threading;
 using osu.Game;
-using osu.Game.Configuration;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Screens.Play;
 using Velopack;
 using Velopack.Sources;
+using UpdateManager = osu.Game.Updater.UpdateManager;
 
 namespace osu.Desktop.Updater
 {
-    public partial class VelopackUpdateManager : Game.Updater.UpdateManager
+    public partial class VelopackUpdateManager : UpdateManager
     {
         [Resolved]
         private INotificationOverlay notificationOverlay { get; set; } = null!;
@@ -27,143 +28,119 @@ namespace osu.Desktop.Updater
         [Resolved]
         private ILocalUserPlayInfo? localUserInfo { get; set; }
 
-        [Resolved]
-        private OsuConfigManager osuConfigManager { get; set; } = null!;
-
         private bool isInGameplay => localUserInfo?.PlayingState.Value != LocalUserPlayingState.NotPlaying;
 
-        private readonly Bindable<ReleaseStream> releaseStream = new Bindable<ReleaseStream>();
-        private UpdateManager? updateManager;
-        private UpdateInfo? pendingUpdate;
+        private ScheduledDelegate? scheduledBackgroundCheck;
 
-        protected override void LoadComplete()
+        private void scheduleNextUpdateCheck()
         {
-            // Used by the base implementation.
-            osuConfigManager.BindWith(OsuSetting.ReleaseStream, releaseStream);
-            releaseStream.BindValueChanged(_ => onReleaseStreamChanged(), true);
-
-            base.LoadComplete();
+            scheduledBackgroundCheck?.Cancel();
+            scheduledBackgroundCheck = Scheduler.AddDelayed(() =>
+            {
+                log("Running scheduled background update check...");
+                CheckForUpdate();
+            }, 60000 * 30);
         }
 
-        private void onReleaseStreamChanged()
+        protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
         {
-            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, releaseStream.Value == ReleaseStream.Tachyon), new UpdateOptions
+            scheduledBackgroundCheck?.Cancel();
+
+            if (isInGameplay)
             {
-                AllowVersionDowngrade = true,
+                log("Update check cancelled - user is in gameplay");
+                scheduleNextUpdateCheck();
+                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
+            {
+                AllowVersionDowngrade = true
             });
 
-            Schedule(() => Task.Run(CheckForUpdateAsync));
-        }
+            UpdateInfo? update = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
 
-        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
-
-        private async Task<bool> checkForUpdateAsync()
-        {
-            // whether to check again in 30 minutes. generally only if there's an error or no update was found (yet).
-            bool scheduleRecheck = false;
-
-            try
+            if (cancellationToken.IsCancellationRequested)
             {
-                // Avoid any kind of update checking while gameplay is running.
-                if (isInGameplay)
-                {
-                    scheduleRecheck = true;
-                    return true;
-                }
-
-                // TODO: we should probably be checking if there's a more recent update, rather than shortcutting here.
-                // Velopack does support this scenario (see https://github.com/ppy/osu/pull/28743#discussion_r1743495975).
-                if (pendingUpdate != null)
-                {
-                    // If there is an update pending restart, show the notification to restart again.
-                    notificationOverlay.Post(new UpdateApplicationCompleteNotification
-                    {
-                        Activated = () =>
-                        {
-                            Task.Run(restartToApplyUpdate);
-                            return true;
-                        }
-                    });
-
-                    return true;
-                }
-
-                if (updateManager == null)
-                {
-                    scheduleRecheck = true;
-                    return false;
-                }
-
-                pendingUpdate = await updateManager.CheckForUpdatesAsync().ConfigureAwait(false);
-
-                // No update is available. We'll check again later.
-                if (pendingUpdate == null)
-                {
-                    scheduleRecheck = true;
-                    return false;
-                }
-
-                // An update is found, let's notify the user and start downloading it.
-                UpdateProgressNotification notification = new UpdateProgressNotification
-                {
-                    CompletionClickAction = () =>
-                    {
-                        Task.Run(restartToApplyUpdate);
-                        return true;
-                    },
-                };
-
-                runOutsideOfGameplay(() => notificationOverlay.Post(notification));
-                notification.StartDownload();
-
-                try
-                {
-                    await updateManager.DownloadUpdatesAsync(pendingUpdate, p => notification.Progress = p / 100f).ConfigureAwait(false);
-                    runOutsideOfGameplay(() => notification.State = ProgressNotificationState.Completed);
-                }
-                catch (Exception e)
-                {
-                    // In the case of an error, a separate notification will be displayed.
-                    scheduleRecheck = true;
-                    notification.FailDownload();
-                    Logger.Error(e, @"update failed!");
-                }
-            }
-            catch (Exception e)
-            {
-                // we'll ignore this and retry later. can be triggered by no internet connection or thread abortion.
-                scheduleRecheck = true;
-                Logger.Log($@"update check failed ({e.Message})");
-            }
-            finally
-            {
-                if (scheduleRecheck)
-                {
-                    Scheduler.AddDelayed(() => Task.Run(async () => await checkForUpdateAsync().ConfigureAwait(false)), 60000 * 30);
-                }
+                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;
         }
 
-        private void runOutsideOfGameplay(Action action)
+        private void downloadUpdate(Velopack.UpdateManager updateManager, UpdateInfo update, CancellationToken cancellationToken) => Task.Run(async () =>
         {
+            log($"Beginning download of update {update.TargetFullRelease.Version}...");
+
+            UpdateDownloadProgressNotification progressNotification = new UpdateDownloadProgressNotification(cancellationToken)
+            {
+                CompletionClickAction = () =>
+                {
+                    restartToApplyUpdate(updateManager, update);
+                    return true;
+                }
+            };
+
+            try
+            {
+                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(progressNotification.CancellationToken, cancellationToken))
+                {
+                    progressNotification.StartDownload();
+                    runOutsideOfGameplay(() => notificationOverlay.Post(progressNotification), cts.Token);
+
+                    await updateManager.DownloadUpdatesAsync(update, p => progressNotification.Progress = p / 100f, cts.Token).ConfigureAwait(false);
+                    runOutsideOfGameplay(() => progressNotification.State = ProgressNotificationState.Completed, cts.Token);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                progressNotification.FailDownload();
+                log(@"Update cancelled");
+            }
+            catch (Exception e)
+            {
+                // In the case of an error, a separate notification will be displayed.
+                progressNotification.FailDownload();
+                Logger.Error(e, @"Update failed!");
+            }
+
+            return true;
+        }, cancellationToken);
+
+        private void runOutsideOfGameplay(Action action, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+                return;
+
             if (isInGameplay)
             {
-                Scheduler.AddDelayed(() => runOutsideOfGameplay(action), 1000);
+                Scheduler.AddDelayed(() => runOutsideOfGameplay(action, cancellationToken), 1000);
                 return;
             }
 
             action();
         }
 
-        private async Task restartToApplyUpdate()
+        private void restartToApplyUpdate(Velopack.UpdateManager updateManager, UpdateInfo update) => Task.Run(async () =>
         {
-            if (updateManager == null)
-                return;
-
-            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
+            await updateManager.WaitExitThenApplyUpdatesAsync(update.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
-        }
+        });
+
+        private static void log(string text) => Logger.Log($"VelopackUpdateManager: {text}");
     }
 }
diff --git a/osu.Desktop/osu.Desktop.csproj b/osu.Desktop/osu.Desktop.csproj
index 05d5bb19fb..b0c5c953d4 100644
--- a/osu.Desktop/osu.Desktop.csproj
+++ b/osu.Desktop/osu.Desktop.csproj
@@ -26,7 +26,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.1053" />
+    <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />
diff --git a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
index d43290e661..1ff5083aaf 100644
--- a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
+++ b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects;
 
@@ -23,21 +24,21 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Fruits",
+                    Name = BeatmapStatisticStrings.Fruits,
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Streams",
+                    Name = BeatmapStatisticStrings.JuiceStreams,
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Showers",
+                    Name = BeatmapStatisticStrings.BananaShowers,
                     Content = bananaShowers.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     BarDisplayLength = Math.Min(bananaShowers / 10f, 1),
diff --git a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
index dfe9dc9dd8..370eb37d16 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -219,5 +220,40 @@ namespace osu.Game.Rulesets.Catch.Edit
             distanceSnapGrid.StartTime = sourceHitObject.GetEndTime();
             distanceSnapGrid.StartX = sourceHitObject.EffectiveX;
         }
+
+        #region Clipboard handling
+
+        public override string ConvertSelectionToString()
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<CatchHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
+        // 1,2,3,4 ...
+        private static readonly Regex selection_regex = new Regex(@"^\d+(,\d+)*$", RegexOptions.Compiled);
+
+        public override void SelectFromTimestamp(double timestamp, string objectDescription)
+        {
+            if (!selection_regex.IsMatch(objectDescription))
+                return;
+
+            List<CatchHitObject> remainingHitObjects = EditorBeatmap.HitObjects.Cast<CatchHitObject>().Where(h => h.StartTime >= timestamp).ToList();
+            string[] splitDescription = objectDescription.Split(',');
+
+            for (int i = 0; i < splitDescription.Length; i++)
+            {
+                if (!int.TryParse(splitDescription[i], out int combo) || combo < 1)
+                    continue;
+
+                CatchHitObject? current = remainingHitObjects.FirstOrDefault(h => h.IndexInCurrentCombo + 1 == combo);
+
+                if (current == null)
+                    continue;
+
+                EditorBeatmap.SelectedHitObjects.Add(current);
+
+                if (i < splitDescription.Length - 1)
+                    remainingHitObjects = remainingHitObjects.Where(h => h != current && h.StartTime >= current.StartTime).ToList();
+            }
+        }
+
+        #endregion
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs b/osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs
index c300afa79f..e4a910700c 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
+                if (!IsExactlyOneSettingChanged(CircleSize, ApproachRate, OverallDifficulty, DrainRate))
                     return string.Empty;
 
                 if (!CircleSize.IsDefault) return format("CS", CircleSize);
diff --git a/osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs b/osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs
index e30e535e9b..dd1ada21bd 100644
--- a/osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs
+++ b/osu.Game.Rulesets.Catch/Replays/CatchReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -64,5 +65,12 @@ namespace osu.Game.Rulesets.Catch.Replays
 
             return new LegacyReplayFrame(Time, Position, null, state);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is CatchReplayFrame catchFrame
+               && Time == catchFrame.Time
+               && Position == catchFrame.Position
+               && Dashing == catchFrame.Dashing
+               && Actions.SequenceEqual(catchFrame.Actions);
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
index 2a7f2dc7ea..2c17cd8015 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
@@ -19,7 +19,6 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
     {
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
@@ -72,13 +71,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -137d, HitResult.Miss },
             new object[] { 5f, -138d, HitResult.Miss },
             new object[] { 5f, 111d, HitResult.Ok },
-            new object[] { 5f, 112d, HitResult.Miss },
-            new object[] { 5f, 113d, HitResult.Miss },
-            new object[] { 5f, 114d, HitResult.Miss },
-            new object[] { 5f, 135d, HitResult.Miss },
-            new object[] { 5f, 136d, HitResult.Miss },
-            new object[] { 5f, 137d, HitResult.Miss },
-            new object[] { 5f, 138d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 112d, HitResult.Miss },
+            // new object[] { 5f, 113d, HitResult.Miss },
+            // new object[] { 5f, 114d, HitResult.Miss },
+            // new object[] { 5f, 135d, HitResult.Miss },
+            // new object[] { 5f, 136d, HitResult.Miss },
+            // new object[] { 5f, 137d, HitResult.Miss },
+            // new object[] { 5f, 138d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // PERFECT hit window is [ -14ms,  14ms]
@@ -99,13 +99,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 71d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
-            new object[] { 9.3f, 99d, HitResult.Miss },
-            new object[] { 9.3f, 100d, HitResult.Miss },
-            new object[] { 9.3f, 101d, HitResult.Miss },
-            new object[] { 9.3f, 122d, HitResult.Miss },
-            new object[] { 9.3f, 123d, HitResult.Miss },
-            new object[] { 9.3f, 124d, HitResult.Miss },
-            new object[] { 9.3f, 125d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 99d, HitResult.Miss },
+            // new object[] { 9.3f, 100d, HitResult.Miss },
+            // new object[] { 9.3f, 101d, HitResult.Miss },
+            // new object[] { 9.3f, 122d, HitResult.Miss },
+            // new object[] { 9.3f, 123d, HitResult.Miss },
+            // new object[] { 9.3f, 124d, HitResult.Miss },
+            // new object[] { 9.3f, 125d, HitResult.Miss },
             new object[] { 9.3f, -98d, HitResult.Ok },
             new object[] { 9.3f, -99d, HitResult.Ok },
             new object[] { 9.3f, -100d, HitResult.Meh },
@@ -145,13 +146,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -137d, HitResult.Miss },
             new object[] { 5f, -138d, HitResult.Miss },
             new object[] { 5f, 111d, HitResult.Ok },
-            new object[] { 5f, 112d, HitResult.Miss },
-            new object[] { 5f, 113d, HitResult.Miss },
-            new object[] { 5f, 114d, HitResult.Miss },
-            new object[] { 5f, 135d, HitResult.Miss },
-            new object[] { 5f, 136d, HitResult.Miss },
-            new object[] { 5f, 137d, HitResult.Miss },
-            new object[] { 5f, 138d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 112d, HitResult.Miss },
+            // new object[] { 5f, 113d, HitResult.Miss },
+            // new object[] { 5f, 114d, HitResult.Miss },
+            // new object[] { 5f, 135d, HitResult.Miss },
+            // new object[] { 5f, 136d, HitResult.Miss },
+            // new object[] { 5f, 137d, HitResult.Miss },
+            // new object[] { 5f, 138d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // PERFECT hit window is [ -16ms,  16ms]
@@ -172,13 +174,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 71d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
-            new object[] { 9.3f, 99d, HitResult.Miss },
-            new object[] { 9.3f, 100d, HitResult.Miss },
-            new object[] { 9.3f, 101d, HitResult.Miss },
-            new object[] { 9.3f, 122d, HitResult.Miss },
-            new object[] { 9.3f, 123d, HitResult.Miss },
-            new object[] { 9.3f, 124d, HitResult.Miss },
-            new object[] { 9.3f, 125d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 99d, HitResult.Miss },
+            // new object[] { 9.3f, 100d, HitResult.Miss },
+            // new object[] { 9.3f, 101d, HitResult.Miss },
+            // new object[] { 9.3f, 122d, HitResult.Miss },
+            // new object[] { 9.3f, 123d, HitResult.Miss },
+            // new object[] { 9.3f, 124d, HitResult.Miss },
+            // new object[] { 9.3f, 125d, HitResult.Miss },
             new object[] { 9.3f, -98d, HitResult.Ok },
             new object[] { 9.3f, -99d, HitResult.Ok },
             new object[] { 9.3f, -100d, HitResult.Meh },
@@ -207,13 +210,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 3.1f, 88d, HitResult.Ok },
             new object[] { 3.1f, 89d, HitResult.Ok },
             new object[] { 3.1f, 116d, HitResult.Ok },
-            new object[] { 3.1f, 117d, HitResult.Miss },
-            new object[] { 3.1f, 118d, HitResult.Miss },
-            new object[] { 3.1f, 119d, HitResult.Miss },
-            new object[] { 3.1f, 140d, HitResult.Miss },
-            new object[] { 3.1f, 141d, HitResult.Miss },
-            new object[] { 3.1f, 142d, HitResult.Miss },
-            new object[] { 3.1f, 143d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 3.1f, 117d, HitResult.Miss },
+            // new object[] { 3.1f, 118d, HitResult.Miss },
+            // new object[] { 3.1f, 119d, HitResult.Miss },
+            // new object[] { 3.1f, 140d, HitResult.Miss },
+            // new object[] { 3.1f, 141d, HitResult.Miss },
+            // new object[] { 3.1f, 142d, HitResult.Miss },
+            // new object[] { 3.1f, 143d, HitResult.Miss },
             new object[] { 3.1f, -116d, HitResult.Ok },
             new object[] { 3.1f, -117d, HitResult.Ok },
             new object[] { 3.1f, -118d, HitResult.Meh },
@@ -253,13 +257,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -122d, HitResult.Miss },
             new object[] { 5f, -123d, HitResult.Miss },
             new object[] { 5f, 96d, HitResult.Ok },
-            new object[] { 5f, 97d, HitResult.Miss },
-            new object[] { 5f, 98d, HitResult.Miss },
-            new object[] { 5f, 99d, HitResult.Miss },
-            new object[] { 5f, 120d, HitResult.Miss },
-            new object[] { 5f, 121d, HitResult.Miss },
-            new object[] { 5f, 122d, HitResult.Miss },
-            new object[] { 5f, 123d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 97d, HitResult.Miss },
+            // new object[] { 5f, 98d, HitResult.Miss },
+            // new object[] { 5f, 99d, HitResult.Miss },
+            // new object[] { 5f, 120d, HitResult.Miss },
+            // new object[] { 5f, 121d, HitResult.Miss },
+            // new object[] { 5f, 122d, HitResult.Miss },
+            // new object[] { 5f, 123d, HitResult.Miss },
 
             // OD = 3.1 test cases.
             // PERFECT hit window is [ -16ms,  16ms]
@@ -280,13 +285,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 3.1f, 78d, HitResult.Ok },
             new object[] { 3.1f, 79d, HitResult.Ok },
             new object[] { 3.1f, 96d, HitResult.Ok },
-            new object[] { 3.1f, 97d, HitResult.Miss },
-            new object[] { 3.1f, 98d, HitResult.Miss },
-            new object[] { 3.1f, 99d, HitResult.Miss },
-            new object[] { 3.1f, 120d, HitResult.Miss },
-            new object[] { 3.1f, 121d, HitResult.Miss },
-            new object[] { 3.1f, 122d, HitResult.Miss },
-            new object[] { 3.1f, 123d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 3.1f, 97d, HitResult.Miss },
+            // new object[] { 3.1f, 98d, HitResult.Miss },
+            // new object[] { 3.1f, 99d, HitResult.Miss },
+            // new object[] { 3.1f, 120d, HitResult.Miss },
+            // new object[] { 3.1f, 121d, HitResult.Miss },
+            // new object[] { 3.1f, 122d, HitResult.Miss },
+            // new object[] { 3.1f, 123d, HitResult.Miss },
             new object[] { 3.1f, -96d, HitResult.Ok },
             new object[] { 3.1f, -97d, HitResult.Ok },
             new object[] { 3.1f, -98d, HitResult.Meh },
@@ -327,13 +333,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -98d, HitResult.Miss },
             new object[] { 5f, -99d, HitResult.Miss },
             new object[] { 5f, 79d, HitResult.Ok },
-            new object[] { 5f, 80d, HitResult.Miss },
-            new object[] { 5f, 81d, HitResult.Miss },
-            new object[] { 5f, 82d, HitResult.Miss },
-            new object[] { 5f, 96d, HitResult.Miss },
-            new object[] { 5f, 97d, HitResult.Miss },
-            new object[] { 5f, 98d, HitResult.Miss },
-            new object[] { 5f, 99d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 80d, HitResult.Miss },
+            // new object[] { 5f, 81d, HitResult.Miss },
+            // new object[] { 5f, 82d, HitResult.Miss },
+            // new object[] { 5f, 96d, HitResult.Miss },
+            // new object[] { 5f, 97d, HitResult.Miss },
+            // new object[] { 5f, 98d, HitResult.Miss },
+            // new object[] { 5f, 99d, HitResult.Miss },
 
             // OD = 9.3 test cases.
             // This leads to "effective" OD of 13.02.
@@ -356,13 +363,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 9.3f, 50d, HitResult.Ok },
             new object[] { 9.3f, 51d, HitResult.Ok },
             new object[] { 9.3f, 69d, HitResult.Ok },
-            new object[] { 9.3f, 70d, HitResult.Miss },
-            new object[] { 9.3f, 71d, HitResult.Miss },
-            new object[] { 9.3f, 72d, HitResult.Miss },
-            new object[] { 9.3f, 86d, HitResult.Miss },
-            new object[] { 9.3f, 87d, HitResult.Miss },
-            new object[] { 9.3f, 88d, HitResult.Miss },
-            new object[] { 9.3f, 89d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 9.3f, 70d, HitResult.Miss },
+            // new object[] { 9.3f, 71d, HitResult.Miss },
+            // new object[] { 9.3f, 72d, HitResult.Miss },
+            // new object[] { 9.3f, 86d, HitResult.Miss },
+            // new object[] { 9.3f, 87d, HitResult.Miss },
+            // new object[] { 9.3f, 88d, HitResult.Miss },
+            // new object[] { 9.3f, 89d, HitResult.Miss },
             new object[] { 9.3f, -69d, HitResult.Ok },
             new object[] { 9.3f, -70d, HitResult.Ok },
             new object[] { 9.3f, -71d, HitResult.Meh },
@@ -402,13 +410,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -191d, HitResult.Miss },
             new object[] { 5f, -192d, HitResult.Miss },
             new object[] { 5f, 155d, HitResult.Ok },
-            new object[] { 5f, 156d, HitResult.Miss },
-            new object[] { 5f, 157d, HitResult.Miss },
-            new object[] { 5f, 158d, HitResult.Miss },
-            new object[] { 5f, 189d, HitResult.Miss },
-            new object[] { 5f, 190d, HitResult.Miss },
-            new object[] { 5f, 191d, HitResult.Miss },
-            new object[] { 5f, 192d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 156d, HitResult.Miss },
+            // new object[] { 5f, 157d, HitResult.Miss },
+            // new object[] { 5f, 158d, HitResult.Miss },
+            // new object[] { 5f, 189d, HitResult.Miss },
+            // new object[] { 5f, 190d, HitResult.Miss },
+            // new object[] { 5f, 191d, HitResult.Miss },
+            // new object[] { 5f, 192d, HitResult.Miss },
         };
 
         private static readonly object[][] score_v1_non_convert_double_time_test_cases =
@@ -440,13 +449,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -205d, HitResult.Miss },
             new object[] { 5f, -206d, HitResult.Miss },
             new object[] { 5f, 167d, HitResult.Ok },
-            new object[] { 5f, 168d, HitResult.Miss },
-            new object[] { 5f, 169d, HitResult.Miss },
-            new object[] { 5f, 170d, HitResult.Miss },
-            new object[] { 5f, 203d, HitResult.Miss },
-            new object[] { 5f, 204d, HitResult.Miss },
-            new object[] { 5f, 205d, HitResult.Miss },
-            new object[] { 5f, 206d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 168d, HitResult.Miss },
+            // new object[] { 5f, 169d, HitResult.Miss },
+            // new object[] { 5f, 170d, HitResult.Miss },
+            // new object[] { 5f, 203d, HitResult.Miss },
+            // new object[] { 5f, 204d, HitResult.Miss },
+            // new object[] { 5f, 205d, HitResult.Miss },
+            // new object[] { 5f, 206d, HitResult.Miss },
         };
 
         private static readonly object[][] score_v1_non_convert_half_time_test_cases =
@@ -478,13 +488,14 @@ namespace osu.Game.Rulesets.Mania.Tests
             new object[] { 5f, -103d, HitResult.Miss },
             new object[] { 5f, -104d, HitResult.Miss },
             new object[] { 5f, 83d, HitResult.Ok },
-            new object[] { 5f, 84d, HitResult.Miss },
-            new object[] { 5f, 85d, HitResult.Miss },
-            new object[] { 5f, 86d, HitResult.Miss },
-            new object[] { 5f, 101d, HitResult.Miss },
-            new object[] { 5f, 102d, HitResult.Miss },
-            new object[] { 5f, 103d, HitResult.Miss },
-            new object[] { 5f, 104d, HitResult.Miss },
+            // coverage of broken "can't hit meh late" behaviour, which is intentionally not being reproduced
+            // new object[] { 5f, 84d, HitResult.Miss },
+            // new object[] { 5f, 85d, HitResult.Miss },
+            // new object[] { 5f, 86d, HitResult.Miss },
+            // new object[] { 5f, 101d, HitResult.Miss },
+            // new object[] { 5f, 102d, HitResult.Miss },
+            // new object[] { 5f, 103d, HitResult.Miss },
+            // new object[] { 5f, 104d, HitResult.Miss },
         };
 
         private const double note_time = 300;
@@ -517,6 +528,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV2 single note @ OD{overallDifficulty}", beatmap, $@"SV2 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1NonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -544,6 +556,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1 single note @ OD{overallDifficulty}", beatmap, $@"SV1 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_convert_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1Convert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -572,6 +585,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_hard_rock_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndHardRockNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -600,6 +614,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+HR single note @ OD{overallDifficulty}", beatmap, $@"SV1+HR {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_easy_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndEasyNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -628,6 +643,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+EZ single note @ OD{overallDifficulty}", beatmap, $@"SV1+EZ {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_double_time_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndDoubleTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
@@ -656,6 +672,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             RunTest($@"SV1+DT single note @ OD{overallDifficulty}", beatmap, $@"SV1+DT {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
         }
 
+        [Ignore("Tests expected to fail until stable's detailed treatment of hit windows in mania is reproduced.")]
         [TestCaseSource(nameof(score_v1_non_convert_half_time_test_cases))]
         public void TestHitWindowTreatmentWithScoreV1AndHalfTimeNonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs
index 64496d7628..a8160d3373 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs
@@ -12,7 +12,6 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneReplayStability : ReplayStabilityTestScene
     {
         private static readonly object[][] test_cases =
@@ -22,87 +21,79 @@ namespace osu.Game.Rulesets.Mania.Tests
             // while round brackets `()` represent *open* or *exclusive* bounds.
 
             // OD = 5 test cases.
-            // PERFECT hit window is [ -19.4ms,  19.4ms]
-            // GREAT   hit window is [ -49.0ms,  49.0ms]
-            // GOOD    hit window is [ -82.0ms,  82.0ms]
-            // OK      hit window is [-112.0ms, 112.0ms]
-            // MEH     hit window is [-136.0ms, 136.0ms]
-            // MISS    hit window is [-173.0ms, 173.0ms]
+            // PERFECT hit window is [ -19.5ms,  19.5ms]
+            // GREAT   hit window is [ -49.5ms,  49.5ms]
+            // GOOD    hit window is [ -82.5ms,  82.5ms]
+            // OK      hit window is [-112.5ms, 112.5ms]
+            // MEH     hit window is [-136.5ms, 136.5ms]
+            // MISS    hit window is [-173.5ms, 173.5ms]
             new object[] { 5f, -19d, HitResult.Perfect },
             new object[] { 5f, -19.2d, HitResult.Perfect },
-            new object[] { 5f, -19.38d, HitResult.Perfect },
-            // new object[] { 5f, -19.4d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
-            new object[] { 5f, -19.44d, HitResult.Great },
             new object[] { 5f, -19.7d, HitResult.Great },
             new object[] { 5f, -20d, HitResult.Great },
             new object[] { 5f, -48d, HitResult.Great },
             new object[] { 5f, -48.4d, HitResult.Great },
             new object[] { 5f, -48.7d, HitResult.Great },
             new object[] { 5f, -49d, HitResult.Great },
-            new object[] { 5f, -49.2d, HitResult.Good },
+            new object[] { 5f, -49.2d, HitResult.Great },
             new object[] { 5f, -49.7d, HitResult.Good },
             new object[] { 5f, -50d, HitResult.Good },
             new object[] { 5f, -81d, HitResult.Good },
             new object[] { 5f, -81.2d, HitResult.Good },
             new object[] { 5f, -81.7d, HitResult.Good },
             new object[] { 5f, -82d, HitResult.Good },
-            new object[] { 5f, -82.2d, HitResult.Ok },
+            new object[] { 5f, -82.2d, HitResult.Good },
             new object[] { 5f, -82.7d, HitResult.Ok },
             new object[] { 5f, -83d, HitResult.Ok },
             new object[] { 5f, -111d, HitResult.Ok },
             new object[] { 5f, -111.2d, HitResult.Ok },
             new object[] { 5f, -111.7d, HitResult.Ok },
             new object[] { 5f, -112d, HitResult.Ok },
-            new object[] { 5f, -112.2d, HitResult.Meh },
+            new object[] { 5f, -112.2d, HitResult.Ok },
             new object[] { 5f, -112.7d, HitResult.Meh },
             new object[] { 5f, -113d, HitResult.Meh },
             new object[] { 5f, -135d, HitResult.Meh },
             new object[] { 5f, -135.2d, HitResult.Meh },
             new object[] { 5f, -135.8d, HitResult.Meh },
             new object[] { 5f, -136d, HitResult.Meh },
-            new object[] { 5f, -136.2d, HitResult.Miss },
+            new object[] { 5f, -136.2d, HitResult.Meh },
             new object[] { 5f, -136.7d, HitResult.Miss },
             new object[] { 5f, -137d, HitResult.Miss },
 
             // OD = 9.3 test cases.
-            // PERFECT hit window is [ -14.67ms,  14.67ms]
-            // GREAT   hit window is [ -36.10ms,  36.10ms]
-            // GOOD    hit window is [ -69.10ms,  69.10ms]
-            // OK      hit window is [ -99.10ms,  99.10ms]
-            // MEH     hit window is [-123.10ms, 123.10ms]
-            // MISS    hit window is [-160.10ms, 160.10ms]
+            // PERFECT hit window is [ -14.5ms,  14.5ms]
+            // GREAT   hit window is [ -36.5ms,  36.5ms]
+            // GOOD    hit window is [ -69.5ms,  69.5ms]
+            // OK      hit window is [ -99.5ms,  99.5ms]
+            // MEH     hit window is [-123.5ms, 123.5ms]
+            // MISS    hit window is [-160.5ms, 160.5ms]
             new object[] { 9.3f, 14d, HitResult.Perfect },
             new object[] { 9.3f, 14.2d, HitResult.Perfect },
-            new object[] { 9.3f, 14.6d, HitResult.Perfect },
-            // new object[] { 9.3f, 14.67d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
             new object[] { 9.3f, 14.7d, HitResult.Great },
             new object[] { 9.3f, 15d, HitResult.Great },
             new object[] { 9.3f, 35d, HitResult.Great },
             new object[] { 9.3f, 35.3d, HitResult.Great },
             new object[] { 9.3f, 35.8d, HitResult.Great },
-            new object[] { 9.3f, 36.05d, HitResult.Great },
-            new object[] { 9.3f, 36.3d, HitResult.Good },
+            new object[] { 9.3f, 36.3d, HitResult.Great },
             new object[] { 9.3f, 36.7d, HitResult.Good },
             new object[] { 9.3f, 37d, HitResult.Good },
             new object[] { 9.3f, 68d, HitResult.Good },
             new object[] { 9.3f, 68.4d, HitResult.Good },
             new object[] { 9.3f, 68.9d, HitResult.Good },
-            new object[] { 9.3f, 69.07d, HitResult.Good },
-            new object[] { 9.3f, 69.25d, HitResult.Ok },
+            new object[] { 9.3f, 69.25d, HitResult.Good },
             new object[] { 9.3f, 69.85d, HitResult.Ok },
             new object[] { 9.3f, 70d, HitResult.Ok },
             new object[] { 9.3f, 98d, HitResult.Ok },
             new object[] { 9.3f, 98.3d, HitResult.Ok },
             new object[] { 9.3f, 98.6d, HitResult.Ok },
             new object[] { 9.3f, 99d, HitResult.Ok },
-            new object[] { 9.3f, 99.3d, HitResult.Meh },
+            new object[] { 9.3f, 99.3d, HitResult.Ok },
             new object[] { 9.3f, 99.7d, HitResult.Meh },
             new object[] { 9.3f, 100d, HitResult.Meh },
             new object[] { 9.3f, 122d, HitResult.Meh },
             new object[] { 9.3f, 122.34d, HitResult.Meh },
             new object[] { 9.3f, 122.57d, HitResult.Meh },
-            new object[] { 9.3f, 123.04d, HitResult.Meh },
-            new object[] { 9.3f, 123.45d, HitResult.Miss },
+            new object[] { 9.3f, 123.45d, HitResult.Meh },
             new object[] { 9.3f, 123.95d, HitResult.Miss },
             new object[] { 9.3f, 124d, HitResult.Miss },
         };
@@ -110,7 +101,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [TestCaseSource(nameof(test_cases))]
         public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
         {
-            const double note_time = 100;
+            const double note_time = 300;
 
             var beatmap = new ManiaBeatmap(new StageDefinition(1))
             {
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
index 3ee1b63800..1f8380a9f7 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 
@@ -42,14 +43,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Notes",
+                    Name = BeatmapStatisticStrings.Notes,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
                     BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Notes",
+                    Name = BeatmapStatisticStrings.HoldNotes,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
                     BarDisplayLength = holdNotes / (float)sum,
diff --git a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
index 6c607886ae..23c062164e 100644
--- a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
@@ -197,6 +197,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         public override void OnKilled()
         {
             base.OnKilled();
+            // flush the final state of holding on kill.
+            // this matters because some skin implementations like legacy skin
+            // insert drawables in the hierarchy that are not a child of this DHO
+            // (see `LegacyBodyPiece` and related machinations with `lightContainer` being added at column level)
+            isHolding.Value = Result.IsHolding(Time.Current);
             (bodyPiece.Drawable as IHoldNoteBody)?.Recycle();
         }
 
diff --git a/osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs b/osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs
index f80c442025..abbaa374f0 100644
--- a/osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs
+++ b/osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -47,5 +48,8 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is ManiaReplayFrame maniaFrame && Time == maniaFrame.Time && Actions.SequenceEqual(maniaFrame.Actions);
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
index 627f48f391..96dbd957ae 100644
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
@@ -1,15 +1,30 @@
 // 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 System;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 
 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);
+        private static readonly DifficultyRange great_window_range = new DifficultyRange(64, 49, 34);
+        private static readonly DifficultyRange good_window_range = new DifficultyRange(97, 82, 67);
+        private static readonly DifficultyRange ok_window_range = new DifficultyRange(127, 112, 97);
+        private static readonly DifficultyRange meh_window_range = new DifficultyRange(151, 136, 121);
+        private static readonly DifficultyRange miss_window_range = new DifficultyRange(188, 173, 158);
+
         private readonly double multiplier;
 
+        private double perfect;
+        private double great;
+        private double good;
+        private double ok;
+        private double meh;
+        private double miss;
+
         public ManiaHitWindows()
             : this(1)
         {
@@ -36,11 +51,41 @@ namespace osu.Game.Rulesets.Mania.Scoring
             return false;
         }
 
-        protected override DifficultyRange[] GetRanges() => base.GetRanges().Select(r =>
-            new DifficultyRange(
-                r.Result,
-                r.Min * multiplier,
-                r.Average * multiplier,
-                r.Max * multiplier)).ToArray();
+        public override void SetDifficulty(double difficulty)
+        {
+            perfect = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, perfect_window_range) * multiplier) + 0.5;
+            great = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, great_window_range) * multiplier) + 0.5;
+            good = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, good_window_range) * multiplier) + 0.5;
+            ok = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, ok_window_range) * multiplier) + 0.5;
+            meh = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, meh_window_range) * multiplier) + 0.5;
+            miss = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, miss_window_range) * multiplier) + 0.5;
+        }
+
+        public override double WindowFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Perfect:
+                    return perfect;
+
+                case HitResult.Great:
+                    return great;
+
+                case HitResult.Good:
+                    return good;
+
+                case HitResult.Ok:
+                    return ok;
+
+                case HitResult.Meh:
+                    return meh;
+
+                case HitResult.Miss:
+                    return miss;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(result), result, null);
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
index 33ae2c68e6..496e7610ff 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs
@@ -5,7 +5,6 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Framework.Utils;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
@@ -36,22 +35,21 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
         [Test]
         public void TestPlayfieldBasedSize()
         {
-            ModFlashlight mod = new OsuModFlashlight();
+            OsuModFlashlight flashlight;
             CreateModTest(new ModTestData
             {
-                Mod = mod,
+                Mods = [flashlight = new OsuModFlashlight(), new OsuModBarrelRoll()],
                 PassCondition = () =>
                 {
                     var flashlightOverlay = Player.DrawableRuleset.Overlays
                                                   .ChildrenOfType<ModFlashlight<OsuHitObject>.Flashlight>()
                                                   .First();
 
-                    return Precision.AlmostEquals(mod.DefaultFlashlightSize * .5f, flashlightOverlay.GetSize());
+                    // 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;
                 }
             });
-
-            AddStep("adjust playfield scale", () =>
-                Player.DrawableRuleset.Playfield.Scale = new Vector2(.5f));
         }
 
         [Test]
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRelax.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRelax.cs
index 1bb2f24c1c..b4298344b8 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRelax.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRelax.cs
@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Replays;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -22,21 +21,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
     public partial class TestSceneOsuModRelax : OsuModTestScene
     {
-        private readonly HitCircle hitObject;
-        private readonly HitWindows hitWindows = new OsuHitWindows();
-
-        public TestSceneOsuModRelax()
-        {
-            hitWindows.SetDifficulty(9);
-
-            hitObject = new HitCircle
-            {
-                StartTime = 1000,
-                Position = new Vector2(100, 100),
-                HitWindows = hitWindows
-            };
-        }
-
         protected override TestPlayer CreateModPlayer(Ruleset ruleset) => new ModRelaxTestPlayer(CurrentTestData, AllowFail);
 
         [Test]
@@ -46,12 +30,21 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             Autoplay = false,
             CreateBeatmap = () => new Beatmap
             {
-                HitObjects = new List<HitObject> { hitObject }
+                Difficulty = { OverallDifficulty = 9 },
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle
+                    {
+                        StartTime = 1000,
+                        Position = new Vector2(100, 100),
+                        HitWindows = new OsuHitWindows()
+                    }
+                }
             },
             ReplayFrames = new List<ReplayFrame>
             {
                 new OsuReplayFrame(0, new Vector2()),
-                new OsuReplayFrame(hitObject.StartTime, hitObject.Position),
+                new OsuReplayFrame(100, new Vector2(100)),
             },
             PassCondition = () => Player.ScoreProcessor.Combo.Value == 1
         });
@@ -63,13 +56,22 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             Autoplay = false,
             CreateBeatmap = () => new Beatmap
             {
-                HitObjects = new List<HitObject> { hitObject }
+                Difficulty = { OverallDifficulty = 9 },
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle
+                    {
+                        StartTime = 1000,
+                        Position = new Vector2(100, 100),
+                        HitWindows = new OsuHitWindows()
+                    }
+                }
             },
             ReplayFrames = new List<ReplayFrame>
             {
-                new OsuReplayFrame(0, new Vector2(hitObject.X - 22, hitObject.Y - 22)), // must be an edge hit for the cursor to not stay on the object for too long
-                new OsuReplayFrame(hitObject.StartTime - OsuModRelax.RELAX_LENIENCY, new Vector2(hitObject.X - 22, hitObject.Y - 22)),
-                new OsuReplayFrame(hitObject.StartTime, new Vector2(0)),
+                new OsuReplayFrame(0, new Vector2(78, 78)), // must be an edge hit for the cursor to not stay on the object for too long
+                new OsuReplayFrame(1000 - OsuModRelax.RELAX_LENIENCY, new Vector2(78, 78)),
+                new OsuReplayFrame(1000, new Vector2(0)),
             },
             PassCondition = () => Player.ScoreProcessor.Combo.Value == 1
         });
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneCursorParticles.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneCursorParticles.cs
index f6e460284b..fd947343e4 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneCursorParticles.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneCursorParticles.cs
@@ -110,23 +110,23 @@ namespace osu.Game.Rulesets.Osu.Tests
                             new Spinner
                             {
                                 StartTime = 0,
-                                Duration = 1000,
+                                Duration = 3000,
                                 Position = OsuPlayfield.BASE_SIZE / 2,
                             },
                             new Slider
                             {
-                                StartTime = 2500,
+                                StartTime = 4500,
                                 RepeatCount = 0,
                                 Position = OsuPlayfield.BASE_SIZE / 2,
                                 Path = new SliderPath(new[]
                                 {
                                     new PathControlPoint(Vector2.Zero),
-                                    new PathControlPoint(new Vector2(100, 0)),
+                                    new PathControlPoint(new Vector2(200, 0)),
                                 })
                             },
                             new HitCircle
                             {
-                                StartTime = 4500,
+                                StartTime = 10000,
                                 Position = OsuPlayfield.BASE_SIZE / 2,
                             },
                         },
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs
index 379699b276..404ca0c79e 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs
@@ -17,7 +17,6 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
     {
         protected override Ruleset CreateRuleset() => new OsuRuleset();
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneOsuHitObjectSamples.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneOsuHitObjectSamples.cs
index 61cc10f284..ddea5eed87 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneOsuHitObjectSamples.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneOsuHitObjectSamples.cs
@@ -14,26 +14,27 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         protected override IResourceStore<byte[]> RulesetResources => new DllResourceStore(Assembly.GetAssembly(typeof(TestSceneOsuHitObjectSamples)));
 
-        [TestCase("normal-hitnormal")]
-        [TestCase("hitnormal")]
-        public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
+        [TestCase("normal-hitnormal2", "normal-hitnormal")]
+        [TestCase("hitnormal", "hitnormal")]
+        public void TestDefaultCustomSampleFromBeatmap(string beatmapSkinSampleName, string userSkinSampleName)
         {
-            SetupSkins(expectedSample, expectedSample);
+            SetupSkins(beatmapSkinSampleName, userSkinSampleName);
 
             CreateTestWithBeatmap("osu-hitobject-beatmap-custom-sample-bank.osu");
 
-            AssertBeatmapLookup(expectedSample);
+            AssertBeatmapLookup(beatmapSkinSampleName);
         }
 
-        [TestCase("normal-hitnormal")]
-        [TestCase("hitnormal")]
-        public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
+        [TestCase("", "normal-hitnormal")]
+        [TestCase("normal-hitnormal", "normal-hitnormal")]
+        [TestCase("", "hitnormal")]
+        public void TestDefaultCustomSampleFromUserSkinFallback(string beatmapSkinSampleName, string userSkinSampleName)
         {
-            SetupSkins(string.Empty, expectedSample);
+            SetupSkins(beatmapSkinSampleName, userSkinSampleName);
 
             CreateTestWithBeatmap("osu-hitobject-beatmap-custom-sample-bank.osu");
 
-            AssertUserLookup(expectedSample);
+            AssertUserLookup(userSkinSampleName);
         }
 
         [TestCase("normal-hitnormal2")]
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneReplayRecording.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayRecording.cs
index 6b867a7729..8608ea1dfc 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneReplayRecording.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayRecording.cs
@@ -78,6 +78,16 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("smoke button press recorded to replay", () => Player.Score.Replay.Frames.OfType<OsuReplayFrame>().Any(f => f.Actions.SequenceEqual([OsuAction.Smoke])));
         }
 
+        [Test]
+        public void TestPressAndReleaseOnSameFrame()
+        {
+            seekTo(0);
+            AddStep("move cursor to circle", () => InputManager.MoveMouseTo(Player.DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.Single()));
+            AddStep("press X", () => InputManager.PressKey(Key.X));
+            AddStep("release X", () => InputManager.ReleaseKey(Key.X));
+            AddAssert("right button press recorded to replay", () => Player.Score.Replay.Frames.OfType<OsuReplayFrame>().Any(f => f.Actions.SequenceEqual([OsuAction.RightButton])));
+        }
+
         private void seekTo(double time)
         {
             AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs
index 2303b17d96..320fdcff2c 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs
@@ -13,7 +13,6 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneReplayStability : ReplayStabilityTestScene
     {
         private static readonly object[][] test_cases =
@@ -23,53 +22,49 @@ namespace osu.Game.Rulesets.Osu.Tests
             // while round brackets `()` represent *open* or *exclusive* bounds.
 
             // OD = 5 test cases.
-            // GREAT hit window is [ -50ms,  50ms]
-            // OK    hit window is [-100ms, 100ms]
-            // MEH   hit window is [-150ms, 150ms]
-            // MISS  hit window is [-400ms, 400ms]
+            // GREAT hit window is [ -49.5ms,  49.5ms]
+            // OK    hit window is [ -99.5ms,  99.5ms]
+            // MEH   hit window is [-149.5ms, 149.5ms]
             new object[] { 5f, 49d, HitResult.Great },
             new object[] { 5f, 49.2d, HitResult.Great },
-            new object[] { 5f, 49.7d, HitResult.Great },
-            new object[] { 5f, 50d, HitResult.Great },
+            new object[] { 5f, 49.7d, HitResult.Ok },
+            new object[] { 5f, 50d, HitResult.Ok },
             new object[] { 5f, 50.4d, HitResult.Ok },
             new object[] { 5f, 50.9d, HitResult.Ok },
             new object[] { 5f, 51d, HitResult.Ok },
             new object[] { 5f, 99d, HitResult.Ok },
             new object[] { 5f, 99.2d, HitResult.Ok },
-            new object[] { 5f, 99.7d, HitResult.Ok },
-            new object[] { 5f, 100d, HitResult.Ok },
+            new object[] { 5f, 99.7d, HitResult.Meh },
+            new object[] { 5f, 100d, HitResult.Meh },
             new object[] { 5f, 100.4d, HitResult.Meh },
             new object[] { 5f, 100.9d, HitResult.Meh },
             new object[] { 5f, 101d, HitResult.Meh },
             new object[] { 5f, 149d, HitResult.Meh },
             new object[] { 5f, 149.2d, HitResult.Meh },
-            new object[] { 5f, 149.7d, HitResult.Meh },
-            new object[] { 5f, 150d, HitResult.Meh },
+            new object[] { 5f, 149.7d, HitResult.Miss },
+            new object[] { 5f, 150d, HitResult.Miss },
             new object[] { 5f, 150.4d, HitResult.Miss },
             new object[] { 5f, 150.9d, HitResult.Miss },
             new object[] { 5f, 151d, HitResult.Miss },
 
             // OD = 5.7 test cases.
-            // GREAT hit window is [ -45.8ms,  45.8ms]
-            // OK    hit window is [ -94.4ms,  94.4ms]
-            // MEH   hit window is [-143.0ms, 143.0ms]
-            // MISS  hit window is [-400.0ms, 400.0ms]
-            new object[] { 5.7f, 45d, HitResult.Great },
-            new object[] { 5.7f, 45.2d, HitResult.Great },
-            new object[] { 5.7f, 45.8d, HitResult.Great },
-            new object[] { 5.7f, 45.9d, HitResult.Ok },
-            new object[] { 5.7f, 46d, HitResult.Ok },
-            new object[] { 5.7f, 46.4d, HitResult.Ok },
-            new object[] { 5.7f, 94d, HitResult.Ok },
-            new object[] { 5.7f, 94.2d, HitResult.Ok },
-            new object[] { 5.7f, 94.4d, HitResult.Ok },
-            new object[] { 5.7f, 94.48d, HitResult.Ok },
-            new object[] { 5.7f, 94.9d, HitResult.Meh },
-            new object[] { 5.7f, 95d, HitResult.Meh },
-            new object[] { 5.7f, 95.4d, HitResult.Meh },
+            // GREAT hit window is [ -44.5ms,  44.5ms]
+            // OK    hit window is [ -93.5ms,  93.5ms]
+            // MEH   hit window is [-142.5ms, 142.5ms]
+            new object[] { 5.7f, 44d, HitResult.Great },
+            new object[] { 5.7f, 44.2d, HitResult.Great },
+            new object[] { 5.7f, 44.8d, HitResult.Ok },
+            new object[] { 5.7f, 45d, HitResult.Ok },
+            new object[] { 5.7f, 45.4d, HitResult.Ok },
+            new object[] { 5.7f, 93d, HitResult.Ok },
+            new object[] { 5.7f, 93.4d, HitResult.Ok },
+            new object[] { 5.7f, 93.9d, HitResult.Meh },
+            new object[] { 5.7f, 94d, HitResult.Meh },
+            new object[] { 5.7f, 94.4d, HitResult.Meh },
             new object[] { 5.7f, 142d, HitResult.Meh },
-            new object[] { 5.7f, 142.7d, HitResult.Meh },
-            new object[] { 5.7f, 143d, HitResult.Meh },
+            new object[] { 5.7f, 142.2d, HitResult.Meh },
+            new object[] { 5.7f, 142.7d, HitResult.Miss },
+            new object[] { 5.7f, 143d, HitResult.Miss },
             new object[] { 5.7f, 143.4d, HitResult.Miss },
             new object[] { 5.7f, 143.9d, HitResult.Miss },
             new object[] { 5.7f, 144d, HitResult.Miss },
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
index 286e4bd775..0842f8f14f 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
@@ -484,6 +484,47 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("no miss judgements recorded", () => judgementResults.All(r => r.Type.IsHit()));
         }
 
+        /// <summary>
+        /// Sliders are common to by 1/2 or 1/4 beat length in order to place the circle on the next beat.
+        /// This tests a user pressing the next circle in the window between the last tick and the end of the slider (<see cref="SliderEventGenerator.TAIL_LENIENCY"/>).
+        /// </summary>
+        [Test]
+        public void TestHitNextCircleDuringTailLeniency()
+        {
+            const double bpm = 240;
+            const double beat_length = 60000 / bpm;
+            const double slider_start = time_slider_start;
+            const double slider_end = slider_start + beat_length;
+            const double last_tick_time = slider_end + SliderEventGenerator.TAIL_LENIENCY;
+            const double next_circle_time = slider_end + beat_length / 4;
+
+            performTest(new List<ReplayFrame>
+                {
+                    new OsuReplayFrame { Position = Vector2.Zero, Actions = { OsuAction.LeftButton }, Time = time_slider_start },
+                    new OsuReplayFrame { Position = new Vector2(140, 0), Actions = { OsuAction.RightButton }, Time = last_tick_time + 20 },
+                },
+                [
+                    new Slider
+                    {
+                        StartTime = slider_start,
+                        Position = new Vector2(0, 0),
+                        TickDistanceMultiplier = 10, // no ticks
+                        Path = new SliderPath(PathType.PERFECT_CURVE, new[]
+                        {
+                            Vector2.Zero,
+                            new Vector2(100, 0),
+                        }, 100),
+                    },
+                    new HitCircle
+                    {
+                        StartTime = next_circle_time,
+                        Position = new Vector2(140, 0)
+                    }
+                ], bpm: bpm);
+
+            AddAssert("all judgements are hit", () => judgementResults.All(j => j.Type.IsHit()));
+        }
+
         private void assertAllMaxJudgements()
         {
             AddAssert("All judgements max", () =>
@@ -522,6 +563,11 @@ namespace osu.Game.Rulesets.Osu.Tests
                 }, slider_path_length),
             };
 
+            performTest(frames, [slider], bpm, tickRate);
+        }
+
+        private void performTest(List<ReplayFrame> frames, List<OsuHitObject> objects, double? bpm = null, int? tickRate = null)
+        {
             AddStep("load player", () =>
             {
                 var cpi = new ControlPointInfo();
@@ -531,7 +577,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
                 Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
                 {
-                    HitObjects = { slider },
+                    HitObjects = objects,
                     BeatmapInfo =
                     {
                         Difficulty = new BeatmapDifficulty
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderLateHitJudgement.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderLateHitJudgement.cs
index d089e924ca..3276516d0a 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderLateHitJudgement.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderLateHitJudgement.cs
@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 100, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 100, slider_end_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 99, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 99, slider_end_position, OsuAction.LeftButton),
             });
 
             assertHeadJudgement(HitResult.Ok);
@@ -70,8 +70,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 100, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 100, slider_end_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 99, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 99, slider_end_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.SliderVelocityMultiplier = 2;
@@ -91,8 +91,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_end_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_end_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.TickDistanceMultiplier = 0.2f;
@@ -116,8 +116,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_end_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_end_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.SliderVelocityMultiplier = 2;
@@ -165,8 +165,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.LINEAR, new[]
@@ -195,8 +195,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.LINEAR, new[]
@@ -224,8 +224,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.PERFECT_CURVE, new[]
@@ -259,8 +259,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.PERFECT_CURVE, new[]
@@ -289,8 +289,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position, OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position, OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position, OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.PERFECT_CURVE, new[]
@@ -320,8 +320,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             performTest(new List<ReplayFrame>
             {
-                new OsuReplayFrame(time_slider_start + 150, slider_start_position - new Vector2(20), OsuAction.LeftButton),
-                new OsuReplayFrame(time_slider_end + 150, slider_start_position - new Vector2(20), OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_start + 149, slider_start_position - new Vector2(20), OsuAction.LeftButton),
+                new OsuReplayFrame(time_slider_end + 149, slider_start_position - new Vector2(20), OsuAction.LeftButton),
             }, s =>
             {
                 s.Path = new SliderPath(PathType.PERFECT_CURVE, new[]
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
index 75bcd809c8..4a72690da2 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
@@ -22,6 +22,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
+using osu.Game.Tests;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -107,6 +108,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [FlakyTest]
         public void TestVibrateWithoutSpinningOnCentreWithDoubleTime()
         {
             List<ReplayFrame> frames = new List<ReplayFrame>();
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
index 895e9bbdee..c637ed45f7 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
@@ -476,15 +476,24 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private class TestHitWindows : HitWindows
         {
-            private static readonly DifficultyRange[] ranges =
-            {
-                new DifficultyRange(HitResult.Great, 500, 500, 500),
-                new DifficultyRange(HitResult.Miss, early_miss_window, early_miss_window, early_miss_window),
-            };
-
             public override bool IsHitResultAllowed(HitResult result) => result == HitResult.Great || result == HitResult.Miss;
 
-            protected override DifficultyRange[] GetRanges() => ranges;
+            public override void SetDifficulty(double difficulty) { }
+
+            public override double WindowFor(HitResult result)
+            {
+                switch (result)
+                {
+                    case HitResult.Great:
+                        return 500;
+
+                    case HitResult.Miss:
+                        return early_miss_window;
+
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(result), result, null);
+                }
+            }
         }
 
         private partial class ScoreAccessibleReplayPlayer : ReplayPlayer
diff --git a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
index d11b4aac3b..87e592a41c 100644
--- a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
+++ b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
@@ -22,21 +23,21 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = "Circles",
+                    Name = BeatmapStatisticStrings.Circles,
                     Content = circles.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     BarDisplayLength = circles / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = "Sliders",
+                    Name = BeatmapStatisticStrings.Sliders,
                     Content = sliders.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     BarDisplayLength = sliders / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Spinners",
+                    Name = BeatmapStatisticStrings.Spinners,
                     Content = spinners.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     BarDisplayLength = Math.Min(spinners / 10f, 1),
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
index 1d94ac6335..1c3b7360bc 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
+                if (!IsExactlyOneSettingChanged(CircleSize, ApproachRate, OverallDifficulty, DrainRate))
                     return string.Empty;
 
                 if (!CircleSize.IsDefault) return format("CS", CircleSize);
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs b/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
index b2553e295c..5038250261 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs
@@ -19,7 +19,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModMagnetised : Mod, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    public class OsuModMagnetised : Mod, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
     {
         public override string Name => "Magnetised";
         public override string Acronym => "MG";
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
index 72422a0ae8..71080e3d8e 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
@@ -115,10 +115,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         #region Reduce AR (IApplicableToDifficulty)
 
-        public void ReadFromDifficulty(IBeatmapDifficultyInfo difficulty)
-        {
-        }
-
         public void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             // Decrease AR to increase preempt time
diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index e3dfe8e69a..31d00a2610 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 (int min, int mid, int max) clear_rpm_range = (90, 150, 225);
+        private 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 (int min, int mid, int max) complete_rpm_range = (250, 380, 430);
+        private static readonly DifficultyRange complete_rpm_range = new DifficultyRange(250, 380, 430);
 
         public double EndTime
         {
diff --git a/osu.Game.Rulesets.Osu/OsuRuleset.cs b/osu.Game.Rulesets.Osu/OsuRuleset.cs
index 25b1dd9b12..0edb8046b9 100644
--- a/osu.Game.Rulesets.Osu/OsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/OsuRuleset.cs
@@ -373,10 +373,9 @@ namespace osu.Game.Rulesets.Osu
             preempt /= rate;
             adjustedDifficulty.ApproachRate = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(preempt, OsuHitObject.PREEMPT_MAX, OsuHitObject.PREEMPT_MID, OsuHitObject.PREEMPT_MIN);
 
-            var greatHitWindowRange = OsuHitWindows.OSU_RANGES.Single(range => range.Result == HitResult.Great);
-            double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, greatHitWindowRange.Min, greatHitWindowRange.Average, greatHitWindowRange.Max);
+            double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, OsuHitWindows.GREAT_WINDOW_RANGE);
             greatHitWindow /= rate;
-            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(greatHitWindow, greatHitWindowRange.Min, greatHitWindowRange.Average, greatHitWindowRange.Max);
+            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(greatHitWindow, OsuHitWindows.GREAT_WINDOW_RANGE);
 
             return adjustedDifficulty;
         }
diff --git a/osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs b/osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs
index 8082c5aef4..db2d9eaeda 100644
--- a/osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs
+++ b/osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -47,5 +48,8 @@ namespace osu.Game.Rulesets.Osu.Replays
 
             return new LegacyReplayFrame(Time, Position.X, Position.Y, state);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is OsuReplayFrame osuFrame && Time == osuFrame.Time && Position == osuFrame.Position && Actions.SequenceEqual(osuFrame.Actions);
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs b/osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs
index fd86e0eeda..a0f235c8c7 100644
--- a/osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs
+++ b/osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs
@@ -1,24 +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;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Scoring
 {
     public class OsuHitWindows : HitWindows
     {
+        public static readonly DifficultyRange GREAT_WINDOW_RANGE = new DifficultyRange(80, 50, 20);
+        public static readonly DifficultyRange OK_WINDOW_RANGE = new DifficultyRange(140, 100, 60);
+        public static readonly DifficultyRange MEH_WINDOW_RANGE = new DifficultyRange(200, 150, 100);
+
         /// <summary>
         /// osu! ruleset has a fixed miss window regardless of difficulty settings.
         /// </summary>
         public const double MISS_WINDOW = 400;
 
-        internal static readonly DifficultyRange[] OSU_RANGES =
-        {
-            new DifficultyRange(HitResult.Great, 80, 50, 20),
-            new DifficultyRange(HitResult.Ok, 140, 100, 60),
-            new DifficultyRange(HitResult.Meh, 200, 150, 100),
-            new DifficultyRange(HitResult.Miss, MISS_WINDOW, MISS_WINDOW, MISS_WINDOW),
-        };
+        private double great;
+        private double ok;
+        private double meh;
 
         public override bool IsHitResultAllowed(HitResult result)
         {
@@ -34,6 +36,32 @@ namespace osu.Game.Rulesets.Osu.Scoring
             return false;
         }
 
-        protected override DifficultyRange[] GetRanges() => OSU_RANGES;
+        public override void SetDifficulty(double difficulty)
+        {
+            great = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, GREAT_WINDOW_RANGE)) - 0.5;
+            ok = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, OK_WINDOW_RANGE)) - 0.5;
+            meh = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, MEH_WINDOW_RANGE)) - 0.5;
+        }
+
+        public override double WindowFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Great:
+                    return great;
+
+                case HitResult.Ok:
+                    return ok;
+
+                case HitResult.Meh:
+                    return meh;
+
+                case HitResult.Miss:
+                    return MISS_WINDOW;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(result), result, null);
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Default/PlaySliderBody.cs b/osu.Game.Rulesets.Osu/Skinning/Default/PlaySliderBody.cs
index bda1e6cf41..7b43886057 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Default/PlaySliderBody.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/PlaySliderBody.cs
@@ -44,10 +44,11 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
             SnakingOut.BindTo(configSnakingOut);
 
-            BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
+            BorderColour = GetBorderColour(skin);
         }
 
-        protected virtual Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour) =>
-            skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? hitObjectAccentColour;
+        protected virtual Color4 GetBorderColour(ISkinSource skin) => Color4.White;
+
+        protected virtual Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour) => hitObjectAccentColour;
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBody.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBody.cs
index b54bb44f94..43b7260e2c 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBody.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySliderBody.cs
@@ -15,11 +15,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
     {
         protected override DrawableSliderPath CreateSliderPath() => new LegacyDrawableSliderPath();
 
+        protected override Color4 GetBorderColour(ISkinSource skin)
+            => skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
+
         protected override Color4 GetBodyAccentColour(ISkinSource skin, Color4 hitObjectAccentColour)
-        {
             // legacy skins use a constant value for slider track alpha, regardless of the source colour.
-            return base.GetBodyAccentColour(skin, hitObjectAccentColour).Opacity(0.7f);
-        }
+            => (skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? hitObjectAccentColour).Opacity(0.7f);
 
         private partial class LegacyDrawableSliderPath : DrawableSliderPath
         {
diff --git a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs
index 6fe61e78b7..c175e3342b 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs
@@ -171,13 +171,13 @@ namespace osu.Game.Rulesets.Taiko.Tests.Judgements
             beatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 6 });
             beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 10 });
 
-            var hitWindows = new HitWindows();
+            var hitWindows = new DefaultHitWindows();
             hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
 
             PerformTest(new List<ReplayFrame>
             {
                 new TaikoReplayFrame(0),
-                new TaikoReplayFrame(hit_time - hitWindows.WindowFor(HitResult.Great), TaikoAction.LeftCentre),
+                new TaikoReplayFrame(hit_time - (hitWindows.WindowFor(HitResult.Great) + 0.1), TaikoAction.LeftCentre),
             }, beatmap);
 
             AssertJudgementCount(1);
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSimplifiedRhythm.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSimplifiedRhythm.cs
index 1e2c2a21ce..565b9c3362 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSimplifiedRhythm.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSimplifiedRhythm.cs
@@ -148,5 +148,96 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
             },
             PassCondition = () => Player.ScoreProcessor.Combo.Value == 8 && Player.ScoreProcessor.Accuracy.Value == 1
         });
+
+        /// <summary>
+        /// Regression tests a case of 1/3rd conversion where there are exactly div-3 number of hitobjects.
+        /// </summary>
+        [Test]
+        public void TestOnlyOneThirdConversion()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModSimplifiedRhythm
+                {
+                    OneThirdConversion = { Value = true },
+                },
+                Autoplay = false,
+                CreateBeatmap = () => new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new Hit { StartTime = 1000, Type = HitType.Centre },
+                        new Hit { StartTime = 1333, Type = HitType.Centre }, // mod removes this
+                        new Hit { StartTime = 1666, Type = HitType.Centre }, // mod moves this to 1500
+                        new Hit { StartTime = 2000, Type = HitType.Centre },
+                        new Hit { StartTime = 2333, Type = HitType.Centre }, // mod removes this
+                        new Hit { StartTime = 2666, Type = HitType.Centre }, // mod moves this to 2500
+                    },
+                },
+                ReplayFrames = new List<ReplayFrame>
+                {
+                    new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(1200),
+                    new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(1700),
+                    new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(2200),
+                    new TaikoReplayFrame(2500, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(2700),
+                },
+                PassCondition = () => Player.ScoreProcessor.Combo.Value == 4 && Player.ScoreProcessor.Accuracy.Value == 1
+            });
+        }
+
+        /// <summary>
+        /// Regression tests a case of 1/6th conversion where there are exactly div-6 number of hitobjects.
+        /// </summary>
+        [Test]
+        public void TestOnlyOneSixthConversion() => CreateModTest(new ModTestData
+        {
+            Mod = new TaikoModSimplifiedRhythm
+            {
+                OneSixthConversion = { Value = true }
+            },
+            Autoplay = false,
+            CreateBeatmap = () => new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Hit { StartTime = 1000, Type = HitType.Centre },
+                    new Hit { StartTime = 1166, Type = HitType.Centre }, // mod removes this
+                    new Hit { StartTime = 1333, Type = HitType.Centre }, // mod moves this to 1250
+                    new Hit { StartTime = 1500, Type = HitType.Centre },
+                    new Hit { StartTime = 1666, Type = HitType.Centre }, // mod removes this
+                    new Hit { StartTime = 1833, Type = HitType.Centre }, // mod moves this to 1750
+                    new Hit { StartTime = 2000, Type = HitType.Centre },
+                    new Hit { StartTime = 2166, Type = HitType.Centre }, // mod removes this
+                    new Hit { StartTime = 2333, Type = HitType.Centre }, // mod moves this to 2250
+                    new Hit { StartTime = 2500, Type = HitType.Centre },
+                    new Hit { StartTime = 2666, Type = HitType.Centre }, // mod removes this
+                    new Hit { StartTime = 2833, Type = HitType.Centre }, // mod moves this to 2750
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1200),
+                new TaikoReplayFrame(1250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1450),
+                new TaikoReplayFrame(1500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1600),
+                new TaikoReplayFrame(1750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1800),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2200),
+                new TaikoReplayFrame(2250, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2450),
+                new TaikoReplayFrame(2500, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2600),
+                new TaikoReplayFrame(2750, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2800),
+            },
+            PassCondition = () => Player.ScoreProcessor.Combo.Value == 8 && Player.ScoreProcessor.Accuracy.Value == 1
+        });
     }
 }
diff --git a/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs
index 5e71f974d8..40a426b360 100644
--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs
@@ -15,7 +15,6 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
     {
         protected override string? ExportLocation => null;
@@ -177,7 +176,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 ScoreInfo = new ScoreInfo
                 {
                     Ruleset = CreateRuleset().RulesetInfo,
-                    Mods = [new TaikoModHardRock()]
+                    Mods = [new TaikoModEasy()]
                 }
             };
 
diff --git a/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs
index 62bbebcf0b..c61ae8ecc7 100644
--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs
@@ -12,7 +12,6 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
-    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
     public partial class TestSceneReplayStability : ReplayStabilityTestScene
     {
         private static readonly object[][] test_cases =
@@ -22,40 +21,38 @@ namespace osu.Game.Rulesets.Taiko.Tests
             // while round brackets `()` represent *open* or *exclusive* bounds.
 
             // OD = 5 test cases.
-            // GREAT hit window is [-35ms, 35ms]
-            // OK    hit window is [-80ms, 80ms]
-            // MISS  hit window is [-95ms, 95ms]
+            // GREAT hit window is [-34.5ms, 34.5ms]
+            // OK    hit window is [-79.5ms, 79.5ms]
+            // MISS  hit window is [-94.5ms, 94.5ms]
             new object[] { 5f, -34d, HitResult.Great },
             new object[] { 5f, -34.2d, HitResult.Great },
-            new object[] { 5f, -34.7d, HitResult.Great },
-            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -34.7d, HitResult.Ok },
+            new object[] { 5f, -35d, HitResult.Ok },
             new object[] { 5f, -35.2d, HitResult.Ok },
             new object[] { 5f, -35.8d, HitResult.Ok },
             new object[] { 5f, -36d, HitResult.Ok },
             new object[] { 5f, -79d, HitResult.Ok },
             new object[] { 5f, -79.3d, HitResult.Ok },
-            new object[] { 5f, -79.7d, HitResult.Ok },
-            new object[] { 5f, -80d, HitResult.Ok },
+            new object[] { 5f, -79.7d, HitResult.Miss },
+            new object[] { 5f, -80d, HitResult.Miss },
             new object[] { 5f, -80.2d, HitResult.Miss },
             new object[] { 5f, -80.8d, HitResult.Miss },
             new object[] { 5f, -81d, HitResult.Miss },
 
             // OD = 7.8 test cases.
-            // GREAT hit window is [-26.6ms, 26.6ms]
-            // OK    hit window is [-63.2ms, 63.2ms]
-            // MISS  hit window is [-81.0ms, 81.0ms]
-            new object[] { 7.8f, -26d, HitResult.Great },
-            new object[] { 7.8f, -26.4d, HitResult.Great },
-            new object[] { 7.8f, -26.59d, HitResult.Great },
-            new object[] { 7.8f, -26.8d, HitResult.Ok },
-            new object[] { 7.8f, -27d, HitResult.Ok },
-            new object[] { 7.8f, -27.1d, HitResult.Ok },
-            new object[] { 7.8f, -63d, HitResult.Ok },
-            new object[] { 7.8f, -63.18d, HitResult.Ok },
-            new object[] { 7.8f, -63.4d, HitResult.Ok },
-            new object[] { 7.8f, -63.7d, HitResult.Miss },
-            new object[] { 7.8f, -64d, HitResult.Miss },
-            new object[] { 7.8f, -64.2d, HitResult.Miss },
+            // GREAT hit window is [-25.5ms, 25.5ms]
+            // OK    hit window is [-62.5ms, 62.5ms]
+            // MISS  hit window is [-80.5ms, 80.5ms]
+            new object[] { 7.8f, -25d, HitResult.Great },
+            new object[] { 7.8f, -25.4d, HitResult.Great },
+            new object[] { 7.8f, -25.8d, HitResult.Ok },
+            new object[] { 7.8f, -26d, HitResult.Ok },
+            new object[] { 7.8f, -26.1d, HitResult.Ok },
+            new object[] { 7.8f, -62d, HitResult.Ok },
+            new object[] { 7.8f, -62.4d, HitResult.Ok },
+            new object[] { 7.8f, -62.7d, HitResult.Miss },
+            new object[] { 7.8f, -63d, HitResult.Miss },
+            new object[] { 7.8f, -63.2d, HitResult.Miss },
         };
 
         [TestCaseSource(nameof(test_cases))]
diff --git a/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoHitObjectSamples.cs b/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoHitObjectSamples.cs
index 1d1e82fb07..b1df133c30 100644
--- a/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoHitObjectSamples.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoHitObjectSamples.cs
@@ -14,26 +14,27 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
         protected override IResourceStore<byte[]> RulesetResources => new DllResourceStore(Assembly.GetAssembly(typeof(TestSceneTaikoHitObjectSamples)));
 
-        [TestCase("taiko-normal-hitnormal")]
-        [TestCase("hitnormal")]
-        public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
+        [TestCase("taiko-normal-hitnormal2", "taiko-normal-hitnormal")]
+        [TestCase("hitnormal", "hitnormal")]
+        public void TestDefaultCustomSampleFromBeatmap(string beatmapSkinSampleName, string userSkinSampleName)
         {
-            SetupSkins(expectedSample, expectedSample);
+            SetupSkins(beatmapSkinSampleName, userSkinSampleName);
 
             CreateTestWithBeatmap("taiko-hitobject-beatmap-custom-sample-bank.osu");
 
-            AssertBeatmapLookup(expectedSample);
+            AssertBeatmapLookup(beatmapSkinSampleName);
         }
 
-        [TestCase("taiko-normal-hitnormal")]
-        [TestCase("hitnormal")]
-        public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
+        [TestCase("", "taiko-normal-hitnormal")]
+        [TestCase("taiko-normal-hitnormal", "taiko-normal-hitnormal")]
+        [TestCase("", "hitnormal")]
+        public void TestDefaultCustomSampleFromUserSkinFallback(string beatmapSkinSampleName, string userSkinSampleName)
         {
-            SetupSkins(string.Empty, expectedSample);
+            SetupSkins(beatmapSkinSampleName, userSkinSampleName);
 
             CreateTestWithBeatmap("taiko-hitobject-beatmap-custom-sample-bank.osu");
 
-            AssertUserLookup(expectedSample);
+            AssertUserLookup(userSkinSampleName);
         }
 
         [TestCase("taiko-normal-hitnormal2")]
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
index 5b0582ab59..4a38381bbe 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Localisation;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Beatmaps
@@ -22,21 +23,21 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Hits",
+                    Name = BeatmapStatisticStrings.Hits,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = hits.ToString(),
                     BarDisplayLength = hits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Drumrolls",
+                    Name = BeatmapStatisticStrings.Drumrolls,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = drumRolls.ToString(),
                     BarDisplayLength = drumRolls / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Swells",
+                    Name = BeatmapStatisticStrings.Swells,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     Content = swells.ToString(),
                     BarDisplayLength = Math.Min(swells / 10f, 1),
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs
index 57b57555c2..b06d1fe5ac 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs
@@ -25,16 +25,16 @@ namespace osu.Game.Rulesets.Taiko.Mods
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
+                if (!IsExactlyOneSettingChanged(ScrollSpeed, OverallDifficulty, DrainRate))
                     return string.Empty;
 
-                if (!ScrollSpeed.IsDefault) return format("SC", ScrollSpeed);
-                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
-                if (!DrainRate.IsDefault) return format("HP", DrainRate);
+                if (!ScrollSpeed.IsDefault) return format("SC", ScrollSpeed, 2);
+                if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty, 1);
+                if (!DrainRate.IsDefault) return format("HP", DrainRate, 1);
 
                 return string.Empty;
 
-                string format(string acronym, DifficultyBindable bindable) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(1)}";
+                string format(string acronym, DifficultyBindable bindable, int digits) => $"{acronym}{bindable.Value!.Value.ToStandardFormattedString(digits)}";
             }
         }
 
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
index e690ff075b..6e9b974fbf 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
             var taikoBeatmap = (TaikoBeatmap)beatmap;
             var controlPointInfo = taikoBeatmap.ControlPointInfo;
 
-            Hit[] hits = taikoBeatmap.HitObjects.Where(obj => obj is Hit).Cast<Hit>().ToArray();
+            Hit[] hits = taikoBeatmap.HitObjects.OfType<Hit>().ToArray();
 
             if (hits.Length == 0)
                 return;
@@ -61,10 +61,10 @@ namespace osu.Game.Rulesets.Taiko.Mods
                     if (inPattern)
                     {
                         // pattern continues
-                        if (snapValue == baseRhythm) continue;
+                        if (snapValue == baseRhythm)
+                            continue;
 
                         inPattern = false;
-
                         processPattern(i);
                     }
                     else
@@ -108,7 +108,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
                                 if (indexInPattern % 3 == 1)
                                     taikoBeatmap.HitObjects.Remove(hits[j]);
                                 else if (indexInPattern % 3 == 2)
-                                    hits[j].StartTime = hits[j + 1].StartTime - controlPointInfo.TimingPointAt(hits[j].StartTime).BeatLength / adjustedRhythm;
+                                    hits[j].StartTime = hits[j - 2].StartTime + controlPointInfo.TimingPointAt(hits[j].StartTime).BeatLength / adjustedRhythm;
 
                                 break;
                             }
diff --git a/osu.Game.Rulesets.Taiko/Replays/TaikoReplayFrame.cs b/osu.Game.Rulesets.Taiko/Replays/TaikoReplayFrame.cs
index a0a687dca6..6f10c03a96 100644
--- a/osu.Game.Rulesets.Taiko/Replays/TaikoReplayFrame.cs
+++ b/osu.Game.Rulesets.Taiko/Replays/TaikoReplayFrame.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Replays;
@@ -42,5 +43,8 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
             return new LegacyReplayFrame(Time, null, null, state);
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is TaikoReplayFrame taikoFrame && Time == taikoFrame.Time && Actions.SequenceEqual(taikoFrame.Actions);
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Scoring/TaikoHitWindows.cs b/osu.Game.Rulesets.Taiko/Scoring/TaikoHitWindows.cs
index b44ef8ee93..f3a478f592 100644
--- a/osu.Game.Rulesets.Taiko/Scoring/TaikoHitWindows.cs
+++ b/osu.Game.Rulesets.Taiko/Scoring/TaikoHitWindows.cs
@@ -1,18 +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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Scoring
 {
     public class TaikoHitWindows : HitWindows
     {
-        internal static readonly DifficultyRange[] TAIKO_RANGES =
-        {
-            new DifficultyRange(HitResult.Great, 50, 35, 20),
-            new DifficultyRange(HitResult.Ok, 120, 80, 50),
-            new DifficultyRange(HitResult.Miss, 135, 95, 70),
-        };
+        public static readonly DifficultyRange GREAT_WINDOW_RANGE = new DifficultyRange(50, 35, 20);
+        public static readonly DifficultyRange OK_WINDOW_RANGE = new DifficultyRange(120, 80, 50);
+        public static readonly DifficultyRange MISS_WINDOW_RANGE = new DifficultyRange(135, 95, 70);
+
+        private double great;
+        private double ok;
+        private double miss;
 
         public override bool IsHitResultAllowed(HitResult result)
         {
@@ -27,6 +30,29 @@ namespace osu.Game.Rulesets.Taiko.Scoring
             return false;
         }
 
-        protected override DifficultyRange[] GetRanges() => TAIKO_RANGES;
+        public override void SetDifficulty(double difficulty)
+        {
+            great = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, GREAT_WINDOW_RANGE)) - 0.5;
+            ok = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, OK_WINDOW_RANGE)) - 0.5;
+            miss = Math.Floor(IBeatmapDifficultyInfo.DifficultyRange(difficulty, MISS_WINDOW_RANGE)) - 0.5;
+        }
+
+        public override double WindowFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Great:
+                    return great;
+
+                case HitResult.Ok:
+                    return ok;
+
+                case HitResult.Miss:
+                    return miss;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(result), result, null);
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
index 8cc14ca651..1cb41e1299 100644
--- a/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoRuleset.cs
@@ -274,10 +274,9 @@ namespace osu.Game.Rulesets.Taiko
         {
             BeatmapDifficulty adjustedDifficulty = new BeatmapDifficulty(difficulty);
 
-            var greatHitWindowRange = TaikoHitWindows.TAIKO_RANGES.Single(range => range.Result == HitResult.Great);
-            double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, greatHitWindowRange.Min, greatHitWindowRange.Average, greatHitWindowRange.Max);
+            double greatHitWindow = IBeatmapDifficultyInfo.DifficultyRange(adjustedDifficulty.OverallDifficulty, TaikoHitWindows.GREAT_WINDOW_RANGE);
             greatHitWindow /= rate;
-            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(greatHitWindow, greatHitWindowRange.Min, greatHitWindowRange.Average, greatHitWindowRange.Max);
+            adjustedDifficulty.OverallDifficulty = (float)IBeatmapDifficultyInfo.InverseDifficultyRange(greatHitWindow, TaikoHitWindows.GREAT_WINDOW_RANGE);
 
             return adjustedDifficulty;
         }
diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
index caebf52026..e27146a86f 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
@@ -211,6 +211,31 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.That(decodedAfterEncode.skin.Configuration.CustomComboColours, Has.Count.EqualTo(8));
         }
 
+        [Test]
+        public void TestEncodeStabilityOfSliderWithFractionalCoordinates()
+        {
+            Slider originalSlider = new Slider
+            {
+                Position = new Vector2(0.6f),
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(Vector2.Zero, PathType.PERFECT_CURVE),
+                    new PathControlPoint(new Vector2(25.6f, 78.4f)),
+                    new PathControlPoint(new Vector2(55.8f, 34.2f)),
+                })
+            };
+            var beatmap = new Beatmap
+            {
+                HitObjects = { originalSlider }
+            };
+
+            var encoded = encodeToLegacy((beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty)));
+            var decodedAfterEncode = decodeFromLegacy(encoded, string.Empty, version: LegacyBeatmapEncoder.FIRST_LAZER_VERSION);
+            var decodedSlider = (Slider)decodedAfterEncode.beatmap.HitObjects[0];
+            Assert.That(decodedSlider.Path.ControlPoints.Select(p => p.Position),
+                Is.EquivalentTo(originalSlider.Path.ControlPoints.Select(p => p.Position)));
+        }
+
         private bool areComboColoursEqual(IHasComboColours a, IHasComboColours b)
         {
             // equal to null, no need to SequenceEqual
@@ -233,11 +258,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
-        private (IBeatmap beatmap, TestLegacySkin skin) decodeFromLegacy(Stream stream, string name)
+        private (IBeatmap beatmap, TestLegacySkin skin) decodeFromLegacy(Stream stream, string name, int version = LegacyDecoder<Beatmap>.LATEST_VERSION)
         {
             using (var reader = new LineBufferedReader(stream))
             {
-                var beatmap = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(reader);
+                var beatmap = new LegacyBeatmapDecoder(version) { ApplyOffsets = false }.Decode(reader);
                 var beatmapSkin = new TestLegacySkin(beatmaps_resource_store, name);
                 stream.Seek(0, SeekOrigin.Begin);
                 beatmapSkin.Configuration = new LegacySkinDecoder().Decode(reader);
diff --git a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
index 408db39d54..c081671a48 100644
--- a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
+++ b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
@@ -3,9 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
@@ -27,33 +25,34 @@ namespace osu.Game.Tests.Editing
     public partial class TestSceneHitObjectComposerDistanceSnapping : EditorClockTestScene
     {
         private TestHitObjectComposer composer = null!;
-
-        [Cached(typeof(EditorBeatmap))]
-        [Cached(typeof(IBeatSnapProvider))]
-        private readonly EditorBeatmap editorBeatmap;
-
-        protected override Container<Drawable> Content { get; } = new PopoverContainer { RelativeSizeAxes = Axes.Both };
-
-        public TestSceneHitObjectComposerDistanceSnapping()
-        {
-            base.Content.Add(new Container
-            {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    editorBeatmap = new EditorBeatmap(new OsuBeatmap
-                    {
-                        BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
-                    }),
-                    Content
-                },
-            });
-        }
+        private EditorBeatmap editorBeatmap = null!;
 
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Child = composer = new TestHitObjectComposer();
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo = { Ruleset = new OsuRuleset().RulesetInfo },
+            });
+
+            Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies =
+                [
+                    (typeof(EditorBeatmap), editorBeatmap),
+                    (typeof(IBeatSnapProvider), editorBeatmap)
+                ],
+                Children = new Drawable[]
+                {
+                    editorBeatmap,
+                    new PopoverContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = composer = new TestHitObjectComposer()
+                    }
+                }
+            };
 
             BeatDivisor.Value = 1;
 
@@ -247,16 +246,23 @@ namespace osu.Game.Tests.Editing
         }
 
         private void assertSnapDistance(float expectedDistance, IHasSliderVelocity? hasSliderVelocity = null)
-            => AddAssert($"distance is {expectedDistance}", () => composer.DistanceSnapProvider.GetBeatSnapDistance(hasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance is {expectedDistance}", () => composer.DistanceSnapProvider.GetBeatSnapDistance(hasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private void assertDurationToDistance(double duration, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DistanceSnapProvider.DurationToDistance(duration, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"duration = {duration} -> distance = {expectedDistance}",
+                () => composer.DistanceSnapProvider.DurationToDistance(duration, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private void assertDistanceToDuration(float distance, double expectedDuration, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceSnapProvider.DistanceToDuration(distance, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration}",
+                () => composer.DistanceSnapProvider.DistanceToDuration(distance, referenceObject?.StartTime ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
 
         private void assertSnappedDistance(float distance, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.DistanceSnapProvider.FindSnappedDistance(distance, referenceObject?.GetEndTime() ?? 0, referenceObject as IHasSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)",
+                () => composer.DistanceSnapProvider.FindSnappedDistance(distance, referenceObject?.GetEndTime() ?? 0, referenceObject as IHasSliderVelocity),
+                () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private partial class TestHitObjectComposer : OsuHitObjectComposer
         {
diff --git a/osu.Game.Tests/Gameplay/TestSceneDrainingHealthProcessor.cs b/osu.Game.Tests/Gameplay/TestSceneDrainingHealthProcessor.cs
index 584a9e09c0..18030d7222 100644
--- a/osu.Game.Tests/Gameplay/TestSceneDrainingHealthProcessor.cs
+++ b/osu.Game.Tests/Gameplay/TestSceneDrainingHealthProcessor.cs
@@ -359,7 +359,7 @@ namespace osu.Game.Tests.Gameplay
             }
 
             public override Judgement CreateJudgement() => new TestJudgement(maxResult);
-            protected override HitWindows CreateHitWindows() => new HitWindows();
+            protected override HitWindows CreateHitWindows() => new DefaultHitWindows();
 
             private class TestJudgement : Judgement
             {
diff --git a/osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs b/osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs
index d198ef5074..c9f5f50232 100644
--- a/osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs
+++ b/osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs
@@ -64,11 +64,9 @@ namespace osu.Game.Tests.Gameplay
         /// <summary>
         /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the beatmap skin:
         /// normal-hitnormal2
-        /// normal-hitnormal
         /// hitnormal
         /// </summary>
         [TestCase("normal-hitnormal2")]
-        [TestCase("normal-hitnormal")]
         [TestCase("hitnormal")]
         public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
         {
@@ -162,7 +160,6 @@ namespace osu.Game.Tests.Gameplay
         /// Tests that a control point that provides a custom sample of 2 causes <see cref="TestDefaultCustomSampleFromBeatmap"/>.
         /// </summary>
         [TestCase("normal-hitnormal2")]
-        [TestCase("normal-hitnormal")]
         [TestCase("hitnormal")]
         public void TestControlPointCustomSampleFromBeatmap(string sampleName)
         {
diff --git a/osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs b/osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs
index e31a3dbdf0..2230763984 100644
--- a/osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs
+++ b/osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs
@@ -166,11 +166,7 @@ namespace osu.Game.Tests.Mods
         /// </summary>
         private BeatmapDifficulty applyDifficulty(BeatmapDifficulty difficulty)
         {
-            // ensure that ReadFromDifficulty doesn't pollute the values.
             var newDifficulty = difficulty.Clone();
-
-            testMod.ReadFromDifficulty(difficulty);
-
             testMod.ApplyToDifficulty(newDifficulty);
             return newDifficulty;
         }
diff --git a/osu.Game.Tests/Mods/ModUtilsTest.cs b/osu.Game.Tests/Mods/ModUtilsTest.cs
index 6b3bc5f10f..6ec4e799e6 100644
--- a/osu.Game.Tests/Mods/ModUtilsTest.cs
+++ b/osu.Game.Tests/Mods/ModUtilsTest.cs
@@ -259,9 +259,6 @@ namespace osu.Game.Tests.Mods
             new MultiplayerTestScenario(true, true, [new OsuModPerfect()], []),
             new MultiplayerTestScenario(true, true, [new OsuModDoubleTime()], []),
             new MultiplayerTestScenario(true, true, [new OsuModNightcore()], []),
-            new MultiplayerTestScenario(true, true, [new OsuModHidden()], []),
-            new MultiplayerTestScenario(true, true, [new OsuModFlashlight()], []),
-            new MultiplayerTestScenario(true, true, [new OsuModAccuracyChallenge()], []),
             new MultiplayerTestScenario(true, true, [new OsuModDifficultyAdjust()], []),
             new MultiplayerTestScenario(true, true, [new ModWindUp()], []),
             new MultiplayerTestScenario(true, true, [new ModWindDown()], []),
@@ -345,10 +342,47 @@ namespace osu.Game.Tests.Mods
                 {
                     foreach (var mod in ruleset.CreateAllMods())
                     {
-                        if (mod.ValidForFreestyleAsRequiredMod && mod.UserPlayable && !commonAcronyms.Contains(mod.Acronym))
+                        if (mod.ValidForFreestyleAsRequiredMod && !mod.UserPlayable)
+                            Assert.Fail($"Mod {mod.GetType().ReadableName()} declares {nameof(Mod.ValidForFreestyleAsRequiredMod)} but is not playable!");
+
+                        if (mod.ValidForFreestyleAsRequiredMod && !mod.HasImplementation)
+                            Assert.Fail($"Mod {mod.GetType().ReadableName()} declares {nameof(Mod.ValidForFreestyleAsRequiredMod)} but is not implemented!");
+
+                        if (mod.ValidForFreestyleAsRequiredMod && mod.UserPlayable && mod.HasImplementation && !commonAcronyms.Contains(mod.Acronym))
                             Assert.Fail($"{mod.GetType().ReadableName()} declares {nameof(Mod.ValidForFreestyleAsRequiredMod)} but does not exist in all four basic rulesets!");
-                        if (!mod.ValidForFreestyleAsRequiredMod && mod.UserPlayable && commonAcronyms.Contains(mod.Acronym))
-                            Assert.Fail($"{mod.GetType().ReadableName()} does not declare {nameof(Mod.ValidForFreestyleAsRequiredMod)} but exists in all four basic rulesets!");
+                    }
+                }
+            });
+        }
+
+        [Test]
+        public void TestModsValidForRequiredFreestyleAreConsistentlyCompatibleAcrossRulesets()
+        {
+            Dictionary<(string firstMod, string secondMod), bool> compatibilityMap = new Dictionary<(string, string), bool>();
+
+            Assert.Multiple(() =>
+            {
+                for (int rulesetId = 0; rulesetId < 4; ++rulesetId)
+                {
+                    var rulesetStore = new AssemblyRulesetStore();
+                    var ruleset = rulesetStore.GetRuleset(rulesetId)!.CreateInstance();
+
+                    var modsValidForFreestyleAsRequired = ruleset.CreateAllMods().Where(m => m.ValidForFreestyleAsRequiredMod).OrderBy(m => m.Acronym).ToList();
+
+                    for (int i = 0; i < modsValidForFreestyleAsRequired.Count; i++)
+                    {
+                        for (int j = i; j < modsValidForFreestyleAsRequired.Count; ++j)
+                        {
+                            var first = modsValidForFreestyleAsRequired[i];
+                            var second = modsValidForFreestyleAsRequired[j];
+
+                            bool compatible = ModUtils.CheckCompatibleSet([first, second]);
+
+                            if (!compatibilityMap.TryGetValue((first.Acronym, second.Acronym), out bool previousCompatible))
+                                compatibilityMap[(first.Acronym, second.Acronym)] = compatible;
+                            else if (previousCompatible != compatible)
+                                Assert.Fail($"{first.Acronym} and {second.Acronym} declare {nameof(Mod.ValidForFreestyleAsRequiredMod)} while not being consistently compatible in all four rulesets!");
+                        }
                     }
                 }
             });
diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
index f4e324d7ba..578698b724 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
@@ -85,16 +85,6 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.That(filterCriteria.SearchTerms[0].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
         }
 
-        /*
-         * The following tests have been written a bit strangely (they don't check exact
-         * bound equality with what the filter says).
-         * This is to account for floating-point arithmetic issues.
-         * For example, specifying a bpm<140 filter would previously match beatmaps with BPM
-         * of 139.99999, which would be displayed in the UI as 140.
-         * Due to this the tests check the last tick inside the range and the first tick
-         * outside of the range.
-         */
-
         [TestCase("star")]
         [TestCase("stars")]
         public void TestApplyStarQueries(string variant)
@@ -105,11 +95,31 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.AreEqual("easy", filterCriteria.SearchText.Trim());
             Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
             Assert.IsNotNull(filterCriteria.StarDifficulty.Max);
-            Assert.Greater(filterCriteria.StarDifficulty.Max, 3.99d);
-            Assert.Less(filterCriteria.StarDifficulty.Max, 4.00d);
+            Assert.AreEqual(filterCriteria.StarDifficulty.Max, 4.00d);
             Assert.IsNull(filterCriteria.StarDifficulty.Min);
         }
 
+        [Test]
+        public void TestStarQueriesInclusive()
+        {
+            const string query = "stars>=6";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual(filterCriteria.StarDifficulty.Min, 6.00d);
+            Assert.True(filterCriteria.StarDifficulty.IsLowerInclusive);
+            Assert.IsNull(filterCriteria.StarDifficulty.Max);
+        }
+
+        /*
+         * The following tests have been written a bit strangely (they don't check exact
+         * bound equality with what the filter says).
+         * This is to account for floating-point arithmetic issues.
+         * For example, specifying a bpm<140 filter would previously match beatmaps with BPM
+         * of 139.99999, which would be displayed in the UI as 140.
+         * Due to this the tests check the last tick inside the range and the first tick
+         * outside of the range.
+         */
+
         [Test]
         public void TestApplyApproachRateQueries()
         {
diff --git a/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs b/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
index 07d6d68e82..cfe523fdd5 100644
--- a/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
+++ b/osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs
@@ -33,7 +33,7 @@ namespace osu.Game.Tests.NonVisual
         public void TestResultIfOnlyParentHitWindowIsEmpty()
         {
             var testObject = new TestHitObject(HitWindows.Empty);
-            HitObject nested = new TestHitObject(new HitWindows());
+            HitObject nested = new TestHitObject(new DefaultHitWindows());
             testObject.AddNested(nested);
             testDrawableRuleset.HitObjects = new List<HitObject> { testObject };
 
@@ -43,8 +43,8 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestResultIfParentHitWindowsIsNotEmpty()
         {
-            var testObject = new TestHitObject(new HitWindows());
-            HitObject nested = new TestHitObject(new HitWindows());
+            var testObject = new TestHitObject(new DefaultHitWindows());
+            HitObject nested = new TestHitObject(new DefaultHitWindows());
             testObject.AddNested(nested);
             testDrawableRuleset.HitObjects = new List<HitObject> { testObject };
 
@@ -58,7 +58,7 @@ namespace osu.Game.Tests.NonVisual
             HitObject nested = new TestHitObject(HitWindows.Empty);
             firstObject.AddNested(nested);
 
-            var secondObject = new TestHitObject(new HitWindows());
+            var secondObject = new TestHitObject(new DefaultHitWindows());
             testDrawableRuleset.HitObjects = new List<HitObject> { firstObject, secondObject };
 
             Assert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, secondObject.HitWindows);
diff --git a/osu.Game.Tests/NonVisual/FormatUtilsTest.cs b/osu.Game.Tests/NonVisual/FormatUtilsTest.cs
index a12658bd8b..0fcf754cf6 100644
--- a/osu.Game.Tests/NonVisual/FormatUtilsTest.cs
+++ b/osu.Game.Tests/NonVisual/FormatUtilsTest.cs
@@ -21,5 +21,18 @@ namespace osu.Game.Tests.NonVisual
         {
             Assert.AreEqual(expectedOutput, input.FormatAccuracy().ToString());
         }
+
+        [TestCase(3, "3.00")]
+        [TestCase(3.3, "3.30")]
+        [TestCase(3.55, "3.55")]
+        [TestCase(3.553, "3.55")]
+        [TestCase(3.557, "3.55")]
+        [TestCase(3.9999, "3.99")]
+        [TestCase(3.999999, "3.99")]
+        [TestCase(4, "4.00")]
+        public void TestStarRatingFormatting(double input, string expectedOutput)
+        {
+            Assert.AreEqual(expectedOutput, input.FormatStarRating().ToString());
+        }
     }
 }
diff --git a/osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs b/osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs
index 541ad1e8bb..ffb21f124c 100644
--- a/osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs
+++ b/osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs
@@ -383,6 +383,9 @@ namespace osu.Game.Tests.NonVisual
                 IsImportant = isImportant;
                 FrameIndex = frameIndex;
             }
+
+            public override bool IsEquivalentTo(ReplayFrame other)
+                => other is TestReplayFrame testFrame && Time == testFrame.Time && IsImportant == testFrame.IsImportant && FrameIndex == testFrame.FrameIndex;
         }
 
         private class TestInputHandler : FramedReplayInputHandler<TestReplayFrame>
diff --git a/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
new file mode 100644
index 0000000000..bdb4dce354
--- /dev/null
+++ b/osu.Game.Tests/NonVisual/TestSceneUpdateManager.cs
@@ -0,0 +1,187 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Tests.Visual;
+using osu.Game.Updater;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [HeadlessTest]
+    public partial class TestSceneUpdateManager : OsuTestScene
+    {
+        [Cached(typeof(INotificationOverlay))]
+        private readonly INotificationOverlay notifications = new TestNotificationOverlay();
+
+        private TestUpdateManager manager = null!;
+        private OsuConfigManager config = null!;
+
+        [SetUpSteps]
+        public void SetupSteps()
+        {
+            AddStep("add manager", () =>
+            {
+                config = new OsuConfigManager(LocalStorage);
+                config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
+                Child = new DependencyProvidingContainer
+                {
+                    CachedDependencies = [(typeof(OsuConfigManager), config)],
+                    Child = manager = new TestUpdateManager()
+                };
+            });
+
+            // Updates should be checked when the object is loaded for the first time.
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("1 check completed", () => manager.Completions, () => Is.EqualTo(1));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+        }
+
+        /// <summary>
+        /// Updates should be checked when the release stream is changed.
+        /// </summary>
+        [Test]
+        public void TestReleaseStreamChanged()
+        {
+            AddStep("change release stream", () => config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Tachyon));
+
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("2 checks completed", () => manager.Completions, () => Is.EqualTo(2));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+
+            AddStep("change release stream", () => config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer));
+
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("3 checks completed", () => manager.Completions, () => Is.EqualTo(3));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+        }
+
+        /// <summary>
+        /// Changing the release stream should start a new invocation and cancel the existing one.
+        /// </summary>
+        [Test]
+        public void TestNewInvocationOnReleaseStreamChanged()
+        {
+            AddStep("change release stream", () => config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Tachyon));
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("change release stream", () => config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Lazer));
+            AddUntilStep("3 invocations", () => manager.Invocations, () => Is.EqualTo(3));
+
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("2 checks completed", () => manager.Completions, () => Is.EqualTo(2));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+        }
+
+        /// <summary>
+        /// Updates should be checked when the user requests them to.
+        /// </summary>
+        [Test]
+        public void TestUserRequest()
+        {
+            AddStep("request check", () => manager.CheckForUpdate());
+
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("2 checks completed", () => manager.Completions, () => Is.EqualTo(2));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+
+            AddStep("request check", () => manager.CheckForUpdate());
+
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("3 checks completed", () => manager.Completions, () => Is.EqualTo(3));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+        }
+
+        /// <summary>
+        /// User requests should start a new invocation and cancel the existing one.
+        /// </summary>
+        [Test]
+        public void TestUserRequestOverridesExistingCheck()
+        {
+            // This part covering double user input is not really possible because the settings button is disabled during the check,
+            // but it's kept here for sanity in-case the update manager is used as a standalone object elsewhere.
+
+            AddStep("request check", () => manager.CheckForUpdate());
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("request check", () => manager.CheckForUpdate());
+            AddUntilStep("3 invocations", () => manager.Invocations, () => Is.EqualTo(3));
+
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("2 checks completed", () => manager.Completions, () => Is.EqualTo(2));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+
+            // This next part tests for the user requesting an update during a background check, and is possible to occur in practice.
+
+            AddStep("change release stream", () => config.SetValue(OsuSetting.ReleaseStream, ReleaseStream.Tachyon));
+            AddUntilStep("check pending", () => manager.IsPending);
+            AddStep("request check", () => manager.CheckForUpdate());
+            AddUntilStep("5 invocations", () => manager.Invocations, () => Is.EqualTo(5));
+
+            AddStep("complete check", () => manager.Complete());
+            AddUntilStep("3 checks completed", () => manager.Completions, () => Is.EqualTo(3));
+            AddUntilStep("no check pending", () => !manager.IsPending);
+        }
+
+        private partial class TestUpdateManager : UpdateManager
+        {
+            public bool IsPending { get; private set; }
+            public int Invocations { get; private set; }
+            public int Completions { get; private set; }
+
+            private TaskCompletionSource<bool>? pendingCheck;
+
+            protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
+            {
+                Invocations++;
+
+                var check = pendingCheck = new TaskCompletionSource<bool>();
+                IsPending = true;
+
+                try
+                {
+                    bool result = await check.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
+                    Completions++;
+                    return result;
+                }
+                finally
+                {
+                    IsPending = false;
+                }
+            }
+
+            public void Complete()
+            {
+                pendingCheck?.SetResult(true);
+            }
+        }
+
+        private partial class TestNotificationOverlay : INotificationOverlay
+        {
+            public void Post(Notification notification)
+            {
+            }
+
+            public void Hide()
+            {
+            }
+
+            public IBindable<int> UnreadCount { get; } = new Bindable<int>();
+
+            public IEnumerable<Notification> AllNotifications { get; } = Enumerable.Empty<Notification>();
+        }
+    }
+}
diff --git a/osu.Game.Tests/Resources/TestResources.cs b/osu.Game.Tests/Resources/TestResources.cs
index 54204d412a..469bc8ee73 100644
--- a/osu.Game.Tests/Resources/TestResources.cs
+++ b/osu.Game.Tests/Resources/TestResources.cs
@@ -104,7 +104,7 @@ namespace osu.Game.Tests.Resources
             {
                 // Create random metadata, then we can check if sorting works based on these
                 Artist = "Some Artist " + RNG.Next(0, 9),
-                Title = $"Some Song (set id {setId:000}) {Guid.NewGuid()}",
+                Title = $"Some Song (set id {setId:000000}) {Guid.NewGuid()}",
                 Author = { Username = "Some Guy " + RNG.Next(0, 9) },
             };
 
diff --git a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
index eeaa68e2ee..58fb02c90c 100644
--- a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
@@ -32,7 +32,7 @@ using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Screens.Ranking;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Storyboards.Drawables;
 using osu.Game.Tests.Resources;
 using osuTK;
@@ -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?.SelectedBeatmapInfo != null);
+            AddUntilStep("Song select has selection", () => songSelect.Carousel?.CurrentSelection != null);
             AddStep("Set default user settings", () =>
             {
                 SelectedMods.Value = new[] { new OsuModNoFail() };
@@ -340,7 +340,7 @@ namespace osu.Game.Tests.Visual.Background
             rulesets?.Dispose();
         }
 
-        private partial class DummySongSelect : PlaySongSelect
+        private partial class DummySongSelect : SoloSongSelect
         {
             private FadeAccessibleBackground background;
 
@@ -355,7 +355,7 @@ namespace osu.Game.Tests.Visual.Background
             public readonly Bindable<double> DimLevel = new BindableDouble();
             public readonly Bindable<double> BlurLevel = new BindableDouble();
 
-            public new BeatmapCarousel Carousel => base.Carousel;
+            public BeatmapCarousel Carousel => this.ChildrenOfType<BeatmapCarousel>().SingleOrDefault();
 
             [BackgroundDependencyLoader]
             private void load(OsuConfigManager config)
@@ -368,7 +368,7 @@ namespace osu.Game.Tests.Visual.Background
 
             public bool IsBackgroundDimmed() => background.CurrentColour == OsuColour.Gray(1f - background.CurrentDim);
 
-            public bool IsBackgroundUndimmed() => background.CurrentColour == Color4.White;
+            public bool IsBackgroundUndimmed() => background.CurrentColour == new Color4(0.9f, 0.9f, 0.9f, 1f);
 
             public bool IsUserBlurApplied() => Precision.AlmostEquals(background.CurrentBlur, new Vector2((float)BlurLevel.Value * BackgroundScreenBeatmap.USER_BLUR_FACTOR), 0.1f);
 
@@ -376,7 +376,7 @@ namespace osu.Game.Tests.Visual.Background
 
             public bool IsBackgroundVisible() => background.CurrentAlpha == 1;
 
-            public bool IsBackgroundBlur() => Precision.AlmostEquals(background.CurrentBlur, new Vector2(BACKGROUND_BLUR), 0.1f);
+            public bool IsBackgroundBlur() => Precision.AlmostBigger(background.CurrentBlur.X, 0, 0.1f);
 
             public bool CheckBackgroundBlur(Vector2 expected) => Precision.AlmostEquals(background.CurrentBlur, expected, 0.1f);
 
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
index fd3431c08b..6a9ca1292c 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
@@ -615,6 +615,25 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
         }
 
+        [Test]
+        public void TestUndoAfterQuickDeletingObjectWhileDragged()
+        {
+            AddStep("add hitobject", () => EditorBeatmap.Add(
+                new HitCircle { StartTime = 0, Position = new Vector2(200, 200) }
+            ));
+
+            moveMouseToObject(() => EditorBeatmap.HitObjects[0]);
+
+            AddStep("hold left click", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("drag hitobject to different position", () => InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.BottomRight));
+            AddStep("click middle mouse button", () => InputManager.Click(MouseButton.Middle));
+            AddStep("release left click", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count, () => Is.Zero);
+
+            AddStep("undo", () => Editor.Undo());
+            AddAssert("one hitobject in beatmap", () => EditorBeatmap.HitObjects.Count, () => Is.EqualTo(1));
+        }
+
         [Test]
         public void TestShiftModifierMaintainsAspectRatio()
         {
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
index 2758954907..8d7eb41369 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
@@ -232,8 +232,8 @@ namespace osu.Game.Tests.Visual.Editing
                 EditorBeatmap.ControlPointInfo.Add(1500, new EffectControlPoint { KiaiMode = false, ScrollSpeed = 0.3 });
             });
 
+            ensureEditorLoaded();
             AddStep("save beatmap", () => Editor.Save());
-
             AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new ManiaRuleset().RulesetInfo));
 
             AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog is CreateNewDifficultyDialog);
@@ -274,6 +274,14 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("save beatmap", () => Editor.Save());
             AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new ManiaRuleset().RulesetInfo));
 
+            AddUntilStep("wait for created", () =>
+            {
+                string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
+                return difficultyName != null && difficultyName != firstDifficultyName;
+            });
+
+            ensureEditorLoaded();
+
             AddStep("set unique difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = firstDifficultyName);
             AddStep("add timing point", () => EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 1000 }));
             AddStep("add effect points", () =>
@@ -285,8 +293,8 @@ namespace osu.Game.Tests.Visual.Editing
                 EditorBeatmap.ControlPointInfo.Add(1500, new EffectControlPoint { KiaiMode = false, ScrollSpeed = 0.3 });
             });
 
+            ensureEditorLoaded();
             AddStep("save beatmap", () => Editor.Save());
-
             AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new TaikoRuleset().RulesetInfo));
 
             AddUntilStep("wait for created", () =>
@@ -629,6 +637,8 @@ namespace osu.Game.Tests.Visual.Editing
                     StartTime = 1000
                 }
             }));
+
+            ensureEditorLoaded();
             AddStep("save beatmap", () => Editor.Save());
             AddStep("try to create new catch difficulty", () => Editor.CreateNewDifficulty(new CatchRuleset().RulesetInfo));
 
@@ -765,7 +775,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("other audio not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (1).mp3"));
         }
 
-        private void ensureEditorLoaded() => AddUntilStep("wait for editor load", () => Editor.IsLoaded && DialogOverlay.IsLoaded);
+        private void ensureEditorLoaded() => AddUntilStep("wait for editor load", () => Editor.ReadyForUse && DialogOverlay.IsLoaded);
 
         private void createNewDifficulty()
         {
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
index 2e7b55ab49..7f40da5bab 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
@@ -15,7 +15,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Overlays;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -190,7 +190,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Set tags again", () => EditorBeatmap.BeatmapInfo.Metadata.Tags = tags_to_discard);
 
             AddStep("Exit editor", () => Editor.Exit());
-            AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
             AddAssert("Tags reverted correctly", () => Game.Beatmap.Value.BeatmapInfo.Metadata.Tags == tags_to_save);
         }
 
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs b/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
index 955ded97af..e3b79d4053 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
@@ -14,7 +14,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.Editing
                 () => Is.EqualTo(1));
 
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("entered song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("entered song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             addStepClickLink("00:00:000 (1)", waitForSeek: false);
             AddUntilStep("received 'must be in edit'",
@@ -151,12 +151,12 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Present beatmap", () => Game.PresentBeatmap(beatmapSet));
             AddUntilStep("Wait for song select", () =>
                 Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet)
-                && Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
-                && songSelect.BeatmapSetsLoaded
+                && Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect
+                && songSelect.CarouselItemsPresented
             );
             AddStep("Switch ruleset", () => Game.Ruleset.Value = ruleset);
             AddStep("Open editor for ruleset", () =>
-                ((PlaySongSelect)Game.ScreenStack.CurrentScreen)
+                ((SoloSongSelect)Game.ScreenStack.CurrentScreen)
                 .Edit(beatmapSet.Beatmaps.Last(beatmap => beatmap.Ruleset.Name == ruleset.Name))
             );
             AddUntilStep("Wait for editor open", () => editor?.ReadyForUse == true);
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
index 92a10628ff..25b36a0f33 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
@@ -45,6 +45,44 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
         }
 
+        /// <summary>
+        /// If we already have an old score with enough hit events and the new score doesn't have enough, continue displaying the old one rather than showing the user "play too short" message.
+        /// </summary>
+        [Test]
+        public void TestTooShortToDisplay_HasPreviousValidScore()
+        {
+            const double average_error = -4.5;
+            const double initial_offset = -2;
+
+            AddStep("Set offset non-neutral", () => offsetControl.Current.Value = initial_offset);
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+
+            AddStep("Set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+
+            AddStep("Set short reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddUntilStep("Still calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+
+            AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
+            AddAssert("Offset is adjusted", () => offsetControl.Current.Value == initial_offset - average_error);
+        }
+
         [Test]
         public void TestNotEnoughTimedHitEvents()
         {
@@ -125,10 +163,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
             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);
-            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
-            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
 
             recreateControl();
             AddStep("Set same reference score", () => offsetControl.ReferenceScore.Value = referenceScore);
@@ -141,6 +176,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestCalibrationFromNonZero()
         {
+            ScoreInfo referenceScore = null!;
             const double average_error = -4.5;
             const double initial_offset = -2;
 
@@ -148,7 +184,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
             AddStep("Set reference score", () =>
             {
-                offsetControl.ReferenceScore.Value = new ScoreInfo
+                offsetControl.ReferenceScore.Value = referenceScore = new ScoreInfo
                 {
                     HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
                     BeatmapInfo = Beatmap.Value.BeatmapInfo,
@@ -158,9 +194,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
             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);
-            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
+
+            recreateControl();
+            AddStep("Set same reference score", () => offsetControl.ReferenceScore.Value = referenceScore);
             AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
         }
 
@@ -209,10 +246,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
             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);
-            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
-            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
 
             AddStep("Clean up beatmap", () => Realm.Write(r => r.RemoveAll<BeatmapInfo>()));
         }
@@ -236,10 +270,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
             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);
-            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
-            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
         }
 
         private void recreateControl()
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
index f45e6326d1..d026afcd6d 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("toggle expanded", () =>
             {
                 if (leaderboard.IsNotNull())
-                    leaderboard.ForceExpand.Value = !leaderboard.ForceExpand.Value;
+                    leaderboard.CollapseDuringGameplay.Value = !leaderboard.CollapseDuringGameplay.Value;
             });
 
             AddSliderStep("set player score", 50, 5000000, 1222333, v => playerScore.Value = v);
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySamplePlayback.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySamplePlayback.cs
index 21c83d521c..84b312d5ee 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySamplePlayback.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySamplePlayback.cs
@@ -9,7 +9,6 @@ using osu.Game.Audio;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -21,6 +20,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private bool seek;
 
         [Test]
+        [FlakyTest]
         public void TestAllSamplesStopDuringSeek()
         {
             DrawableSlider? slider = null;
@@ -73,8 +73,8 @@ namespace osu.Game.Tests.Visual.Gameplay
                 //
                 // We want to keep seeking while asserting various test conditions, so
                 // continue to seek until we unset the flag.
-                var gameplayClockContainer = Player.ChildrenOfType<GameplayClockContainer>().First();
-                gameplayClockContainer.Seek(gameplayClockContainer.CurrentTime > 30000 ? 0 : 60000);
+                var gameplayClockContainer = Player?.GameplayClockContainer;
+                gameplayClockContainer?.Seek(gameplayClockContainer.CurrentTime > 30000 ? 0 : 60000);
             }
         }
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySampleTriggerSource.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySampleTriggerSource.cs
index 6981591193..894b51ddcb 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySampleTriggerSource.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplaySampleTriggerSource.cs
@@ -65,30 +65,30 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
                 new HitCircle
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                     StartTime = t += spacing,
                     Samples = new[] { new HitSampleInfo(HitSampleInfo.HIT_NORMAL) }
                 },
                 new HitCircle
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                     StartTime = t += spacing,
                     Samples = new[] { new HitSampleInfo(HitSampleInfo.HIT_WHISTLE) }
                 },
                 new HitCircle
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                     StartTime = t += spacing,
                     Samples = new[] { new HitSampleInfo(HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT) },
                 },
                 new HitCircle
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                     StartTime = t += spacing,
                 },
                 new Slider
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                     StartTime = t += spacing,
                     Path = new SliderPath(PathType.LINEAR, new[] { Vector2.Zero, Vector2.UnitY * 200 }),
                     Samples = new[] { new HitSampleInfo(HitSampleInfo.HIT_WHISTLE, HitSampleInfo.BANK_SOFT) },
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlayRulesetLayouts.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlayRulesetLayouts.cs
index b64ba387b0..47791dd462 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlayRulesetLayouts.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlayRulesetLayouts.cs
@@ -136,7 +136,6 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
             public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
-            public bool IsPartial { get; } = false;
 
             public TestGameplayLeaderboardProvider()
             {
@@ -147,8 +146,8 @@ namespace osu.Game.Tests.Visual.Gameplay
                         User = new APIUser { Username = $"User {i}" },
                         TotalScore = (20 - i) * 50_000,
                         Accuracy = i * 0.05,
-                        Combo = i * 50
-                    }, i == 19));
+                        MaxCombo = i * 50,
+                    }, i == 19, GameplayLeaderboardScore.ComboDisplayMode.Highest));
                 }
             }
         }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
index 81dd23661c..b3ed4135a9 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs
@@ -6,11 +6,16 @@ using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Replays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Resources;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -157,6 +162,51 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("Jumped forwards", () => Player.GameplayClockContainer.CurrentTime - lastTime > 500);
         }
 
+        [Test]
+        public void TestReplayDoesNotFailUntilRunningOutOfFrames()
+        {
+            var score = new Score
+            {
+                ScoreInfo = TestResources.CreateTestScoreInfo(Beatmap.Value.BeatmapInfo),
+                Replay = new Replay
+                {
+                    Frames =
+                    {
+                        new OsuReplayFrame(0, Vector2.Zero),
+                        new OsuReplayFrame(10000, Vector2.Zero),
+                    }
+                }
+            };
+            score.ScoreInfo.Mods = [];
+            score.ScoreInfo.Rank = ScoreRank.F;
+            AddStep("set global state", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                Ruleset.Value = Beatmap.Value.BeatmapInfo.Ruleset;
+                SelectedMods.Value = score.ScoreInfo.Mods;
+            });
+            AddStep("create player", () => Player = new TestReplayPlayer(score, showResults: false));
+            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));
+        }
+
+        [Test]
+        public void TestPlayerLoaderSettingsHover()
+        {
+            loadPlayerWithBeatmap();
+
+            AddUntilStep("wait for settings overlay hidden", () => settingsOverlay().Expanded.Value, () => Is.False);
+            AddStep("move mouse to right of screen", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopRight));
+            AddUntilStep("wait for settings overlay visible", () => settingsOverlay().Expanded.Value, () => Is.True);
+            AddStep("move mouse to centre of screen", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for settings overlay hidden", () => settingsOverlay().Expanded.Value, () => Is.False);
+
+            PlayerSettingsOverlay settingsOverlay() => Player.ChildrenOfType<PlayerSettingsOverlay>().Single();
+        }
+
         private void loadPlayerWithBeatmap(IBeatmap? beatmap = null)
         {
             AddStep("create player", () =>
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs
index 4ad6bc66e3..8ada550174 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayRecorder.cs
@@ -317,6 +317,9 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Position = position;
                 Actions.AddRange(actions);
             }
+
+            public override bool IsEquivalentTo(ReplayFrame other)
+                => other is TestReplayFrame testFrame && Time == testFrame.Time && Position == testFrame.Position && Actions.SequenceEqual(testFrame.Actions);
         }
 
         public enum TestAction
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorMultipleSkins.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorMultipleSkins.cs
index 656873e9ed..00369ade18 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorMultipleSkins.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorMultipleSkins.cs
@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Tests.Gameplay;
 using osuTK.Input;
 
@@ -37,6 +38,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached]
         public readonly EditorClipboard Clipboard = new EditorClipboard();
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private EmptyGameplayLeaderboardProvider leaderboardProvider = new EmptyGameplayLeaderboardProvider();
+
         public TestSceneSkinEditorMultipleSkins()
         {
             scoreProcessor = gameplayState.ScoreProcessor;
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
index fcaa2996e1..754ec841d8 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Skinning;
 using osu.Game.Tests.Gameplay;
 
@@ -42,6 +43,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(IGameplayClock))]
         private readonly IGameplayClock gameplayClock = new GameplayClockContainer(new TrackVirtual(60000), false, false);
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private EmptyGameplayLeaderboardProvider leaderboardProvider = new EmptyGameplayLeaderboardProvider();
+
         private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
 
         // best way to check without exposing.
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs
index 8b1a8307ca..276a0c3410 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs
@@ -69,6 +69,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
+        [FlakyTest]
         public void TestFadeOnIdle()
         {
             createTest();
@@ -144,7 +145,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestDoesntFadeOnMouseDown()
+        [FlakyTest]
+        public void TestDoesNotFadeOnMouseDown()
         {
             createTest();
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs
index dd5bbf70b4..062d73abbf 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs
@@ -353,6 +353,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
                 return new LegacyReplayFrame(Time, Position.X, Position.Y, state);
             }
+
+            public override bool IsEquivalentTo(ReplayFrame other)
+                => other is TestReplayFrame testFrame && Time == testFrame.Time && Position == testFrame.Position && Actions.SequenceEqual(testFrame.Actions);
         }
 
         public enum TestAction
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs b/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
index 1af4af8f6b..53d909406f 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
@@ -150,6 +150,24 @@ namespace osu.Game.Tests.Visual.Menus
                     });
             });
 
+            // cross-reference: `TestSceneOverallRanking.TestRoundingTreatment()`.
+            AddStep("Test rounding treatment", () =>
+            {
+                var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
+                transientUpdateDisplay.LatestUpdate.Value = new ScoreBasedUserStatisticsUpdate(
+                    new ScoreInfo(),
+                    new UserStatistics
+                    {
+                        GlobalRank = 111_111,
+                        PP = 5071.495M
+                    },
+                    new UserStatistics
+                    {
+                        GlobalRank = 111_111,
+                        PP = 5072.99M
+                    });
+            });
+
             AddStep("No change 1", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
diff --git a/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs b/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
index 3008edf41f..955737578a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
@@ -167,7 +167,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void TestScoreUpdates()
         {
             AddRepeatStep("update state", UpdateUserStatesRandomly, 100);
-            AddToggleStep("switch compact mode", expanded => Leaderboard!.ForceExpand.Value = expanded);
+            AddToggleStep("switch compact mode", collapsed => Leaderboard!.CollapseDuringGameplay.Value = collapsed);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
index 131b644dcb..c39708352e 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        ForceExpand = { Value = true }
+                        CollapseDuringGameplay = { Value = false }
                     }
                 });
             });
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
index bd66694cd9..faf8f35a8e 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
@@ -303,6 +303,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
 
         [Test]
+        [FlakyTest]
         public void TestMostInSyncUserIsAudioSource()
         {
             start(new[] { PLAYER_1_ID, PLAYER_2_ID });
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
index 40d8650c69..6141820cb7 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
@@ -44,14 +44,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     Team2Score = { BindTarget = LeaderboardProvider.TeamScores[1] }
                 }, Add);
 
-                LoadComponentAsync(new GameplayMatchScoreDisplay
+                GameplayMatchScoreDisplay matchScoreDisplay;
+                LoadComponentAsync(matchScoreDisplay = new GameplayMatchScoreDisplay
                 {
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.BottomCentre,
                     Team1Score = { BindTarget = LeaderboardProvider.TeamScores[0] },
                     Team2Score = { BindTarget = LeaderboardProvider.TeamScores[1] },
-                    Expanded = { BindTarget = Leaderboard!.ForceExpand },
                 }, Add);
+
+                Leaderboard!.CollapseDuringGameplay.BindValueChanged(_ => matchScoreDisplay.Expanded.Value = !Leaderboard.CollapseDuringGameplay.Value);
             });
         }
     }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
index a94f440a01..e0a0e5a785 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
@@ -59,9 +59,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
             importedSet = beatmaps.GetAllUsableBeatmapSets().First();
         }
 
-        [SetUpSteps]
-        public void SetupSteps()
+        public override void SetUpSteps()
         {
+            base.SetUpSteps();
+
+            AddUntilStep("wait for mod select removed", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Count(), () => Is.Zero);
+
             AddStep("load match", () =>
             {
                 room = new Room { Name = "Test Room" };
@@ -305,7 +308,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for join", () => RoomJoined);
 
             ClickButtonWhenEnabled<UserModSelectButton>();
-            AddAssert("mod select shows unranked", () => this.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
+            AddUntilStep("mod select shows unranked", () => this.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
 
             AddStep("select flashlight", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
index 77fe96310f..066c981cd2 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
@@ -56,6 +56,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
+            AddUntilStep("wait for mod select removed", () => this.ChildrenOfType<FreeModSelectOverlay>().Count(), () => Is.Zero);
+
             AddStep("reset", () =>
             {
                 room = new Room();
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
index fee5e62958..037c5faae3 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
@@ -165,23 +165,75 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         Name = "A host-only room",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
+                        RoomID = 1337,
                     }),
                     new MultiplayerRoomPanel(new Room
                     {
                         Name = "An all-players, team-versus room",
                         QueueMode = QueueMode.AllPlayers,
-                        Type = MatchType.TeamVersus
+                        Type = MatchType.TeamVersus,
+                        RoomID = 1338,
                     }),
                     new MultiplayerRoomPanel(new Room
                     {
                         Name = "A round-robin room",
                         QueueMode = QueueMode.AllPlayersRoundRobin,
-                        Type = MatchType.HeadToHead
+                        Type = MatchType.HeadToHead,
+                        RoomID = 1339,
                     }),
                 }
             });
         }
 
+        [Test]
+        public void TestRoomWithLongTitle()
+        {
+            AddStep("create rooms", () => Child = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(5),
+                Children = new[]
+                {
+                    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.",
+                        QueueMode = QueueMode.HostOnly,
+                        Type = MatchType.HeadToHead,
+                        RoomID = 1337,
+                    }),
+                }
+            });
+        }
+
+        [Test]
+        public void TestRoomWithUpdatedRoomID()
+        {
+            Room room = null!;
+
+            AddStep("create rooms", () => Child = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(5),
+                Children = new[]
+                {
+                    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.",
+                        QueueMode = QueueMode.HostOnly,
+                        Type = MatchType.HeadToHead,
+                    }),
+                }
+            });
+            AddWaitStep("wait", 3);
+            AddStep("set room ID", () => room.RoomID = 1337);
+            AddWaitStep("wait", 3);
+            AddStep("clear room ID", () => room.RoomID = null);
+        }
+
         private RoomPanel createLoungeRoom(Room room)
         {
             room.Host ??= new APIUser { Username = "peppy", Id = 2 };
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
index ee5b1797ed..c7499c98b5 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
@@ -26,8 +26,8 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.GameplayTest;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osuTK.Input;
 
@@ -110,7 +110,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("exit", () => getEditor().Exit());
 
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect
                                                        && songSelect.Beatmap.Value is DummyWorkingBeatmap);
         }
 
@@ -171,7 +171,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("switch ruleset at song select", () => Game.Ruleset.Value = new ManiaRuleset().RulesetInfo);
 
-            AddStep("open editor", () => ((PlaySongSelect)Game.ScreenStack.CurrentScreen).Edit(beatmapSet.Beatmaps.First(beatmap => beatmap.Ruleset.OnlineID == 0)));
+            AddStep("open editor", () => ((SoloSongSelect)Game.ScreenStack.CurrentScreen).Edit(beatmapSet.Beatmaps.First(beatmap => beatmap.Ruleset.OnlineID == 0)));
 
             AddUntilStep("wait for editor open", () => Game.ScreenStack.CurrentScreen is Editor editor && editor.ReadyForUse);
             AddAssert("editor ruleset is osu!", () => Game.Ruleset.Value, () => Is.EqualTo(new OsuRuleset().RulesetInfo));
@@ -187,8 +187,8 @@ namespace osu.Game.Tests.Visual.Navigation
             });
             AddAssert("gameplay ruleset is osu!", () => Game.Ruleset.Value, () => Is.EqualTo(new OsuRuleset().RulesetInfo));
 
-            AddStep("exit to song select", () => Game.PerformFromScreen(_ => { }, typeof(PlaySongSelect).Yield()));
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddStep("exit to song select", () => Game.PerformFromScreen(_ => { }, typeof(SoloSongSelect).Yield()));
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
             AddAssert("previous ruleset restored", () => Game.Ruleset.Value.Equals(new ManiaRuleset().RulesetInfo));
         }
 
@@ -289,8 +289,8 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("user request play", () => Game.MusicController.Play(requestedByUser: true));
             AddUntilStep("music still stopped", () => !Game.MusicController.IsPlaying);
 
-            AddStep("exit to song select", () => Game.PerformFromScreen(_ => { }, typeof(PlaySongSelect).Yield()));
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddStep("exit to song select", () => Game.PerformFromScreen(_ => { }, typeof(SoloSongSelect).Yield()));
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
 
             AddUntilStep("wait for music playing", () => Game.MusicController.IsPlaying);
             AddStep("user request stop", () => Game.MusicController.Stop(requestedByUser: true));
@@ -352,13 +352,13 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("present beatmap", () => Game.PresentBeatmap(beatmapSet));
             AddUntilStep("wait for song select",
                 () => Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet)
-                      && Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
-                      && songSelect.BeatmapSetsLoaded);
+                      && Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect
+                      && songSelect.CarouselItemsPresented);
         }
 
         private void openEditor()
         {
-            AddStep("open editor", () => ((PlaySongSelect)Game.ScreenStack.CurrentScreen).Edit(beatmapSet.Beatmaps.First(beatmap => beatmap.Ruleset.OnlineID == 0)));
+            AddStep("open editor", () => ((SoloSongSelect)Game.ScreenStack.CurrentScreen).Edit(beatmapSet.Beatmaps.First(beatmap => beatmap.Ruleset.OnlineID == 0)));
             AddUntilStep("wait for editor open", () => Game.ScreenStack.CurrentScreen is Editor editor && editor.ReadyForUse);
         }
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneButtonSystemNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneButtonSystemNavigation.cs
index 43b160250c..0ccfb5a4e3 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneButtonSystemNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneButtonSystemNavigation.cs
@@ -5,7 +5,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Navigation
@@ -40,7 +40,7 @@ namespace osu.Game.Tests.Visual.Navigation
                 InputManager.Key(Key.P);
             });
 
-            AddAssert("entered song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddAssert("entered song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
         }
 
         [Test]
@@ -55,7 +55,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("state is play", () => buttons.State == ButtonSystemState.Play);
 
             AddStep("press P", () => InputManager.Key(Key.P));
-            AddAssert("entered song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddAssert("entered song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneChangeAndUseGameplayBindings.cs b/osu.Game.Tests/Visual/Navigation/TestSceneChangeAndUseGameplayBindings.cs
index 3a3af43cb1..4f27d9b323 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneChangeAndUseGameplayBindings.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneChangeAndUseGameplayBindings.cs
@@ -15,7 +15,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Overlays.Settings.Sections.Input;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK.Input;
 
@@ -54,10 +54,10 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
-            PushAndConfirm(() => new PlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
 
             AddUntilStep("wait for selection", () => !Game.Beatmap.IsDefault);
-            AddUntilStep("wait for carousel load", () => songSelect.BeatmapSetsLoaded);
+            AddUntilStep("wait for carousel load", () => songSelect.CarouselItemsPresented);
 
             AddStep("enter gameplay", () => InputManager.Key(Key.Enter));
 
@@ -94,7 +94,7 @@ namespace osu.Game.Tests.Visual.Navigation
                                                                   .AsEnumerable()
                                                                   .First(k => k.RulesetName == "osu" && k.ActionInt == 0);
 
-        private Screens.Select.SongSelect songSelect => Game.ScreenStack.CurrentScreen as Screens.Select.SongSelect;
+        private SoloSongSelect songSelect => Game.ScreenStack.CurrentScreen as SoloSongSelect;
 
         private Player player => Game.ScreenStack.CurrentScreen as Player;
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneMouseWheelVolumeAdjust.cs b/osu.Game.Tests/Visual/Navigation/TestSceneMouseWheelVolumeAdjust.cs
index 26a37fa211..0a4349d73f 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneMouseWheelVolumeAdjust.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneMouseWheelVolumeAdjust.cs
@@ -5,6 +5,7 @@ using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Game.Configuration;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK.Input;
 
@@ -83,9 +84,9 @@ namespace osu.Game.Tests.Visual.Navigation
         private void loadToPlayerNonBreakTime()
         {
             Player? player = null;
-            Screens.Select.SongSelect songSelect = null!;
-            PushAndConfirm(() => songSelect = new TestSceneScreenNavigation.TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            SoloSongSelect 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);
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneOsuGame.cs b/osu.Game.Tests/Visual/Navigation/TestSceneOsuGame.cs
index de303fe074..f356873220 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneOsuGame.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneOsuGame.cs
@@ -25,6 +25,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens.Menu;
 using osu.Game.Skinning;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Navigation
@@ -83,6 +84,7 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestCursorHidesWhenIdle()
         {
+            AddStep("move mouse inside game bounds", () => InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.TopLeft + new Vector2(20)));
             AddStep("click mouse", () => InputManager.Click(MouseButton.Left));
             AddUntilStep("wait until idle", () => Game.IsIdle.Value);
             AddUntilStep("menu cursor hidden", () => Game.GlobalCursorDisplay.MenuCursor.ActiveCursor.Alpha == 0);
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePerformFromScreen.cs b/osu.Game.Tests/Visual/Navigation/TestScenePerformFromScreen.cs
index 5fe4bb9340..04d7b15295 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePerformFromScreen.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePerformFromScreen.cs
@@ -17,9 +17,9 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK.Input;
-using static osu.Game.Tests.Visual.Navigation.TestSceneScreenNavigation;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
@@ -44,17 +44,17 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestPerformAtSongSelect()
         {
-            PushAndConfirm(() => new TestPlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
 
-            AddStep("perform immediately", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(TestPlaySongSelect) }));
+            AddStep("perform immediately", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(SoloSongSelect) }));
             AddAssert("did perform", () => actionPerformed);
-            AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen is TestPlaySongSelect);
+            AddAssert("screen didn't change", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
         }
 
         [Test]
         public void TestPerformAtMenuFromSongSelect()
         {
-            PushAndConfirm(() => new TestPlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
 
             AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true));
             AddUntilStep("returned to menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
@@ -69,8 +69,8 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("Press enter", () => InputManager.Key(Key.Enter));
             AddUntilStep("Wait for new screen", () => Game.ScreenStack.CurrentScreen is PlayerLoader);
 
-            AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(TestPlaySongSelect) }));
-            AddUntilStep("returned to song select", () => Game.ScreenStack.CurrentScreen is TestPlaySongSelect);
+            AddStep("try to perform", () => Game.PerformFromScreen(_ => actionPerformed = true, new[] { typeof(SoloSongSelect) }));
+            AddUntilStep("returned to song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect);
             AddAssert("did perform", () => actionPerformed);
         }
 
@@ -257,7 +257,7 @@ namespace osu.Game.Tests.Visual.Navigation
         private void importAndWaitForSongSelect()
         {
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
-            PushAndConfirm(() => new TestPlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
             AddUntilStep("beatmap updated", () => Game.Beatmap.Value.BeatmapSetInfo.OnlineID == 241526);
         }
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
index f036b4b3ef..e7172cacbf 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
@@ -16,7 +16,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
@@ -81,11 +81,9 @@ namespace osu.Game.Tests.Visual.Navigation
             presentAndConfirm(osuImport);
 
             var maniaImport = importBeatmap(2, new ManiaRuleset().RulesetInfo);
-            confirmBeatmapInSongSelect(maniaImport);
             presentAndConfirm(maniaImport);
 
             var catchImport = importBeatmap(3, new CatchRuleset().RulesetInfo);
-            confirmBeatmapInSongSelect(catchImport);
             presentAndConfirm(catchImport);
 
             // Ruleset is always changed.
@@ -103,11 +101,9 @@ namespace osu.Game.Tests.Visual.Navigation
             presentAndConfirm(osuImport);
 
             var maniaImport = importBeatmap(2, new ManiaRuleset().RulesetInfo);
-            confirmBeatmapInSongSelect(maniaImport);
             presentAndConfirm(maniaImport);
 
             var catchImport = importBeatmap(3, new CatchRuleset().RulesetInfo);
-            confirmBeatmapInSongSelect(catchImport);
             presentAndConfirm(catchImport);
 
             // force ruleset to osu!mania
@@ -178,14 +174,14 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             AddUntilStep("wait for carousel loaded", () =>
             {
-                var songSelect = (Screens.Select.SongSelect)Game.ScreenStack.CurrentScreen;
+                var songSelect = (SoloSongSelect)Game.ScreenStack.CurrentScreen;
                 return songSelect.ChildrenOfType<BeatmapCarousel>().SingleOrDefault()?.IsLoaded == true;
             });
 
             AddUntilStep("beatmap in song select", () =>
             {
-                var songSelect = (Screens.Select.SongSelect)Game.ScreenStack.CurrentScreen;
-                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().BeatmapSets.Any(b => b.MatchesOnlineID(getImport()));
+                var songSelect = (SoloSongSelect)Game.ScreenStack.CurrentScreen;
+                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().GetCarouselItems()!.Any(i => i.Model is BeatmapSetInfo bsi && bsi.MatchesOnlineID(getImport()));
             });
         }
 
@@ -193,7 +189,7 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             AddStep("present beatmap", () => Game.PresentBeatmap(getImport()));
 
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
             AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapSetInfo.OnlineID, () => Is.EqualTo(getImport().OnlineID));
             AddAssert("correct ruleset selected", () => Game.Ruleset.Value, () => Is.EqualTo(getImport().Beatmaps.First().Ruleset));
         }
@@ -203,7 +199,7 @@ namespace osu.Game.Tests.Visual.Navigation
             Predicate<BeatmapInfo> pred = b => b.OnlineID == importedID * 1024 + 2;
             AddStep("present difficulty", () => Game.PresentBeatmap(getImport(), pred));
 
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
             AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(importedID * 1024 + 2));
             AddAssert("correct ruleset selected", () => Game.Ruleset.Value.OnlineID, () => Is.EqualTo(expectedRulesetOnlineID ?? getImport().Beatmaps.First().Ruleset.OnlineID));
         }
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePresentScore.cs b/osu.Game.Tests/Visual/Navigation/TestScenePresentScore.cs
index 2c2335de13..fa337a3ec2 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePresentScore.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePresentScore.cs
@@ -18,7 +18,8 @@ using osu.Game.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
+using FilterControl = osu.Game.Screens.SelectV2.FilterControl;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
@@ -96,9 +97,9 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestFromSongSelectWithFilter([Values] ScorePresentType type)
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
-            AddStep("filter to nothing", () => ((PlaySongSelect)Game.ScreenStack.CurrentScreen).FilterControl.CurrentTextSearch.Value = "fdsajkl;fgewq");
+            AddStep("filter to nothing", () => ((SoloSongSelect)Game.ScreenStack.CurrentScreen).ChildrenOfType<FilterControl>().Single().Search("fdsajkl;fgewq"));
             AddUntilStep("wait for no results", () => Beatmap.IsDefault);
 
             var firstImport = importScore(1, new CatchRuleset().RulesetInfo);
@@ -109,7 +110,7 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestFromSongSelectWithConvertRulesetChange([Values] ScorePresentType type)
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             AddStep("set convert to false", () => Game.LocalConfig.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
 
@@ -121,7 +122,7 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestFromSongSelect([Values] ScorePresentType type)
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             var firstImport = importScore(1);
             presentAndConfirm(firstImport, type);
@@ -134,7 +135,7 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestFromSongSelectDifferentRuleset([Values] ScorePresentType type)
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             var firstImport = importScore(1);
             presentAndConfirm(firstImport, type);
@@ -147,7 +148,7 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestPresentTwoImportsWithSameOnlineIDButDifferentHashes([Values] ScorePresentType type)
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             var firstImport = importScore(1);
             presentAndConfirm(firstImport, type);
@@ -160,7 +161,7 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestScoreRefetchIgnoresEmptyHash()
         {
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
+            AddUntilStep("song select is current", () => Game.ScreenStack.CurrentScreen is SoloSongSelect songSelect && songSelect.CarouselItemsPresented);
 
             importScore(-1, hash: string.Empty);
             importScore(3, hash: @"deadbeef");
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index 7aa2ecb06c..d50fc69823 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -26,7 +26,6 @@ using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
-using osu.Game.Online.Leaderboards;
 using osu.Game.Online.Notifications.WebSocket;
 using osu.Game.Online.Notifications.WebSocket.Events;
 using osu.Game.Overlays;
@@ -49,20 +48,13 @@ using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Screens.Ranking;
-using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Leaderboards;
-using osu.Game.Screens.Select.Options;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Beatmaps.IO;
 using osu.Game.Tests.Resources;
 using osu.Game.Utils;
 using osuTK;
 using osuTK.Input;
-using BeatmapCarousel = osu.Game.Screens.Select.BeatmapCarousel;
-using CollectionDropdown = osu.Game.Collections.CollectionDropdown;
-using FilterControl = osu.Game.Screens.Select.FilterControl;
-using FooterButtonRandom = osu.Game.Screens.Select.FooterButtonRandom;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
@@ -146,62 +138,70 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestExitSongSelectWithEscape()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
+            ModSelectOverlay modSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
-            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddStep("Show mods overlay", () =>
+            {
+                modSelect = songSelect!.ChildrenOfType<ModSelectOverlay>().Single();
+                modSelect.Show();
+            });
+            AddAssert("Overlay was shown", () => modSelect.State.Value == Visibility.Visible);
             pushEscape();
-            AddAssert("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            AddAssert("Overlay was hidden", () => modSelect.State.Value == Visibility.Hidden);
             exitViaEscapeAndConfirm();
         }
 
         [Test]
         public void TestEnterGameplayWhileFilteringToNoSelection()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
 
-            AddStep("force selection", () =>
+            AddStep("force selection and change filter immediately", () =>
             {
-                songSelect.FinaliseSelection();
-                songSelect.FilterControl.CurrentTextSearch.Value = "test";
+                InputManager.Key(Key.Enter);
+                songSelect.ChildrenOfType<FilterControl>().Single().Search("test");
             });
 
             AddUntilStep("wait for player", () => !songSelect.IsCurrentScreen());
             AddStep("return to song select", () => songSelect.MakeCurrent());
 
-            AddUntilStep("wait for selection lost", () => songSelect.Beatmap.IsDefault);
+            AddUntilStep("selection not lost", () => !songSelect.Beatmap.IsDefault);
+            AddUntilStep("placeholder visible", () => songSelect.ChildrenOfType<NoResultsPlaceholder>().Single().State.Value, () => Is.EqualTo(Visibility.Visible));
         }
 
         [Test]
         public void TestSongSelectBackActionHandling()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+
+            AddUntilStep("wait for filter control", () => filterControlTextBox().IsLoaded);
 
             AddStep("set filter", () => filterControlTextBox().Current.Value = "test");
             AddStep("press back", () => InputManager.Click(MouseButton.Button1));
 
-            AddAssert("still at song select", () => Game.ScreenStack.CurrentScreen == songSelect);
+            AddAssert("still at song select", () => Game.ScreenStack.CurrentScreen, () => Is.EqualTo(songSelect));
             AddAssert("filter cleared", () => string.IsNullOrEmpty(filterControlTextBox().Current.Value));
 
             AddStep("set filter again", () => filterControlTextBox().Current.Value = "test");
             AddStep("open collections dropdown", () =>
             {
-                InputManager.MoveMouseTo(songSelect.ChildrenOfType<CollectionDropdown>().Single());
+                InputManager.MoveMouseTo(songSelect.ChildrenOfType<Screens.SelectV2.CollectionDropdown>().Single());
                 InputManager.Click(MouseButton.Left);
             });
 
             AddStep("press back once", () => InputManager.Click(MouseButton.Button1));
             AddAssert("still at song select", () => Game.ScreenStack.CurrentScreen == songSelect);
             AddAssert("collections dropdown closed", () => songSelect
-                                                           .ChildrenOfType<CollectionDropdown>().Single()
+                                                           .ChildrenOfType<Screens.SelectV2.CollectionDropdown>().Single()
                                                            .ChildrenOfType<Dropdown<CollectionFilterMenuItem>.DropdownMenu>().Single().State == MenuState.Closed);
 
             AddStep("press back a second time", () => InputManager.Click(MouseButton.Button1));
@@ -210,17 +210,17 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("press back a third time", () => InputManager.Click(MouseButton.Button1));
             ConfirmAtMainMenu();
 
-            TextBox filterControlTextBox() => songSelect.ChildrenOfType<FilterControl.FilterControlTextBox>().Single();
+            FilterControl.SongSelectSearchTextBox filterControlTextBox() => songSelect.ChildrenOfType<FilterControl.SongSelectSearchTextBox>().Single();
         }
 
         [Test]
         public void TestSongSelectRandomRewindButton()
         {
             Guid? originalSelection = null;
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("Add two beatmaps", () =>
             {
@@ -247,41 +247,6 @@ namespace osu.Game.Tests.Visual.Navigation
 
         [Test]
         public void TestSongSelectScrollHandling()
-        {
-            TestPlaySongSelect songSelect = null;
-            double scrollPosition = 0;
-
-            AddStep("set game volume to max", () => Game.Dependencies.Get<FrameworkConfigManager>().SetValue(FrameworkSetting.VolumeUniversal, 1d));
-            AddUntilStep("wait for volume overlay to hide", () => Game.ChildrenOfType<VolumeOverlay>().SingleOrDefault()?.State.Value, () => Is.EqualTo(Visibility.Hidden));
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
-            AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
-            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
-
-            AddStep("store scroll position", () => scrollPosition = getCarouselScrollPosition());
-
-            AddStep("move to left side", () => InputManager.MoveMouseTo(
-                songSelect.ChildrenOfType<Screens.Select.SongSelect.LeftSideInteractionContainer>().Single().ScreenSpaceDrawQuad.TopLeft + new Vector2(1)));
-            AddStep("scroll down", () => InputManager.ScrollVerticalBy(-1));
-            AddAssert("carousel didn't move", getCarouselScrollPosition, () => Is.EqualTo(scrollPosition));
-
-            AddRepeatStep("alt-scroll down", () =>
-            {
-                InputManager.PressKey(Key.AltLeft);
-                InputManager.ScrollVerticalBy(-1);
-                InputManager.ReleaseKey(Key.AltLeft);
-            }, 5);
-            AddAssert("game volume decreased", () => Game.Dependencies.Get<FrameworkConfigManager>().Get<double>(FrameworkSetting.VolumeUniversal), () => Is.LessThan(1));
-
-            AddStep("move to carousel", () => InputManager.MoveMouseTo(songSelect.ChildrenOfType<BeatmapCarousel>().Single()));
-            AddStep("scroll down", () => InputManager.ScrollVerticalBy(-1));
-            AddAssert("carousel moved", getCarouselScrollPosition, () => Is.Not.EqualTo(scrollPosition));
-
-            double getCarouselScrollPosition() => Game.ChildrenOfType<UserTrackingScrollContainer<DrawableCarouselItem>>().Single().Current;
-        }
-
-        [Test]
-        public void TestNewSongSelectScrollHandling()
         {
             SoloSongSelect songSelect = null;
             double scrollPosition = 0;
@@ -293,6 +258,8 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
             AddUntilStep("wait for beatmap", () => Game.ChildrenOfType<PanelBeatmapSet>().Any());
 
+            // TODO: this logic can likely be removed when we fix https://github.com/ppy/osu/issues/33379
+            // It should be probably be immediate in this case.
             AddWaitStep("wait for scroll", 10);
 
             AddStep("store scroll position", () => scrollPosition = getCarouselScrollPosition());
@@ -325,7 +292,7 @@ namespace osu.Game.Tests.Visual.Navigation
             }, 5);
             AddAssert("game volume decreased", () => Game.Dependencies.Get<FrameworkConfigManager>().Get<double>(FrameworkSetting.VolumeUniversal), () => Is.LessThan(1));
 
-            AddStep("move to carousel", () => InputManager.MoveMouseTo(songSelect.ChildrenOfType<Screens.SelectV2.BeatmapCarousel>().Single()));
+            AddStep("move to carousel", () => InputManager.MoveMouseTo(songSelect.ChildrenOfType<BeatmapCarousel>().Single()));
             AddStep("scroll down", () => InputManager.ScrollVerticalBy(-1));
             AddAssert("carousel moved", getCarouselScrollPosition, () => Is.Not.EqualTo(scrollPosition));
 
@@ -339,21 +306,21 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestOpenModSelectOverlayUsingAction()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
             AddStep("Show mods overlay", () => InputManager.Key(Key.F1));
-            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddAssert("Overlay was shown", () => songSelect!.ChildrenOfType<ModSelectOverlay>().Single().State.Value == Visibility.Visible);
         }
 
         [Test]
         public void TestAttemptPlayBeatmapWrongHashFails()
         {
-            Screens.Select.SongSelect songSelect = null;
+            Screens.SelectV2.SongSelect songSelect = null;
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).GetResultSafely());
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
 
@@ -384,11 +351,11 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestAttemptPlayBeatmapMissingFails()
         {
-            Screens.Select.SongSelect songSelect = null;
+            Screens.SelectV2.SongSelect songSelect = null;
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).GetResultSafely());
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
 
@@ -418,9 +385,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             Player player = null;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
@@ -461,9 +428,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             Player player = null;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game).WaitSafely());
 
@@ -515,9 +482,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             Player player = null;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game).WaitSafely());
 
@@ -558,9 +525,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             Player player = null;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
@@ -663,7 +630,7 @@ namespace osu.Game.Tests.Visual.Navigation
             playToResults();
 
             ScoreInfo score = null;
-            LeaderboardScore scorePanel = null;
+            BeatmapLeaderboardScore scorePanel = null;
 
             AddStep("get score", () => score = ((ResultsScreen)Game.ScreenStack.CurrentScreen).Score);
 
@@ -672,18 +639,11 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action!.Invoke());
 
             AddStep("show local scores",
-                () => Game.ChildrenOfType<BeatmapDetailAreaTabControl>().First().Current.Value = new BeatmapDetailAreaLeaderboardTabItem<BeatmapLeaderboardScope>(BeatmapLeaderboardScope.Local));
+                () => Game.ChildrenOfType<Dropdown<BeatmapLeaderboardScope>>().First().Current.Value = BeatmapLeaderboardScope.Local);
 
-            AddUntilStep("wait for score displayed", () => (scorePanel = Game.ChildrenOfType<LeaderboardScore>().FirstOrDefault(s => s.Score.Equals(score))) != null);
+            AddUntilStep("wait for score displayed", () => (scorePanel = Game.ChildrenOfType<BeatmapLeaderboardScore>().FirstOrDefault(s => s.Score.Equals(score))) != null);
 
-            AddStep("open options", () => InputManager.Key(Key.F3));
-
-            AddStep("choose clear all scores", () => InputManager.Key(Key.Number4));
-
-            AddUntilStep("wait for dialog display", () => ((Drawable)Game.Dependencies.Get<IDialogOverlay>()).IsLoaded);
-            AddUntilStep("wait for dialog", () => Game.Dependencies.Get<IDialogOverlay>().CurrentDialog != null);
-            AddStep("confirm deletion", () => InputManager.Key(Key.Number1));
-            AddUntilStep("wait for dialog dismissed", () => Game.Dependencies.Get<IDialogOverlay>().CurrentDialog == null);
+            AddStep("Clear all scores", () => Game.Dependencies.Get<ScoreManager>().Delete());
 
             AddUntilStep("ensure score is pending deletion", () => Game.Realm.Run(r => r.Find<ScoreInfo>(score.ID)?.DeletePending == true));
 
@@ -696,7 +656,7 @@ namespace osu.Game.Tests.Visual.Navigation
             playToResults();
 
             ScoreInfo score = null;
-            LeaderboardScore scorePanel = null;
+            BeatmapLeaderboardScore scorePanel = null;
 
             AddStep("get score", () => score = ((ResultsScreen)Game.ScreenStack.CurrentScreen).Score);
 
@@ -705,9 +665,9 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action!.Invoke());
 
             AddStep("show local scores",
-                () => Game.ChildrenOfType<BeatmapDetailAreaTabControl>().First().Current.Value = new BeatmapDetailAreaLeaderboardTabItem<BeatmapLeaderboardScope>(BeatmapLeaderboardScope.Local));
+                () => Game.ChildrenOfType<Dropdown<BeatmapLeaderboardScope>>().First().Current.Value = BeatmapLeaderboardScope.Local);
 
-            AddUntilStep("wait for score displayed", () => (scorePanel = Game.ChildrenOfType<LeaderboardScore>().FirstOrDefault(s => s.Score.Equals(score))) != null);
+            AddUntilStep("wait for score displayed", () => (scorePanel = Game.ChildrenOfType<BeatmapLeaderboardScore>().FirstOrDefault(s => s.Score.Equals(score))) != null);
 
             AddStep("right click panel", () =>
             {
@@ -718,7 +678,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("click delete", () =>
             {
                 var dropdownItem = Game
-                                   .ChildrenOfType<PlayBeatmapDetailArea>().First()
+                                   .ChildrenOfType<BeatmapLeaderboardWedge>().First()
                                    .ChildrenOfType<OsuContextMenu>().First()
                                    .ChildrenOfType<DrawableOsuMenuItem>().First(i => i.Item.Text.ToString() == "Delete");
 
@@ -744,9 +704,9 @@ namespace osu.Game.Tests.Visual.Navigation
 
             IWorkingBeatmap beatmap() => Game.Beatmap.Value;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            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());
 
@@ -777,9 +737,9 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestMenuMakesMusic()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
 
             AddUntilStep("wait for no track", () => Game.MusicController.CurrentTrack.IsDummyDevice);
 
@@ -791,26 +751,32 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestPushSongSelectAndPressBackButtonImmediately()
         {
-            AddStep("push song select", () => Game.ScreenStack.Push(new TestPlaySongSelect()));
+            AddStep("push song select", () => Game.ScreenStack.Push(new SoloSongSelect()));
             AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action!.Invoke());
-            AddWaitStep("wait two frames", 2);
+
+            ConfirmAtMainMenu();
         }
 
         [Test]
         public void TestExitSongSelectWithClick()
         {
-            TestPlaySongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
+            ModSelectOverlay modSelect = null;
 
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
-            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddStep("Show mods overlay", () =>
+            {
+                modSelect = songSelect!.ChildrenOfType<ModSelectOverlay>().Single();
+                modSelect.Show();
+            });
+            AddAssert("Overlay was shown", () => modSelect.State.Value == Visibility.Visible);
 
             AddStep("Move mouse to dimmed area", () => InputManager.MoveMouseTo(new Vector2(
                 songSelect.ScreenSpaceDrawQuad.TopLeft.X + 1,
                 songSelect.ScreenSpaceDrawQuad.TopLeft.Y + songSelect.ScreenSpaceDrawQuad.Height / 2)));
             AddStep("Click left mouse button", () => InputManager.Click(MouseButton.Left));
 
-            AddUntilStep("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            AddUntilStep("Overlay was hidden", () => modSelect.State.Value == Visibility.Hidden);
             exitViaBackButtonAndConfirm();
         }
 
@@ -875,10 +841,18 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             AddUntilStep("Wait for toolbar to load", () => Game.Toolbar.IsLoaded);
 
-            TestPlaySongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            SoloSongSelect songSelect = null;
+            ModSelectOverlay modSelect = null;
 
-            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddStep("Show mods overlay", () =>
+            {
+                modSelect = songSelect!.ChildrenOfType<ModSelectOverlay>().Single();
+                modSelect.Show();
+            });
+            AddAssert("Overlay was shown", () => modSelect.State.Value == Visibility.Visible);
+
+            AddStep("Show mods overlay", () => modSelect.Show());
 
             AddStep("Change ruleset to osu!taiko", () =>
             {
@@ -889,7 +863,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddAssert("Ruleset changed to osu!taiko", () => Game.Toolbar.ChildrenOfType<ToolbarRulesetSelector>().Single().Current.Value.OnlineID == 1);
 
-            AddAssert("Mods overlay still visible", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddAssert("Mods overlay still visible", () => modSelect.State.Value == Visibility.Visible);
         }
 
         [Test]
@@ -899,10 +873,12 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
-            TestPlaySongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            SoloSongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
-            AddStep("Show options overlay", () => songSelect.BeatmapOptionsOverlay.Show());
+            AddStep("Show options overlay", () => InputManager.Key(Key.F3));
+            AddUntilStep("Options overlay visible", () => this.ChildrenOfType<FooterButtonOptions.Popover>().SingleOrDefault()?.State.Value == Visibility.Visible);
 
             AddStep("Change ruleset to osu!taiko", () =>
             {
@@ -913,7 +889,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddAssert("Ruleset changed to osu!taiko", () => Game.Toolbar.ChildrenOfType<ToolbarRulesetSelector>().Single().Current.Value.OnlineID == 1);
 
-            AddAssert("Options overlay still visible", () => songSelect.BeatmapOptionsOverlay.State.Value == Visibility.Visible);
+            AddAssert("Options overlay still visible", () => this.ChildrenOfType<FooterButtonOptions.Popover>().Single().State.Value == Visibility.Visible);
         }
 
         [Test]
@@ -1185,7 +1161,7 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestExitGameFromSongSelect()
         {
-            PushAndConfirm(() => new TestPlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
             exitViaEscapeAndConfirm();
 
             pushEscape(); // returns to osu! logo
@@ -1200,6 +1176,8 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestExitWithHoldDisabled()
         {
+            AddUntilStep("wait for dialog overlay", () => Game.ChildrenOfType<DialogOverlay>().SingleOrDefault() != null);
+
             AddStep("set hold delay to 0", () => Game.LocalConfig.SetValue(OsuSetting.UIHoldActivationDelay, 0.0));
 
             AddStep("press escape twice rapidly", () =>
@@ -1255,10 +1233,10 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("close settings sidebar", () => InputManager.Key(Key.Escape));
 
-            Screens.Select.SongSelect songSelect = null;
+            Screens.SelectV2.SongSelect songSelect = null;
             AddRepeatStep("go to solo", () => InputManager.Key(Key.P), 3);
-            AddUntilStep("wait for song select", () => (songSelect = Game.ScreenStack.CurrentScreen as Screens.Select.SongSelect) != null);
-            AddUntilStep("wait for beatmap sets loaded", () => songSelect.BeatmapSetsLoaded);
+            AddUntilStep("wait for song select", () => (songSelect = Game.ScreenStack.CurrentScreen as Screens.SelectV2.SongSelect) != null);
+            AddUntilStep("wait for beatmap sets loaded", () => songSelect.CarouselItemsPresented);
 
             AddStep("switch to osu! ruleset", () =>
             {
@@ -1268,7 +1246,7 @@ namespace osu.Game.Tests.Visual.Navigation
             });
             AddStep("touch beatmap wedge", () =>
             {
-                var wedge = Game.ChildrenOfType<BeatmapInfoWedge>().Single();
+                var wedge = Game.ChildrenOfType<BeatmapTitleWedge>().Single();
                 var touch = new Touch(TouchSource.Touch2, wedge.ScreenSpaceDrawQuad.Centre);
                 InputManager.BeginTouch(touch);
                 InputManager.EndTouch(touch);
@@ -1284,7 +1262,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("touch device mod not activated", () => Game.SelectedMods.Value, () => Has.None.InstanceOf<ModTouchDevice>());
             AddStep("touch beatmap wedge", () =>
             {
-                var wedge = Game.ChildrenOfType<BeatmapInfoWedge>().Single();
+                var wedge = Game.ChildrenOfType<BeatmapTitleWedge>().Single();
                 var touch = new Touch(TouchSource.Touch2, wedge.ScreenSpaceDrawQuad.Centre);
                 InputManager.BeginTouch(touch);
                 InputManager.EndTouch(touch);
@@ -1301,7 +1279,7 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddStep("click beatmap wedge", () =>
             {
-                InputManager.MoveMouseTo(Game.ChildrenOfType<BeatmapInfoWedge>().Single());
+                InputManager.MoveMouseTo(Game.ChildrenOfType<BeatmapTitleWedge>().Single());
                 InputManager.Click(MouseButton.Left);
             });
             AddUntilStep("touch device mod not activated", () => Game.SelectedMods.Value, () => Has.None.InstanceOf<ModTouchDevice>());
@@ -1312,7 +1290,7 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             BeatmapSetInfo beatmapSet = null;
 
-            PushAndConfirm(() => new TestPlaySongSelect());
+            PushAndConfirm(() => new SoloSongSelect());
             AddStep("import beatmap", () => beatmapSet = BeatmapImportHelper.LoadQuickOszIntoOsu(Game).GetResultSafely());
             AddUntilStep("wait for selected", () => Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet));
             AddStep("select", () => InputManager.Key(Key.Enter));
@@ -1342,9 +1320,9 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestExitSongSelectAndImmediatelyClickLogo()
         {
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
@@ -1373,9 +1351,9 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             BeatmapSetInfo beatmap = null;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
@@ -1404,9 +1382,9 @@ namespace osu.Game.Tests.Visual.Navigation
 
             IWorkingBeatmap beatmap() => Game.Beatmap.Value;
 
-            Screens.Select.SongSelect songSelect = null;
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            Screens.SelectV2.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
 
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
 
@@ -1444,12 +1422,5 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("Click back button", () => InputManager.Click(MouseButton.Left));
             ConfirmAtMainMenu();
         }
-
-        public partial class TestPlaySongSelect : PlaySongSelect
-        {
-            public ModSelectOverlay ModSelectOverlay => ModSelect;
-
-            public BeatmapOptionsOverlay BeatmapOptionsOverlay => BeatmapOptions;
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
index 622c85774a..fe76b74bcb 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
@@ -17,6 +17,7 @@ using osu.Framework.Testing;
 using osu.Framework.Threading;
 using osu.Game.Online.API;
 using osu.Game.Beatmaps;
+using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Settings;
 using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets.Mods;
@@ -26,17 +27,19 @@ using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Skinning;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK;
 using osuTK.Input;
-using static osu.Game.Tests.Visual.Navigation.TestSceneScreenNavigation;
 
 namespace osu.Game.Tests.Visual.Navigation
 {
     public partial class TestSceneSkinEditorNavigation : OsuGameTestScene
     {
-        private TestPlaySongSelect songSelect;
+        private SoloSongSelect songSelect;
+        private ModSelectOverlay modSelect => songSelect.ChildrenOfType<ModSelectOverlay>().First();
+
         private SkinEditor skinEditor => Game.ChildrenOfType<SkinEditor>().FirstOrDefault();
 
         [Test]
@@ -331,10 +334,10 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestModOverlayClosesOnOpeningSkinEditor()
         {
             advanceToSongSelect();
-            AddStep("open mod overlay", () => songSelect.ModSelectOverlay.Show());
+            AddStep("open mod overlay", () => modSelect.Show());
 
             openSkinEditor();
-            AddUntilStep("mod overlay closed", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            AddUntilStep("mod overlay closed", () => modSelect.State.Value == Visibility.Hidden);
         }
 
         [Test]
@@ -448,8 +451,8 @@ namespace osu.Game.Tests.Visual.Navigation
 
         private void advanceToSongSelect()
         {
-            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
-            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for song select", () => songSelect.CarouselItemsPresented);
         }
 
         private void openSkinEditor()
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
new file mode 100644
index 0000000000..676be8fccf
--- /dev/null
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
@@ -0,0 +1,241 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Footer;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Ranking;
+using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Beatmaps.IO;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Navigation
+{
+    /// <summary>
+    /// Tests copied out of `TestSceneScreenNavigation` which are specific to song select.
+    /// These are for SongSelectV2. Eventually, the tests in the above class should be deleted along with old song select.
+    /// </summary>
+    public partial class TestSceneSongSelectNavigation : OsuGameTestScene
+    {
+        [Test]
+        public void TestRetryFromResults()
+        {
+            var getOriginalPlayer = playToResults();
+
+            AddStep("attempt to retry", () => ((ResultsScreen)Game.ScreenStack.CurrentScreen).ChildrenOfType<HotkeyRetryOverlay>().First().Action());
+            AddUntilStep("wait for player", () => Game.ScreenStack.CurrentScreen != getOriginalPlayer() && Game.ScreenStack.CurrentScreen is Player);
+        }
+
+        [Test]
+        public void TestPushSongSelectAndClickBottomLeftCorner()
+        {
+            AddStep("push song select", () => Game.ScreenStack.Push(new SoloSongSelect()));
+
+            // TODO: without this step, a critical bug will be hit, see inline comment in `OsuGame.handleBackButton`.
+            AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect select && select.IsLoaded);
+
+            AddStep("click in corner", () =>
+            {
+                InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.BottomLeft);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            ConfirmAtMainMenu();
+        }
+
+        [Test]
+        public void TestPushSongSelectAndPressBackButtonImmediately()
+        {
+            AddStep("push song select", () => Game.ScreenStack.Push(new SoloSongSelect()));
+
+            // TODO: without this step, a critical bug will be hit, see inline comment in `OsuGame.handleBackButton`.
+            AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect select && select.IsLoaded);
+
+            AddStep("press back button", () => Game.ChildrenOfType<ScreenBackButton>().First().Action!.Invoke());
+
+            ConfirmAtMainMenu();
+        }
+
+        [Test]
+        public void TestEditBeatmap()
+        {
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("open menu", () => InputManager.Key(Key.F3));
+            AddStep("trigger edit", () =>
+            {
+                // TODO: should be 5, not 4.
+                InputManager.Key(Key.Number4);
+            });
+
+            waitForScreen<Editor>();
+
+            pushEscape();
+            waitForScreen<SoloSongSelect>();
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestSongContinuesAfterExitPlayer(bool withUserPause)
+        {
+            Player? player = null;
+
+            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
+
+            PushAndConfirm(() => new SoloSongSelect());
+
+            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, () => Is.True);
+
+            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 TestAutoplayShortcutReturnsInitialModsOnExit()
+        {
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
+
+            AddUntilStep("wait for selection", () => !Game.Beatmap.IsDefault);
+
+            AddStep("open mod select", () => InputManager.Key(Key.F1));
+            AddStep("search magnetised", () => this.ChildrenOfType<ModSelectOverlay>().Single().SearchTerm = "MG");
+            AddStep("select", () => InputManager.Key(Key.Enter));
+
+            AddAssert("magnetised selected", () => Game.SelectedMods.Value.Single(), Is.TypeOf<OsuModMagnetised>);
+            AddStep("configure mod", () => ((OsuModMagnetised)Game.SelectedMods.Value.Single()).AttractionStrength.Value = 1.0f);
+
+            pushEscape();
+            pushEscape();
+
+            AddStep("press ctrl+enter", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.Enter);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddUntilStep("wait for player", () =>
+            {
+                DismissAnyNotifications();
+                return Game.ScreenStack.CurrentScreen is Player;
+            });
+
+            AddAssert("only autoplay selected", () => Game.SelectedMods.Value.Single(), Is.TypeOf<OsuModAutoplay>);
+
+            pushEscape();
+            waitForScreen<SoloSongSelect>();
+
+            AddAssert("magnetised selected", () => Game.SelectedMods.Value.Single(), Is.TypeOf<OsuModMagnetised>);
+            AddAssert("mod configured", () => ((OsuModMagnetised)Game.SelectedMods.Value.Single()).AttractionStrength.Value, () => Is.EqualTo(1.0f));
+        }
+
+        [Test]
+        public void TestLeaderboardCorrectInPlayer()
+        {
+            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
+
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+            AddStep("switch to next difficulty and immediately press enter", () =>
+            {
+                InputManager.Key(Key.Down);
+                Schedule(() => InputManager.Key(Key.Enter));
+            });
+
+            AddUntilStep("wait for player", () =>
+            {
+                DismissAnyNotifications();
+                return Game.ScreenStack.CurrentScreen is Player;
+            });
+            AddAssert("leaderboard matches gameplay beatmap", () => Game.ChildrenOfType<LeaderboardManager>().Single().CurrentCriteria?.Beatmap, () => Is.EqualTo(beatmap().BeatmapInfo));
+        }
+
+        private Func<Player> playToResults()
+        {
+            var player = playToCompletion();
+            AddUntilStep("wait for results", () => (Game.ScreenStack.CurrentScreen as ResultsScreen)?.IsLoaded == true);
+            return player;
+        }
+
+        private Func<Player> playToCompletion()
+        {
+            Player? player = null;
+
+            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
+
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("set mods", () => Game.SelectedMods.Value = new Mod[] { new OsuModNoFail(), new OsuModDoubleTime { SpeedChange = { Value = 2 } } });
+
+            pushEnter();
+
+            AddUntilStep("wait for player", () =>
+            {
+                DismissAnyNotifications();
+                return (player = Game.ScreenStack.CurrentScreen as Player) != null;
+            });
+
+            AddUntilStep("wait for track playing", () => beatmap().Track.IsRunning);
+            AddStep("seek to near end", () => player.ChildrenOfType<GameplayClockContainer>().First().Seek(beatmap().Beatmap.HitObjects[^1].StartTime - 1000));
+            AddUntilStep("wait for complete", () => player?.GameplayState.HasPassed, () => Is.True);
+
+            return () => player!;
+        }
+
+        private void waitForScreen<T>() where T : OsuScreen =>
+            AddUntilStep($"Wait for {typeof(T).ReadableName()}", () => Game.ScreenStack.CurrentScreen is T screen && screen.IsLoaded);
+
+        private void pushEnter() =>
+            AddStep("Press enter", () => InputManager.Key(Key.Enter));
+
+        private void pushEscape() =>
+            AddStep("Press escape", () => InputManager.Key(Key.Escape));
+    }
+}
diff --git a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
index 5dc6f950a5..f36ef7a8e8 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
@@ -243,6 +243,30 @@ namespace osu.Game.Tests.Visual.Online
             });
         }
 
+        [Test]
+        public void TestBeatmapSetHasVideoOrStoryboard()
+        {
+            AddStep("show beatmapset with video", () =>
+            {
+                var beatmapSet = getBeatmapSet();
+                beatmapSet.HasVideo = true;
+                overlay.ShowBeatmapSet(beatmapSet);
+            });
+            AddStep("show beatmapset with storyboard", () =>
+            {
+                var beatmapSet = getBeatmapSet();
+                beatmapSet.HasStoryboard = true;
+                overlay.ShowBeatmapSet(beatmapSet);
+            });
+            AddStep("show beatmapset with video and storyboard", () =>
+            {
+                var beatmapSet = getBeatmapSet();
+                beatmapSet.HasVideo = true;
+                beatmapSet.HasStoryboard = true;
+                overlay.ShowBeatmapSet(beatmapSet);
+            });
+        }
+
         [Test]
         public void TestSelectedModsDontAffectStatistics()
         {
diff --git a/osu.Game.Tests/Visual/Online/TestSceneChangelogOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneChangelogOverlay.cs
index 040b903636..ee88bf917c 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneChangelogOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneChangelogOverlay.cs
@@ -107,7 +107,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 Version = "2018.712.0",
                 DisplayVersion = "2018.712.0",
-                UpdateStream = streams[OsuGameBase.CLIENT_STREAM_NAME],
+                UpdateStream = streams["lazer"],
                 CreatedAt = new DateTime(2018, 7, 12),
                 ChangelogEntries = new List<APIChangelogEntry>
                 {
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneOverallRanking.cs b/osu.Game.Tests/Visual/Ranking/TestSceneOverallRanking.cs
index fb18cc8a59..e49d23dd80 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneOverallRanking.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneOverallRanking.cs
@@ -46,6 +46,32 @@ namespace osu.Game.Tests.Visual.Ranking
                 });
         }
 
+        // cross-reference: `TestSceneToolbarUserButton.TestTransientUserStatisticsDisplay()`, "Test rounding treatment" step.
+        [Test]
+        public void TestRoundingTreatment()
+        {
+            createDisplay();
+            displayUpdate(
+                new UserStatistics
+                {
+                    GlobalRank = 12_345,
+                    Accuracy = 98.99,
+                    MaxCombo = 2_322,
+                    RankedScore = 23_123_543_456,
+                    TotalScore = 123_123_543_456,
+                    PP = 5_071.495M
+                },
+                new UserStatistics
+                {
+                    GlobalRank = 12_345,
+                    Accuracy = 98.99,
+                    MaxCombo = 2_322,
+                    RankedScore = 23_123_543_456,
+                    TotalScore = 123_123_543_456,
+                    PP = 5_072.99M
+                });
+        }
+
         [Test]
         public void TestAllDecreased()
         {
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneSoloResultsScreen.cs b/osu.Game.Tests/Visual/Ranking/TestSceneSoloResultsScreen.cs
index 1ea5e13c49..cd8f234f04 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneSoloResultsScreen.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneSoloResultsScreen.cs
@@ -90,6 +90,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 151_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 scoreManager.Import(localScore);
                 localScore = localScore.Detach();
             });
@@ -119,6 +120,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore.TotalScore = 151_000;
                 localScore.OnlineID = 30;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 scoreManager.Import(localScore);
                 localScore = localScore.Detach();
             });
@@ -161,6 +163,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 151_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -211,6 +214,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 151_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -218,6 +222,63 @@ namespace osu.Game.Tests.Visual.Ranking
             AddAssert("previous user best not shown", () => this.ChildrenOfType<ScorePanel>().All(p => p.Score.OnlineID != 123456));
         }
 
+        [Test]
+        public void TestOnlineLeaderboardWithLessThan50Scores_ShowingAnotherUserScore()
+        {
+            var scores = new List<ScoreInfo>();
+            var soloScores = new List<SoloScoreInfo>();
+
+            AddStep("set leaderboard to global", () => leaderboardManager.FetchWithCriteria(new LeaderboardCriteria(importedBeatmap, importedBeatmap.Ruleset, BeatmapLeaderboardScope.Global, null)));
+            AddStep("set up request handling", () =>
+            {
+                for (int i = 0; i < 30; ++i)
+                {
+                    var score = TestResources.CreateTestScoreInfo(importedBeatmap);
+                    score.TotalScore = 10_000 * (30 - i);
+                    score.Position = i + 1;
+                    score.User = new APIUser { Id = i };
+                    score.BeatmapInfo = new BeatmapInfo
+                    {
+                        OnlineID = 123123,
+                        Status = BeatmapOnlineStatus.Ranked,
+                    };
+                    score.OnlineID = i;
+                    scores.Add(score);
+
+                    var soloScore = SoloScoreInfo.ForSubmission(score);
+                    soloScore.ID = (ulong)i;
+                    soloScores.Add(soloScore);
+                }
+
+                scores[^1].User = API.LocalUser.Value;
+                soloScores[^1].UserID = API.LocalUser.Value.OnlineID;
+
+                dummyAPI.HandleRequest = req =>
+                {
+                    switch (req)
+                    {
+                        case GetScoresRequest getScoresRequest:
+                            getScoresRequest.TriggerSuccess(new APIScoresCollection
+                            {
+                                Scores = soloScores,
+                                UserScore = new APIScoreWithPosition
+                                {
+                                    Score = soloScores[^1],
+                                    Position = 30
+                                }
+                            });
+                            return true;
+                    }
+
+                    return false;
+                };
+            });
+
+            AddStep("show results", () => LoadScreen(new SoloResultsScreen(scores[0])));
+            AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
+            AddAssert("local user best shown", () => this.ChildrenOfType<ScorePanel>().Any(p => p.Score.UserID == API.LocalUser.Value.Id));
+        }
+
         [Test]
         public void TestOnlineLeaderboardWithLessThan50Scores_UserIsLast()
         {
@@ -251,6 +312,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 151_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -302,6 +364,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 31_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -355,6 +418,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 151_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -408,6 +472,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore = TestResources.CreateTestScoreInfo(importedBeatmap);
                 localScore.TotalScore = 651_000;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
@@ -459,6 +524,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 localScore.TotalScore = 151_000;
                 localScore.OnlineID = 12345;
                 localScore.Position = null;
+                localScore.User = API.LocalUser.Value;
                 LoadScreen(new SoloResultsScreen(localScore));
             });
             AddUntilStep("wait for loaded", () => ((Drawable)Stack.CurrentScreen).IsLoaded);
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
index c546c9727c..b63f8ca31c 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
@@ -2,8 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -14,10 +16,12 @@ using osu.Game.Overlays;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens.Ranking;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Ranking
 {
-    public partial class TestSceneUserTagControl : OsuTestScene
+    public partial class TestSceneUserTagControl : OsuManualInputManagerTestScene
     {
         [Cached]
         private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
@@ -63,6 +67,8 @@ namespace osu.Game.Tests.Visual.Ranking
                             beatmapSet.Beatmaps.Single().TopTags =
                             [
                                 new APIBeatmapTag { TagId = 3, VoteCount = 9 },
+                                new APIBeatmapTag { TagId = 2, VoteCount = 8 },
+                                new APIBeatmapTag { TagId = 0, VoteCount = 7 },
                             ];
                             Scheduler.AddDelayed(() => getBeatmapSetRequest.TriggerSuccess(beatmapSet), 500);
                             return true;
@@ -79,6 +85,11 @@ namespace osu.Game.Tests.Visual.Ranking
                     return false;
                 };
             });
+        }
+
+        [Test]
+        public void TestRulesetSupport()
+        {
             AddStep("show for osu! beatmap", () =>
             {
                 var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
@@ -86,6 +97,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 Beatmap.Value = working;
                 recreateControl();
             });
+
             AddStep("show for taiko beatmap", () =>
             {
                 var working = CreateWorkingBeatmap(new TaikoRuleset().RulesetInfo);
@@ -95,6 +107,47 @@ namespace osu.Game.Tests.Visual.Ranking
             });
         }
 
+        [Test]
+        public void TestTagsDoNotMoveUntilMouseMovesAway()
+        {
+            AddStep("show", () =>
+            {
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.BeatmapInfo.OnlineID = 42;
+                Beatmap.Value = working;
+                recreateControl();
+            });
+            AddUntilStep("wait for ready", () => getTagFlow().Count, () => Is.EqualTo(4));
+            AddAssert("tag 2 is second", () => getTagFlow().GetLayoutPosition(getDrawableTagById(2)), () => Is.EqualTo(1));
+            AddStep("vote for tag 2", () =>
+            {
+                InputManager.MoveMouseTo(getDrawableTagById(2));
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(9));
+
+            AddStep("remove vote for tag 2", () =>
+            {
+                InputManager.MoveMouseTo(getDrawableTagById(2));
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("tag 2 not voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(8));
+            AddAssert("tag 2 is still second", () => getTagFlow().GetLayoutPosition(getDrawableTagById(2)), () => Is.EqualTo(1));
+
+            AddStep("vote for tag 2", () =>
+            {
+                InputManager.MoveMouseTo(getDrawableTagById(2));
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("tag 2 voted for", () => getDrawableTagById(2).UserTag.VoteCount.Value, () => Is.EqualTo(9));
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(Vector2.Zero));
+            AddAssert("tag 2 reordered to first", () => getTagFlow().GetLayoutPosition(getDrawableTagById(2)), () => Is.EqualTo(0));
+
+            FillFlowContainer<UserTagControl.DrawableUserTag> getTagFlow() => this.ChildrenOfType<FillFlowContainer<UserTagControl.DrawableUserTag>>().Single();
+
+            UserTagControl.DrawableUserTag getDrawableTagById(long id) => getTagFlow().Single(t => t.UserTag.Id == id);
+        }
+
         private void recreateControl()
         {
             Child = new PopoverContainer
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
index ca6c4998d1..5cf503f21e 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
@@ -119,7 +119,6 @@ namespace osu.Game.Tests.Visual.SongSelect
             {
                 var ruleset = advancedStats.BeatmapInfo.Ruleset.CreateInstance().AsNonNull();
                 var difficultyAdjustMod = ruleset.CreateMod<ModDifficultyAdjust>().AsNonNull();
-                difficultyAdjustMod.ReadFromDifficulty(advancedStats.BeatmapInfo.Difficulty);
                 advancedStats.Mods.Value = new[] { difficultyAdjustMod };
             });
 
@@ -140,7 +139,6 @@ namespace osu.Game.Tests.Visual.SongSelect
                 var difficultyAdjustMod = ruleset.CreateMod<OsuModDifficultyAdjust>().AsNonNull();
                 var originalDifficulty = advancedStats.BeatmapInfo.Difficulty;
 
-                difficultyAdjustMod.ReadFromDifficulty(originalDifficulty);
                 difficultyAdjustMod.DrainRate.Value = originalDifficulty.DrainRate - 0.5f;
                 difficultyAdjustMod.ApproachRate.Value = originalDifficulty.ApproachRate + 2.2f;
                 advancedStats.Mods.Value = new[] { difficultyAdjustMod };
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
deleted file mode 100644
index 44f64365f0..0000000000
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
+++ /dev/null
@@ -1,548 +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.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Platform;
-using osu.Framework.Testing;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.Cursor;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Online.Leaderboards;
-using osu.Game.Overlays;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Scoring;
-using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Leaderboards;
-using osu.Game.Tests.Resources;
-using osu.Game.Users;
-using osuTK;
-using osuTK.Input;
-
-namespace osu.Game.Tests.Visual.SongSelect
-{
-    public partial class TestSceneBeatmapLeaderboard : OsuManualInputManagerTestScene
-    {
-        private readonly FailableLeaderboard leaderboard;
-
-        [Cached(typeof(IDialogOverlay))]
-        private readonly DialogOverlay dialogOverlay;
-
-        private ScoreManager scoreManager = null!;
-        private RulesetStore rulesetStore = null!;
-        private BeatmapManager beatmapManager = null!;
-        private PlaySongSelect songSelect = null!;
-
-        private LeaderboardManager leaderboardManager = null!;
-
-        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.CacheAs<Screens.Select.SongSelect>(songSelect = new PlaySongSelect());
-            dependencies.Cache(leaderboardManager = new LeaderboardManager());
-
-            Dependencies.Cache(Realm);
-
-            return dependencies;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            LoadComponent(songSelect);
-            LoadComponent(leaderboardManager);
-        }
-
-        public TestSceneBeatmapLeaderboard()
-        {
-            Add(new OsuContextMenuContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    dialogOverlay = new DialogOverlay
-                    {
-                        Depth = -1
-                    },
-                    leaderboard = new FailableLeaderboard
-                    {
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Size = new Vector2(550f, 450f),
-                        Scope = BeatmapLeaderboardScope.Global,
-                    }
-                }
-            });
-        }
-
-        [Test]
-        public void TestLocalScoresDisplay()
-        {
-            BeatmapInfo beatmapInfo = null!;
-
-            AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Local);
-
-            AddStep(@"Set beatmap", () =>
-            {
-                beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
-                beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
-
-                leaderboard.BeatmapInfo = beatmapInfo;
-            });
-
-            clearScores();
-            checkDisplayedCount(0);
-
-            importMoreScores(() => beatmapInfo);
-            checkDisplayedCount(10);
-
-            importMoreScores(() => beatmapInfo);
-            checkDisplayedCount(20);
-
-            clearScores();
-            checkDisplayedCount(0);
-        }
-
-        [Test]
-        public void TestLocalScoresDisplayWorksWhenStartingOffline()
-        {
-            BeatmapInfo beatmapInfo = null!;
-
-            AddStep("Log out", () => API.Logout());
-            AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Local);
-
-            AddStep(@"Set beatmap", () =>
-            {
-                beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
-                beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
-
-                leaderboard.BeatmapInfo = beatmapInfo;
-            });
-
-            clearScores();
-            importMoreScores(() => beatmapInfo);
-            checkDisplayedCount(10);
-        }
-
-        [Test]
-        public void TestLocalScoresDisplayOnBeatmapEdit()
-        {
-            BeatmapInfo beatmapInfo = null!;
-            string originalHash = string.Empty;
-
-            AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Local);
-
-            AddStep(@"Import beatmap", () =>
-            {
-                beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
-                beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
-
-                leaderboard.BeatmapInfo = beatmapInfo;
-            });
-
-            clearScores();
-            checkDisplayedCount(0);
-
-            AddStep(@"Perform initial save to guarantee stable hash", () =>
-            {
-                IBeatmap beatmap = beatmapManager.GetWorkingBeatmap(beatmapInfo).Beatmap;
-                beatmapManager.Save(beatmapInfo, beatmap);
-
-                originalHash = beatmapInfo.Hash;
-            });
-
-            importMoreScores(() => beatmapInfo);
-
-            checkDisplayedCount(10);
-            checkStoredCount(10);
-
-            AddStep(@"Save with changes", () =>
-            {
-                IBeatmap beatmap = beatmapManager.GetWorkingBeatmap(beatmapInfo).Beatmap;
-                beatmap.Difficulty.ApproachRate = 12;
-                beatmapManager.Save(beatmapInfo, beatmap);
-            });
-
-            AddAssert("Hash changed", () => beatmapInfo.Hash, () => Is.Not.EqualTo(originalHash));
-            checkDisplayedCount(0);
-            checkStoredCount(10);
-
-            importMoreScores(() => beatmapInfo);
-            importMoreScores(() => beatmapInfo);
-            checkDisplayedCount(20);
-            checkStoredCount(30);
-
-            AddStep(@"Revert changes", () =>
-            {
-                IBeatmap beatmap = beatmapManager.GetWorkingBeatmap(beatmapInfo).Beatmap;
-                beatmap.Difficulty.ApproachRate = 8;
-                beatmapManager.Save(beatmapInfo, beatmap);
-            });
-
-            AddAssert("Hash restored", () => beatmapInfo.Hash, () => Is.EqualTo(originalHash));
-            checkDisplayedCount(10);
-            checkStoredCount(30);
-
-            clearScores();
-            checkDisplayedCount(0);
-            checkStoredCount(0);
-        }
-
-        [Test]
-        public void TestGlobalScoresDisplay()
-        {
-            AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Global);
-            AddStep(@"New Scores", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo())));
-            AddStep(@"New Scores with teams", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()).Select(s =>
-            {
-                s.User.Team = new APITeam();
-                return s;
-            })));
-        }
-
-        [Test]
-        public void TestPersonalBest()
-        {
-            AddStep(@"Show personal best", showPersonalBest);
-            AddStep("null personal best position", showPersonalBestWithNullPosition);
-        }
-
-        [Test]
-        public void TestPlaceholderStates()
-        {
-            AddStep("ensure no scores displayed", () => leaderboard.SetScores(null));
-
-            AddStep(@"Network failure", () => leaderboard.SetErrorState(LeaderboardState.NetworkFailure));
-            AddStep(@"No team", () => leaderboard.SetErrorState(LeaderboardState.NoTeam));
-            AddStep(@"No supporter", () => leaderboard.SetErrorState(LeaderboardState.NotSupporter));
-            AddStep(@"Not logged in", () => leaderboard.SetErrorState(LeaderboardState.NotLoggedIn));
-            AddStep(@"Ruleset unavailable", () => leaderboard.SetErrorState(LeaderboardState.RulesetUnavailable));
-            AddStep(@"Beatmap unavailable", () => leaderboard.SetErrorState(LeaderboardState.BeatmapUnavailable));
-            AddStep(@"None selected", () => leaderboard.SetErrorState(LeaderboardState.NoneSelected));
-        }
-
-        [Test]
-        public void TestUseTheseModsDoesNotCopySystemMods()
-        {
-            AddStep(@"set scores", () => leaderboard.SetScores(leaderboard.Scores, new ScoreInfo
-            {
-                Position = 999,
-                Rank = ScoreRank.XH,
-                Accuracy = 1,
-                MaxCombo = 244,
-                TotalScore = 1707827,
-                Ruleset = new OsuRuleset().RulesetInfo,
-                Mods = new Mod[] { new OsuModHidden(), new ModScoreV2(), },
-                User = new APIUser
-                {
-                    Id = 6602580,
-                    Username = @"waaiiru",
-                    CountryCode = CountryCode.ES,
-                }
-            }));
-            AddUntilStep("wait for scores", () => this.ChildrenOfType<LeaderboardScore>().Count(), () => Is.GreaterThan(0));
-            AddStep("right click panel", () =>
-            {
-                InputManager.MoveMouseTo(this.ChildrenOfType<LeaderboardScore>().Single());
-                InputManager.Click(MouseButton.Right);
-            });
-            AddStep("click use these mods", () =>
-            {
-                InputManager.MoveMouseTo(this.ChildrenOfType<DrawableOsuMenuItem>().Single());
-                InputManager.Click(MouseButton.Left);
-            });
-            AddAssert("song select received HD", () => songSelect.Mods.Value.Any(m => m is OsuModHidden));
-            AddAssert("song select did not receive SV2", () => !songSelect.Mods.Value.Any(m => m is ModScoreV2));
-        }
-
-        private void showPersonalBestWithNullPosition()
-        {
-            leaderboard.SetScores(leaderboard.Scores, new ScoreInfo
-            {
-                Rank = ScoreRank.XH,
-                Accuracy = 1,
-                MaxCombo = 244,
-                TotalScore = 1707827,
-                Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock() },
-                Ruleset = new OsuRuleset().RulesetInfo,
-                User = new APIUser
-                {
-                    Id = 6602580,
-                    Username = @"waaiiru",
-                    CountryCode = CountryCode.ES,
-                },
-            });
-        }
-
-        private void showPersonalBest()
-        {
-            leaderboard.SetScores(leaderboard.Scores, new ScoreInfo
-            {
-                Position = 999,
-                Rank = ScoreRank.XH,
-                Accuracy = 1,
-                MaxCombo = 244,
-                TotalScore = 1707827,
-                Ruleset = new OsuRuleset().RulesetInfo,
-                Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                User = new APIUser
-                {
-                    Id = 6602580,
-                    Username = @"waaiiru",
-                    CountryCode = CountryCode.ES,
-                }
-            });
-        }
-
-        private void importMoreScores(Func<BeatmapInfo> beatmapInfo)
-        {
-            AddStep(@"Import new scores", () =>
-            {
-                foreach (var score in GenerateSampleScores(beatmapInfo()))
-                    scoreManager.Import(score);
-            });
-        }
-
-        private void clearScores()
-        {
-            AddStep("Clear all scores", () => scoreManager.Delete());
-        }
-
-        private void checkDisplayedCount(int expected) =>
-            AddUntilStep($"{expected} scores displayed", () => leaderboard.ChildrenOfType<LeaderboardScore>().Count(), () => Is.EqualTo(expected));
-
-        private void checkStoredCount(int expected) =>
-            AddUntilStep($"Total scores stored is {expected}", () => Realm.Run(r => r.All<ScoreInfo>().Count(s => !s.DeletePending)), () => Is.EqualTo(expected));
-
-        public static ScoreInfo[] GenerateSampleScores(BeatmapInfo beatmapInfo)
-        {
-            return new[]
-            {
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.XH,
-                    Accuracy = 1,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now,
-                    Mods = new Mod[]
-                    {
-                        new OsuModHidden(),
-                        new OsuModFlashlight
-                        {
-                            FollowDelay = { Value = 200 },
-                            SizeMultiplier = { Value = 5 },
-                        },
-                        new OsuModDifficultyAdjust
-                        {
-                            CircleSize = { Value = 11 },
-                            ApproachRate = { Value = 10 },
-                            OverallDifficulty = { Value = 10 },
-                            DrainRate = { Value = 10 },
-                            ExtendedLimits = { Value = true }
-                        }
-                    },
-                    Ruleset = new OsuRuleset().RulesetInfo,
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    User = new APIUser
-                    {
-                        Id = 6602580,
-                        Username = @"waaiiru",
-                        CountryCode = CountryCode.ES,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.X,
-                    Accuracy = 1,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddSeconds(-30),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-                    User = new APIUser
-                    {
-                        Id = 4608074,
-                        Username = @"Skycries",
-                        CountryCode = CountryCode.BR,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.SH,
-                    Accuracy = 1,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddSeconds(-70),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 1014222,
-                        Username = @"eLy",
-                        CountryCode = CountryCode.JP,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.S,
-                    Accuracy = 1,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddMinutes(-40),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 1541390,
-                        Username = @"Toukai",
-                        CountryCode = CountryCode.CA,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.A,
-                    Accuracy = 1,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddHours(-2),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 2243452,
-                        Username = @"Satoruu",
-                        CountryCode = CountryCode.VE,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.B,
-                    Accuracy = 0.9826,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddHours(-25),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 2705430,
-                        Username = @"Mooha",
-                        CountryCode = CountryCode.FR,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.C,
-                    Accuracy = 0.9654,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddHours(-50),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 7151382,
-                        Username = @"Mayuri Hana",
-                        CountryCode = CountryCode.TH,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.D,
-                    Accuracy = 0.6025,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddHours(-72),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 2051389,
-                        Username = @"FunOrange",
-                        CountryCode = CountryCode.CA,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.D,
-                    Accuracy = 0.5140,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddMonths(-10),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 6169483,
-                        Username = @"-Hebel-",
-                        CountryCode = CountryCode.MX,
-                    },
-                },
-                new ScoreInfo
-                {
-                    Rank = ScoreRank.D,
-                    Accuracy = 0.4222,
-                    MaxCombo = 244,
-                    TotalScore = 1707827,
-                    Date = DateTime.Now.AddYears(-2),
-                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
-                    BeatmapInfo = beatmapInfo,
-                    BeatmapHash = beatmapInfo.Hash,
-                    Ruleset = new OsuRuleset().RulesetInfo,
-
-                    User = new APIUser
-                    {
-                        Id = 6702666,
-                        Username = @"prhtnsm",
-                        CountryCode = CountryCode.DE,
-                    },
-                },
-            };
-        }
-
-        private partial class FailableLeaderboard : BeatmapLeaderboard
-        {
-            public new void SetErrorState(LeaderboardState state) => base.SetErrorState(state);
-            public new void SetScores(IEnumerable<ScoreInfo>? scores, ScoreInfo? userScore = null) => base.SetScores(scores, userScore);
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs
index 5c89e8a02c..832e8fc90f 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs
@@ -23,6 +23,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Taiko;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osu.Game.Utils;
@@ -64,16 +65,16 @@ namespace osu.Game.Tests.Visual.SongSelect
                 switch (rulesetID)
                 {
                     case 0:
-                        return 336; // recommended star rating of 2
+                        return 337; // recommended star rating of 2
 
                     case 1:
                         return 973; // SR 3
 
                     case 2:
-                        return 1905; // SR 4
+                        return 1906; // SR 4
 
                     case 3:
-                        return 3329; // SR 5
+                        return 3330; // SR 5
 
                     default:
                         return 0;
@@ -248,7 +249,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             AddStep("present beatmap", () => Game.PresentBeatmap(getImport()));
 
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect select && select.BeatmapSetsLoaded);
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is SoloSongSelect select && select.CarouselItemsPresented);
             AddUntilStep("recommended beatmap displayed", () => Game.Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(getImport().Beatmaps[expectedDiff - 1].OnlineID));
         }
 
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
index 4c895faf27..475d8ec461 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
@@ -139,6 +139,8 @@ namespace osu.Game.Tests.Visual.SongSelect
                 });
             });
 
+            assertCollectionCount(2);
+
             AddStep("remove first collection", () => Realm.Write(r => r.Remove(first)));
             assertCollectionCount(1);
             assertCollectionName(0, "2");
diff --git a/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs b/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs
deleted file mode 100644
index 9dc6bc8a33..0000000000
--- a/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs
+++ /dev/null
@@ -1,1445 +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.Diagnostics;
-using System.Linq;
-using System.Threading.Tasks;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Bindables;
-using osu.Framework.Extensions;
-using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Extensions.ObjectExtensions;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
-using osu.Framework.Platform;
-using osu.Framework.Screens;
-using osu.Framework.Testing;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
-using osu.Game.Database;
-using osu.Game.Extensions;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Online.Chat;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Dialog;
-using osu.Game.Overlays.Mods;
-using osu.Game.Overlays.Notifications;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play;
-using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Carousel;
-using osu.Game.Screens.Select.Filter;
-using osu.Game.Tests.Resources;
-using osuTK.Input;
-
-namespace osu.Game.Tests.Visual.SongSelect
-{
-    [TestFixture]
-    public partial class TestScenePlaySongSelect : ScreenTestScene
-    {
-        private BeatmapManager manager = null!;
-        private RulesetStore rulesets = null!;
-        private MusicController music = null!;
-        private WorkingBeatmap defaultBeatmap = null!;
-        private OsuConfigManager config = null!;
-        private TestSongSelect? songSelect;
-
-        [BackgroundDependencyLoader]
-        private void load(GameHost host, AudioManager audio)
-        {
-            BeatmapStore beatmapStore;
-
-            // These DI caches are required to ensure for interactive runs this test scene doesn't nuke all user beatmaps in the local install.
-            // At a point we have isolated interactive test runs enough, this can likely be removed.
-            Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
-            Dependencies.Cache(Realm);
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, defaultBeatmap = Beatmap.Default));
-            Dependencies.CacheAs(beatmapStore = new RealmDetachedBeatmapStore());
-
-            Dependencies.Cache(music = new MusicController());
-
-            // required to get bindables attached
-            Add(music);
-            Add(beatmapStore);
-
-            Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
-        }
-
-        public override void SetUpSteps()
-        {
-            base.SetUpSteps();
-
-            AddStep("reset defaults", () =>
-            {
-                Ruleset.Value = new OsuRuleset().RulesetInfo;
-
-                Beatmap.SetDefault();
-                SelectedMods.SetDefault();
-
-                songSelect = null;
-            });
-
-            AddStep("delete all beatmaps", () => manager.Delete());
-        }
-
-        [Test]
-        public void TestSpeedChange()
-        {
-            createSongSelect();
-            changeMods();
-
-            decreaseModSpeed();
-            AddAssert("half time activated at 0.95x", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().SpeedChange.Value, () => Is.EqualTo(0.95).Within(0.005));
-
-            decreaseModSpeed();
-            AddAssert("half time speed changed to 0.9x", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().SpeedChange.Value, () => Is.EqualTo(0.9).Within(0.005));
-
-            increaseModSpeed();
-            AddAssert("half time speed changed to 0.95x", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().SpeedChange.Value, () => Is.EqualTo(0.95).Within(0.005));
-
-            increaseModSpeed();
-            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
-
-            increaseModSpeed();
-            AddAssert("double time activated at 1.05x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().SpeedChange.Value, () => Is.EqualTo(1.05).Within(0.005));
-
-            increaseModSpeed();
-            AddAssert("double time speed changed to 1.1x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().SpeedChange.Value, () => Is.EqualTo(1.1).Within(0.005));
-
-            decreaseModSpeed();
-            AddAssert("double time speed changed to 1.05x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().SpeedChange.Value, () => Is.EqualTo(1.05).Within(0.005));
-
-            OsuModNightcore nc = new OsuModNightcore
-            {
-                SpeedChange = { Value = 1.05 }
-            };
-            changeMods(nc);
-
-            increaseModSpeed();
-            AddAssert("nightcore speed changed to 1.1x", () => songSelect!.Mods.Value.OfType<ModNightcore>().Single().SpeedChange.Value, () => Is.EqualTo(1.1).Within(0.005));
-
-            decreaseModSpeed();
-            AddAssert("nightcore speed changed to 1.05x", () => songSelect!.Mods.Value.OfType<ModNightcore>().Single().SpeedChange.Value, () => Is.EqualTo(1.05).Within(0.005));
-
-            decreaseModSpeed();
-            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
-
-            decreaseModSpeed();
-            AddAssert("daycore activated at 0.95x", () => songSelect!.Mods.Value.OfType<ModDaycore>().Single().SpeedChange.Value, () => Is.EqualTo(0.95).Within(0.005));
-
-            decreaseModSpeed();
-            AddAssert("daycore activated at 0.95x", () => songSelect!.Mods.Value.OfType<ModDaycore>().Single().SpeedChange.Value, () => Is.EqualTo(0.9).Within(0.005));
-
-            increaseModSpeed();
-            AddAssert("daycore activated at 0.95x", () => songSelect!.Mods.Value.OfType<ModDaycore>().Single().SpeedChange.Value, () => Is.EqualTo(0.95).Within(0.005));
-
-            OsuModDoubleTime dt = new OsuModDoubleTime
-            {
-                SpeedChange = { Value = 1.02 },
-                AdjustPitch = { Value = true },
-            };
-            changeMods(dt);
-
-            decreaseModSpeed();
-            AddAssert("half time activated at 0.97x", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().SpeedChange.Value, () => Is.EqualTo(0.97).Within(0.005));
-            AddAssert("adjust pitch preserved", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().AdjustPitch.Value, () => Is.True);
-
-            OsuModHalfTime ht = new OsuModHalfTime
-            {
-                SpeedChange = { Value = 0.97 },
-                AdjustPitch = { Value = true },
-            };
-            Mod[] modlist = { ht, new OsuModHardRock(), new OsuModHidden() };
-            changeMods(modlist);
-
-            increaseModSpeed();
-            AddAssert("double time activated at 1.02x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().SpeedChange.Value, () => Is.EqualTo(1.02).Within(0.005));
-            AddAssert("double time activated at 1.02x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().AdjustPitch.Value, () => Is.True);
-            AddAssert("HD still enabled", () => songSelect!.Mods.Value.OfType<ModHidden>().SingleOrDefault(), () => Is.Not.Null);
-            AddAssert("HR still enabled", () => songSelect!.Mods.Value.OfType<ModHardRock>().SingleOrDefault(), () => Is.Not.Null);
-
-            changeMods(new ModWindUp());
-            increaseModSpeed();
-            AddAssert("windup still active", () => songSelect!.Mods.Value.First() is ModWindUp);
-
-            changeMods(new ModAdaptiveSpeed());
-            increaseModSpeed();
-            AddAssert("adaptive speed still active", () => songSelect!.Mods.Value.First() is ModAdaptiveSpeed);
-
-            OsuModDoubleTime dtWithAdjustPitch = new OsuModDoubleTime
-            {
-                SpeedChange = { Value = 1.05 },
-                AdjustPitch = { Value = true },
-            };
-            changeMods(dtWithAdjustPitch);
-
-            decreaseModSpeed();
-            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
-
-            decreaseModSpeed();
-            AddAssert("half time activated at 0.95x", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().SpeedChange.Value, () => Is.EqualTo(0.95).Within(0.005));
-            AddAssert("half time has adjust pitch active", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().AdjustPitch.Value, () => Is.True);
-
-            AddStep("turn off adjust pitch", () => songSelect!.Mods.Value.OfType<ModHalfTime>().Single().AdjustPitch.Value = false);
-
-            increaseModSpeed();
-            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
-
-            increaseModSpeed();
-            AddAssert("double time activated at 1.05x", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().SpeedChange.Value, () => Is.EqualTo(1.05).Within(0.005));
-            AddAssert("double time has adjust pitch inactive", () => songSelect!.Mods.Value.OfType<ModDoubleTime>().Single().AdjustPitch.Value, () => Is.False);
-
-            void increaseModSpeed() => AddStep("increase mod speed", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Up);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
-
-            void decreaseModSpeed() => AddStep("decrease mod speed", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Down);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
-        }
-
-        [Test]
-        public void TestPlaceholderBeatmapPresence()
-        {
-            createSongSelect();
-
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
-
-            addRulesetImportStep(0);
-            AddUntilStep("wait for placeholder hidden", () => getPlaceholder()?.State.Value == Visibility.Hidden);
-
-            AddStep("delete all beatmaps", () => manager.Delete());
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
-        }
-
-        [Test]
-        public void TestPlaceholderStarDifficulty()
-        {
-            addRulesetImportStep(0);
-            AddStep("change star filter", () => config.SetValue(OsuSetting.DisplayStarsMinimum, 10.0));
-
-            createSongSelect();
-
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
-
-            AddStep("click link in placeholder", () => getPlaceholder().ChildrenOfType<DrawableLinkCompiler>().First().TriggerClick());
-
-            AddUntilStep("star filter reset", () => config.Get<double>(OsuSetting.DisplayStarsMinimum) == 0.0);
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestPlaceholderConvertSetting()
-        {
-            addRulesetImportStep(0);
-            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
-
-            createSongSelect();
-
-            changeRuleset(2);
-
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
-
-            AddStep("click link in placeholder", () => getPlaceholder().ChildrenOfType<DrawableLinkCompiler>().First().TriggerClick());
-
-            AddUntilStep("convert setting changed", () => config.Get<bool>(OsuSetting.ShowConvertedBeatmaps));
-            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestSingleFilterOnEnter()
-        {
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddAssert("filter count is 0", () => songSelect?.FilterCount, () => Is.EqualTo(0));
-        }
-
-        [Test]
-        public void TestChangeBeatmapBeforeEnter()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            waitForInitialSelection();
-
-            WorkingBeatmap? selected = null;
-
-            AddStep("store selected beatmap", () => selected = Beatmap.Value);
-
-            AddStep("select next and enter", () =>
-            {
-                InputManager.Key(Key.Down);
-                InputManager.Key(Key.Enter);
-            });
-
-            waitForDismissed();
-            AddAssert("ensure selection changed", () => selected != Beatmap.Value);
-        }
-
-        [Test]
-        public void TestChangeBeatmapAfterEnter()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            waitForInitialSelection();
-
-            WorkingBeatmap? selected = null;
-
-            AddStep("store selected beatmap", () => selected = Beatmap.Value);
-
-            AddStep("select next and enter", () =>
-            {
-                InputManager.Key(Key.Enter);
-                InputManager.Key(Key.Down);
-            });
-
-            waitForDismissed();
-            AddAssert("ensure selection didn't change", () => selected == Beatmap.Value);
-        }
-
-        [Test]
-        public void TestChangeBeatmapViaMouseBeforeEnter()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
-
-            WorkingBeatmap? selected = null;
-
-            AddStep("store selected beatmap", () => selected = Beatmap.Value);
-
-            AddUntilStep("wait for beatmaps to load", () => songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
-
-            AddStep("select next and enter", () =>
-            {
-                InputManager.MoveMouseTo(songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
-                                                    .First(b => !((CarouselBeatmap)b.Item!).BeatmapInfo.Equals(songSelect!.Carousel.SelectedBeatmapInfo)));
-
-                InputManager.Click(MouseButton.Left);
-
-                InputManager.Key(Key.Enter);
-            });
-
-            waitForDismissed();
-            AddAssert("ensure selection changed", () => selected != Beatmap.Value);
-        }
-
-        [Test]
-        public void TestChangeBeatmapViaMouseAfterEnter()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            waitForInitialSelection();
-
-            WorkingBeatmap? selected = null;
-
-            AddStep("store selected beatmap", () => selected = Beatmap.Value);
-
-            AddStep("select next and enter", () =>
-            {
-                InputManager.MoveMouseTo(songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>()
-                                                    .First(b => !((CarouselBeatmap)b.Item!).BeatmapInfo.Equals(songSelect!.Carousel.SelectedBeatmapInfo)));
-
-                InputManager.PressButton(MouseButton.Left);
-
-                InputManager.Key(Key.Enter);
-
-                InputManager.ReleaseButton(MouseButton.Left);
-            });
-
-            waitForDismissed();
-            AddAssert("ensure selection didn't change", () => selected == Beatmap.Value);
-        }
-
-        [Test]
-        public void TestNoFilterOnSimpleResume()
-        {
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            waitForDismissed();
-
-            AddStep("return", () => songSelect!.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
-            AddAssert("filter count is 0", () => songSelect!.FilterCount, () => Is.EqualTo(0));
-        }
-
-        [Test]
-        public void TestFilterOnResumeAfterChange()
-        {
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-
-            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
-
-            createSongSelect();
-
-            AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            waitForDismissed();
-
-            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
-
-            AddStep("return", () => songSelect!.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
-            AddAssert("filter count is 1", () => songSelect!.FilterCount, () => Is.EqualTo(1));
-        }
-
-        [Test]
-        public void TestCarouselSelectionUpdatesOnResume()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
-            waitForDismissed();
-
-            AddStep("update beatmap", () =>
-            {
-                var selectedBeatmap = Beatmap.Value.BeatmapInfo;
-                var anotherBeatmap = Beatmap.Value.BeatmapSetInfo.Beatmaps.Except(selectedBeatmap.Yield()).First();
-                Beatmap.Value = manager.GetWorkingBeatmap(anotherBeatmap);
-            });
-
-            AddStep("return", () => songSelect!.MakeCurrent());
-            AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
-            AddAssert("carousel updated", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(Beatmap.Value.BeatmapInfo) == true);
-        }
-
-        [Test]
-        public void TestAudioResuming()
-        {
-            createSongSelect();
-
-            // We need to use one real beatmap to trigger the "same-track-transfer" logic that we're looking to test here.
-            // See `SongSelect.ensurePlayingSelected` and `WorkingBeatmap.TryTransferTrack`.
-            AddStep("import test beatmap", () => manager.Import(new ImportTask(TestResources.GetTestBeatmapForImport())).WaitSafely());
-            addRulesetImportStep(0);
-
-            checkMusicPlaying(true);
-            AddStep("select first", () => songSelect!.Carousel.SelectBeatmap(songSelect!.Carousel.BeatmapSets.First().Beatmaps.First()));
-            checkMusicPlaying(true);
-
-            AddStep("manual pause", () => music.TogglePause());
-            checkMusicPlaying(false);
-
-            // Track should not have changed, so music should still not be playing.
-            AddStep("select next difficulty", () => songSelect!.Carousel.SelectNext(skipDifficulties: false));
-            checkMusicPlaying(false);
-
-            AddStep("select next set", () => songSelect!.Carousel.SelectNext());
-            checkMusicPlaying(true);
-        }
-
-        [TestCase(false)]
-        [TestCase(true)]
-        public void TestAudioRemainsCorrectOnRulesetChange(bool rulesetsInSameBeatmap)
-        {
-            createSongSelect();
-
-            // start with non-osu! to avoid convert confusion
-            changeRuleset(1);
-
-            if (rulesetsInSameBeatmap)
-            {
-                AddStep("import multi-ruleset map", () =>
-                {
-                    var usableRulesets = rulesets.AvailableRulesets.Where(r => r.OnlineID != 2).ToArray();
-                    manager.Import(TestResources.CreateTestBeatmapSetInfo(rulesets: usableRulesets));
-                });
-            }
-            else
-            {
-                addRulesetImportStep(1);
-                addRulesetImportStep(0);
-            }
-
-            checkMusicPlaying(true);
-
-            AddStep("manual pause", () => music.TogglePause());
-            checkMusicPlaying(false);
-
-            changeRuleset(0);
-            checkMusicPlaying(!rulesetsInSameBeatmap);
-        }
-
-        [Test]
-        public void TestDummy()
-        {
-            createSongSelect();
-            AddUntilStep("dummy selected", () => songSelect!.CurrentBeatmap == defaultBeatmap);
-
-            AddUntilStep("dummy shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
-
-            addManyTestMaps();
-
-            AddUntilStep("random map selected", () => songSelect!.CurrentBeatmap != defaultBeatmap);
-        }
-
-        [Test]
-        public void TestSorting()
-        {
-            createSongSelect();
-            addManyTestMaps();
-
-            AddUntilStep("random map selected", () => songSelect!.CurrentBeatmap != 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));
-        }
-
-        [Test]
-        public void TestImportUnderDifferentRuleset()
-        {
-            createSongSelect();
-            addRulesetImportStep(2);
-            AddUntilStep("no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-        }
-
-        [Test]
-        public void TestImportUnderCurrentRuleset()
-        {
-            createSongSelect();
-            changeRuleset(2);
-            addRulesetImportStep(2);
-            addRulesetImportStep(1);
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
-
-            changeRuleset(1);
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 1);
-
-            changeRuleset(0);
-            AddUntilStep("no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-        }
-
-        [Test]
-        [Ignore("temporary while peppy investigates. probably realm batching related.")]
-        public void TestSelectionRetainedOnBeatmapUpdate()
-        {
-            createSongSelect();
-            changeRuleset(0);
-
-            Live<BeatmapSetInfo>? original = null;
-            int originalOnlineSetID = 0;
-
-            AddStep(@"Sort by artist", () => config.SetValue(OsuSetting.SongSelectSortingMode, SortMode.Artist));
-
-            AddStep("import original", () =>
-            {
-                original = manager.Import(new ImportTask(TestResources.GetQuickTestBeatmapForImport())).GetResultSafely();
-
-                Debug.Assert(original != null);
-
-                originalOnlineSetID = original.Value.OnlineID;
-            });
-
-            // This will move the beatmap set to a different location in the carousel.
-            AddStep("Update original with bogus info", () =>
-            {
-                Debug.Assert(original != null);
-
-                original.PerformWrite(set =>
-                {
-                    foreach (var beatmap in set.Beatmaps)
-                    {
-                        beatmap.Metadata.Artist = "ZZZZZ";
-                        beatmap.OnlineID = 12804;
-                    }
-                });
-            });
-
-            AddRepeatStep("import other beatmaps", () =>
-            {
-                var testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo();
-
-                foreach (var beatmap in testBeatmapSetInfo.Beatmaps)
-                    beatmap.Metadata.Artist = ((char)RNG.Next('A', 'Z')).ToString();
-
-                manager.Import(testBeatmapSetInfo);
-            }, 10);
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID, () => Is.EqualTo(originalOnlineSetID));
-
-            Task<Live<BeatmapSetInfo>?> updateTask = null!;
-
-            AddStep("update beatmap", () =>
-            {
-                Debug.Assert(original != null);
-
-                updateTask = manager.ImportAsUpdate(new ProgressNotification(), new ImportTask(TestResources.GetQuickTestBeatmapForImport()), original.Value);
-            });
-            AddUntilStep("wait for update completion", () => updateTask.IsCompleted);
-
-            AddUntilStep("retained selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID, () => Is.EqualTo(originalOnlineSetID));
-        }
-
-        [Test]
-        public void TestPresentNewRulesetNewBeatmap()
-        {
-            createSongSelect();
-            changeRuleset(2);
-
-            addRulesetImportStep(2);
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
-
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-
-            BeatmapInfo? target = null;
-
-            AddStep("select beatmap/ruleset externally", () =>
-            {
-                target = manager.GetAllUsableBeatmapSets()
-                                .Last(b => b.Beatmaps.Any(bi => bi.Ruleset.OnlineID == 0)).Beatmaps.Last();
-
-                Ruleset.Value = rulesets.AvailableRulesets.First(r => r.OnlineID == 0);
-                Beatmap.Value = manager.GetWorkingBeatmap(target);
-            });
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(target) == true);
-
-            // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
-        }
-
-        [Test]
-        public void TestPresentNewBeatmapNewRuleset()
-        {
-            createSongSelect();
-            changeRuleset(2);
-
-            addRulesetImportStep(2);
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 2);
-
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-            addRulesetImportStep(0);
-
-            BeatmapInfo? target = null;
-
-            AddStep("select beatmap/ruleset externally", () =>
-            {
-                target = manager.GetAllUsableBeatmapSets()
-                                .Last(b => b.Beatmaps.Any(bi => bi.Ruleset.OnlineID == 0)).Beatmaps.Last();
-
-                Beatmap.Value = manager.GetWorkingBeatmap(target);
-                Ruleset.Value = rulesets.AvailableRulesets.First(r => r.OnlineID == 0);
-            });
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(target) == true);
-
-            AddUntilStep("has correct ruleset", () => Ruleset.Value.OnlineID == 0);
-
-            // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect!.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
-        }
-
-        [Test]
-        public void TestModsRetainedBetweenSongSelect()
-        {
-            AddAssert("empty mods", () => !SelectedMods.Value.Any());
-
-            createSongSelect();
-
-            addRulesetImportStep(0);
-
-            changeMods(new OsuModHardRock());
-
-            createSongSelect();
-
-            AddAssert("mods retained", () => SelectedMods.Value.Any());
-        }
-
-        [Test]
-        public void TestStartAfterUnMatchingFilterDoesNotStart()
-        {
-            createSongSelect();
-            addManyTestMaps();
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            bool startRequested = false;
-
-            AddStep("set filter and finalize", () =>
-            {
-                songSelect!.StartRequested = () => startRequested = true;
-
-                songSelect!.Carousel.Filter(new FilterCriteria { SearchText = "somestringthatshouldn'tbematchable" });
-                songSelect!.FinaliseSelection();
-
-                songSelect!.StartRequested = null;
-            });
-
-            AddAssert("start not requested", () => !startRequested);
-        }
-
-        [Test]
-        public void TestSearchTextWithRulesetCriteria()
-        {
-            createSongSelect();
-
-            addRulesetImportStep(0);
-
-            AddStep("disallow convert display", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            AddStep("set filter to match all", () => songSelect!.FilterControl.CurrentTextSearch.Value = "Some");
-
-            changeRuleset(1);
-
-            AddUntilStep("has no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-        }
-
-        [TestCase(false)]
-        [TestCase(true)]
-        public void TestExternalBeatmapChangeWhileFiltered(bool differentRuleset)
-        {
-            createSongSelect();
-            // ensure there is at least 1 difficulty for each of the rulesets
-            // (catch is excluded inside of addManyTestMaps).
-            addManyTestMaps(3);
-
-            changeRuleset(0);
-
-            // used for filter check below
-            AddStep("allow convert display", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text = "nonono");
-
-            AddUntilStep("dummy selected", () => Beatmap.Value is DummyWorkingBeatmap);
-
-            AddUntilStep("has no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-
-            BeatmapInfo? target = null;
-
-            int targetRuleset = differentRuleset ? 1 : 0;
-
-            AddStep("select beatmap externally", () =>
-            {
-                target = manager.GetAllUsableBeatmapSets()
-                                .First(b => b.Beatmaps.Any(bi => bi.Ruleset.OnlineID == targetRuleset))
-                                .Beatmaps
-                                .First(bi => bi.Ruleset.OnlineID == targetRuleset);
-
-                Beatmap.Value = manager.GetWorkingBeatmap(target);
-            });
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            AddAssert("selected only shows expected ruleset (plus converts)", () =>
-            {
-                var selectedPanel = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First(s => s.Item!.State.Value == CarouselItemState.Selected);
-
-                // special case for converts checked here.
-                return selectedPanel.ChildrenOfType<FilterableDifficultyIcon>().All(i =>
-                    i.IsFiltered || i.Item.BeatmapInfo.Ruleset.OnlineID == targetRuleset || i.Item.BeatmapInfo.Ruleset.OnlineID == 0);
-            });
-
-            AddUntilStep("carousel has correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
-            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
-
-            AddStep("reset filter text", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text = string.Empty);
-
-            AddAssert("game still correct", () => Beatmap.Value?.BeatmapInfo.MatchesOnlineID(target) == true);
-            AddAssert("carousel still correct", () => songSelect!.Carousel.SelectedBeatmapInfo.MatchesOnlineID(target));
-        }
-
-        [Test]
-        public void TestExternalBeatmapChangeWhileFilteredThenRefilter()
-        {
-            createSongSelect();
-            // ensure there is at least 1 difficulty for each of the rulesets
-            // (catch is excluded inside of addManyTestMaps).
-            addManyTestMaps(3);
-
-            changeRuleset(0);
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text = "nonono");
-
-            AddUntilStep("dummy selected", () => Beatmap.Value is DummyWorkingBeatmap);
-
-            AddUntilStep("has no selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-
-            BeatmapInfo? target = null;
-
-            AddStep("select beatmap externally", () =>
-            {
-                target = manager
-                         .GetAllUsableBeatmapSets()
-                         .First(b => b.Beatmaps.Any(bi => bi.Ruleset.OnlineID == 1))
-                         .Beatmaps.First();
-
-                Beatmap.Value = manager.GetWorkingBeatmap(target);
-            });
-
-            AddUntilStep("has selection", () => songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            AddUntilStep("carousel has correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
-            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
-
-            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text = "nononoo");
-
-            AddUntilStep("game lost selection", () => Beatmap.Value is DummyWorkingBeatmap);
-            AddAssert("carousel lost selection", () => songSelect!.Carousel.SelectedBeatmapInfo == null);
-        }
-
-        [Test]
-        public void TestAutoplayShortcut()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            AddStep("press ctrl+enter", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Enter);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
-
-            AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
-
-            AddAssert("autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
-
-            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
-
-            AddAssert("no mods selected", () => songSelect!.Mods.Value.Count == 0);
-        }
-
-        [Test]
-        public void TestAutoplayShortcutKeepsAutoplayIfSelectedAlready()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            changeMods(new OsuModAutoplay());
-
-            AddStep("press ctrl+enter", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Enter);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
-
-            AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
-
-            AddAssert("autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
-
-            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
-
-            AddAssert("autoplay still selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
-        }
-
-        [Test]
-        public void TestAutoplayShortcutReturnsInitialModsOnExit()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            changeMods(new OsuModRelax());
-
-            AddStep("press ctrl+enter", () =>
-            {
-                InputManager.PressKey(Key.ControlLeft);
-                InputManager.Key(Key.Enter);
-                InputManager.ReleaseKey(Key.ControlLeft);
-            });
-
-            AddUntilStep("wait for player", () => Stack.CurrentScreen is PlayerLoader);
-
-            AddAssert("only autoplay selected", () => songSelect!.Mods.Value.Single() is ModAutoplay);
-
-            AddUntilStep("wait for return to ss", () => songSelect!.IsCurrentScreen());
-
-            AddAssert("relax returned", () => songSelect!.Mods.Value.Single() is ModRelax);
-        }
-
-        [Test]
-        public void TestHideSetSelectsCorrectBeatmap()
-        {
-            Guid? previousID = null;
-            createSongSelect();
-            addRulesetImportStep(0);
-            AddStep("Move to last difficulty", () => songSelect!.Carousel.SelectBeatmap(songSelect!.Carousel.BeatmapSets.First().Beatmaps.Last()));
-            AddStep("Store current ID", () => previousID = songSelect!.Carousel.SelectedBeatmapInfo!.ID);
-            AddStep("Hide first beatmap", () => manager.Hide(songSelect!.Carousel.SelectedBeatmapSet!.Beatmaps.First()));
-            AddAssert("Selected beatmap has not changed", () => songSelect!.Carousel.SelectedBeatmapInfo?.ID == previousID);
-        }
-
-        [Test]
-        public void TestDifficultyIconSelecting()
-        {
-            addRulesetImportStep(0);
-            createSongSelect();
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            DrawableCarouselBeatmapSet set = null!;
-            AddStep("Find the DrawableCarouselBeatmapSet", () =>
-            {
-                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().First();
-            });
-
-            FilterableDifficultyIcon difficultyIcon = null!;
-
-            AddUntilStep("Find an icon", () =>
-            {
-                var foundIcon = set.ChildrenOfType<FilterableDifficultyIcon>()
-                                   .FirstOrDefault(icon => getDifficultyIconIndex(set, icon) != getCurrentBeatmapIndex());
-
-                if (foundIcon == null)
-                    return false;
-
-                difficultyIcon = foundIcon;
-                return true;
-            });
-
-            AddStep("Click on a difficulty", () =>
-            {
-                InputManager.MoveMouseTo(difficultyIcon);
-
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddAssert("Selected beatmap correct", () => getCurrentBeatmapIndex() == getDifficultyIconIndex(set, difficultyIcon));
-
-            double? maxBPM = null;
-            AddStep("Filter some difficulties", () => songSelect!.Carousel.Filter(new FilterCriteria
-            {
-                BPM = new FilterCriteria.OptionalRange<double>
-                {
-                    Min = maxBPM = songSelect!.Carousel.SelectedBeatmapSet!.MaxBPM,
-                    IsLowerInclusive = true
-                }
-            }));
-
-            BeatmapInfo? filteredBeatmap = null;
-            FilterableDifficultyIcon? filteredIcon = null;
-
-            AddStep("Get filtered icon", () =>
-            {
-                var selectedSet = songSelect!.Carousel.SelectedBeatmapSet;
-
-                Debug.Assert(selectedSet != null);
-
-                filteredBeatmap = selectedSet.Beatmaps.First(b => b.BPM < maxBPM);
-                int filteredBeatmapIndex = getBeatmapIndex(selectedSet, filteredBeatmap);
-                filteredIcon = set.ChildrenOfType<FilterableDifficultyIcon>().ElementAt(filteredBeatmapIndex);
-            });
-
-            AddStep("Click on a filtered difficulty", () =>
-            {
-                Debug.Assert(filteredIcon != null);
-
-                InputManager.MoveMouseTo(filteredIcon);
-
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddAssert("Selected beatmap correct", () => songSelect!.Carousel.SelectedBeatmapInfo?.Equals(filteredBeatmap) == true);
-        }
-
-        [Test]
-        public void TestChangingRulesetOnMultiRulesetBeatmap()
-        {
-            int changeCount = 0;
-
-            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
-            AddStep("bind beatmap changed", () =>
-            {
-                Beatmap.ValueChanged += onChange;
-                changeCount = 0;
-            });
-
-            changeRuleset(0);
-
-            createSongSelect();
-
-            AddStep("import multi-ruleset map", () =>
-            {
-                var usableRulesets = rulesets.AvailableRulesets.Where(r => r.OnlineID != 2).ToArray();
-                manager.Import(TestResources.CreateTestBeatmapSetInfo(3, usableRulesets));
-            });
-
-            int previousSetID = 0;
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            AddStep("record set ID", () => previousSetID = ((IBeatmapSetInfo)Beatmap.Value.BeatmapSetInfo).OnlineID);
-            AddAssert("selection changed once", () => changeCount == 1);
-
-            AddAssert("Check ruleset is osu!", () => Ruleset.Value.OnlineID == 0);
-
-            changeRuleset(3);
-
-            AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.OnlineID == 3);
-
-            AddUntilStep("selection changed", () => changeCount > 1);
-
-            AddAssert("Selected beatmap still same set", () => Beatmap.Value.BeatmapSetInfo.OnlineID == previousSetID);
-            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3);
-
-            AddAssert("selection changed only fired twice", () => changeCount == 2);
-
-            AddStep("unbind beatmap changed", () => Beatmap.ValueChanged -= onChange);
-            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, true));
-
-            // ReSharper disable once AccessToModifiedClosure
-            void onChange(ValueChangedEvent<WorkingBeatmap> valueChangedEvent) => changeCount++;
-        }
-
-        [Test]
-        public void TestDifficultyIconSelectingForDifferentRuleset()
-        {
-            changeRuleset(0);
-
-            createSongSelect();
-
-            AddStep("import multi-ruleset map", () =>
-            {
-                var usableRulesets = rulesets.AvailableRulesets.Where(r => r.OnlineID != 2).ToArray();
-                manager.Import(TestResources.CreateTestBeatmapSetInfo(3, usableRulesets));
-            });
-
-            DrawableCarouselBeatmapSet? set = null;
-            AddUntilStep("Find the DrawableCarouselBeatmapSet", () =>
-            {
-                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
-                return set != null;
-            });
-
-            FilterableDifficultyIcon? difficultyIcon = null;
-            AddUntilStep("Find an icon for different ruleset", () =>
-            {
-                difficultyIcon = set.ChildrenOfType<FilterableDifficultyIcon>()
-                                    .FirstOrDefault(icon => icon.Item.BeatmapInfo.Ruleset.OnlineID == 3);
-                return difficultyIcon != null;
-            });
-
-            AddAssert("Check ruleset is osu!", () => Ruleset.Value.OnlineID == 0);
-
-            int previousSetID = 0;
-
-            AddStep("record set ID", () => previousSetID = ((IBeatmapSetInfo)Beatmap.Value.BeatmapSetInfo).OnlineID);
-
-            AddStep("Click on a difficulty", () =>
-            {
-                Debug.Assert(difficultyIcon != null);
-
-                InputManager.MoveMouseTo(difficultyIcon);
-
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.OnlineID == 3);
-
-            AddAssert("Selected beatmap still same set", () => songSelect!.Carousel.SelectedBeatmapInfo?.BeatmapSet?.OnlineID == previousSetID);
-            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3);
-        }
-
-        [Test]
-        public void TestGroupedDifficultyIconSelecting()
-        {
-            changeRuleset(0);
-
-            createSongSelect();
-
-            BeatmapSetInfo? imported = null;
-
-            AddStep("import huge difficulty count map", () =>
-            {
-                var usableRulesets = rulesets.AvailableRulesets.Where(r => r.OnlineID != 2).ToArray();
-                imported = manager.Import(TestResources.CreateTestBeatmapSetInfo(50, usableRulesets))?.Value;
-            });
-
-            AddStep("select the first beatmap of import", () => Beatmap.Value = manager.GetWorkingBeatmap(imported?.Beatmaps.First()));
-
-            DrawableCarouselBeatmapSet? set = null;
-            AddUntilStep("Find the DrawableCarouselBeatmapSet", () =>
-            {
-                set = songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().FirstOrDefault();
-                return set != null;
-            });
-
-            GroupedDifficultyIcon groupIcon = null!;
-
-            AddUntilStep("Find group icon for different ruleset", () =>
-            {
-                var foundIcon = set.ChildrenOfType<GroupedDifficultyIcon>()
-                                   .FirstOrDefault(icon => icon.Items.First().BeatmapInfo.Ruleset.OnlineID == 3);
-
-                if (foundIcon == null)
-                    return false;
-
-                groupIcon = foundIcon;
-                return true;
-            });
-
-            AddAssert("Check ruleset is osu!", () => Ruleset.Value.OnlineID == 0);
-
-            AddStep("Click on group", () =>
-            {
-                InputManager.MoveMouseTo(groupIcon);
-
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.OnlineID == 3);
-
-            AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(groupIcon.Items.First().BeatmapInfo));
-        }
-
-        [Test]
-        public void TestChangeRulesetWhilePresentingScore()
-        {
-            BeatmapInfo getPresentBeatmap() => manager.GetAllUsableBeatmapSets().Where(s => !s.DeletePending).SelectMany(s => s.Beatmaps).First(b => b.Ruleset.OnlineID == 0);
-            BeatmapInfo getSwitchBeatmap() => manager.GetAllUsableBeatmapSets().Where(s => !s.DeletePending).SelectMany(s => s.Beatmaps).First(b => b.Ruleset.OnlineID == 1);
-
-            changeRuleset(0);
-
-            createSongSelect();
-
-            addRulesetImportStep(0);
-            addRulesetImportStep(1);
-
-            AddStep("present score", () =>
-            {
-                // this ruleset change should be overridden by the present.
-                Ruleset.Value = getSwitchBeatmap().Ruleset;
-
-                songSelect!.PresentScore(new ScoreInfo
-                {
-                    User = new APIUser { Username = "woo" },
-                    BeatmapInfo = getPresentBeatmap(),
-                    Ruleset = getPresentBeatmap().Ruleset
-                });
-            });
-
-            waitForDismissed();
-
-            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
-            AddAssert("check ruleset is correct for score", () => Ruleset.Value.OnlineID == 0);
-        }
-
-        [Test]
-        public void TestChangeBeatmapWhilePresentingScore()
-        {
-            BeatmapInfo getPresentBeatmap() => manager.GetAllUsableBeatmapSets().Where(s => !s.DeletePending).SelectMany(s => s.Beatmaps).First(b => b.Ruleset.OnlineID == 0);
-            BeatmapInfo getSwitchBeatmap() => manager.GetAllUsableBeatmapSets().Where(s => !s.DeletePending).SelectMany(s => s.Beatmaps).First(b => b.Ruleset.OnlineID == 1);
-
-            changeRuleset(0);
-
-            addRulesetImportStep(0);
-            addRulesetImportStep(1);
-
-            createSongSelect();
-
-            AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
-
-            AddStep("present score", () =>
-            {
-                // this beatmap change should be overridden by the present.
-                Beatmap.Value = manager.GetWorkingBeatmap(getSwitchBeatmap());
-
-                songSelect!.PresentScore(TestResources.CreateTestScoreInfo(getPresentBeatmap()));
-            });
-
-            waitForDismissed();
-
-            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
-            AddAssert("check ruleset is correct for score", () => Ruleset.Value.OnlineID == 0);
-        }
-
-        [Test]
-        public void TestModOverlayToggling()
-        {
-            changeRuleset(0);
-            createSongSelect();
-
-            AddStep("toggle mod overlay on", () => InputManager.Key(Key.F1));
-            AddUntilStep("mod overlay shown", () => songSelect!.ModSelect.State.Value == Visibility.Visible);
-
-            AddStep("toggle mod overlay off", () => InputManager.Key(Key.F1));
-            AddUntilStep("mod overlay hidden", () => songSelect!.ModSelect.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestBeatmapOptionsDisabled()
-        {
-            createSongSelect();
-
-            addRulesetImportStep(0);
-
-            AddAssert("options enabled", () => songSelect.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
-            AddStep("delete all beatmaps", () => manager.Delete());
-            AddUntilStep("wait for no beatmap", () => Beatmap.IsDefault);
-            AddAssert("options disabled", () => !songSelect.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
-        }
-
-        [Test]
-        public void TestTextBoxBeatmapDifficultyCount()
-        {
-            createSongSelect();
-
-            AddAssert("0 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "0 matches");
-
-            addRulesetImportStep(0);
-
-            AddAssert("3 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "3 matches");
-            AddStep("delete all beatmaps", () => manager.Delete());
-            AddUntilStep("wait for no beatmap", () => Beatmap.IsDefault);
-            AddAssert("0 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "0 matches");
-        }
-
-        [Test]
-        public void TestHardDeleteHandledCorrectly()
-        {
-            createSongSelect();
-
-            addRulesetImportStep(0);
-            AddAssert("3 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "3 matches");
-
-            AddStep("hard delete beatmap", () => Realm.Write(r => r.RemoveRange(r.All<BeatmapSetInfo>().Where(s => !s.Protected))));
-
-            AddUntilStep("0 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "0 matches");
-        }
-
-        [Test]
-        public void TestDeleteHotkey()
-        {
-            createSongSelect();
-
-            addRulesetImportStep(0);
-            AddAssert("3 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "3 matches");
-
-            AddStep("press shift-delete", () =>
-            {
-                InputManager.PressKey(Key.ShiftLeft);
-                InputManager.Key(Key.Delete);
-                InputManager.ReleaseKey(Key.ShiftLeft);
-            });
-            AddUntilStep("delete dialog shown", () => DialogOverlay.CurrentDialog, Is.InstanceOf<BeatmapDeleteDialog>);
-            AddStep("confirm deletion", () => DialogOverlay.CurrentDialog!.PerformAction<PopupDialogDangerousButton>());
-            AddAssert("0 matching shown", () => songSelect.ChildrenOfType<FilterControl>().Single().InformationalText == "0 matches");
-        }
-
-        [Test]
-        public void TestCutInFilterTextBox()
-        {
-            createSongSelect();
-
-            AddStep("set filter text", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text = "nonono");
-            AddStep("select all", () => InputManager.Keys(PlatformAction.SelectAll));
-            AddStep("press ctrl/cmd-x", () => InputManager.Keys(PlatformAction.Cut));
-
-            AddAssert("filter text cleared", () => songSelect!.FilterControl.ChildrenOfType<FilterControl.FilterControlTextBox>().First().Text, () => Is.Empty);
-        }
-
-        [Test]
-        public void TestNonFilterableModChange()
-        {
-            addRulesetImportStep(0);
-
-            createSongSelect();
-
-            // Mod that is guaranteed to never re-filter.
-            AddStep("add non-filterable mod", () => SelectedMods.Value = new Mod[] { new OsuModCinema() });
-            AddAssert("filter count is 0", () => songSelect!.FilterCount, () => Is.EqualTo(0));
-
-            // Removing the mod should still not re-filter.
-            AddStep("remove non-filterable mod", () => SelectedMods.Value = Array.Empty<Mod>());
-            AddAssert("filter count is 0", () => songSelect!.FilterCount, () => Is.EqualTo(0));
-        }
-
-        [Test]
-        public void TestFilterableModChange()
-        {
-            addRulesetImportStep(3);
-
-            createSongSelect();
-
-            // Change to mania ruleset.
-            AddStep("filter to mania ruleset", () => Ruleset.Value = rulesets.AvailableRulesets.First(r => r.OnlineID == 3));
-            AddAssert("filter count is 2", () => songSelect!.FilterCount, () => Is.EqualTo(1));
-
-            // Apply a mod, but this should NOT re-filter because there's no search text.
-            AddStep("add filterable mod", () => SelectedMods.Value = new Mod[] { new ManiaModKey3() });
-            AddAssert("filter count is 1", () => songSelect!.FilterCount, () => Is.EqualTo(1));
-
-            // Set search text. Should re-filter.
-            AddStep("set search text to match mods", () => songSelect!.FilterControl.CurrentTextSearch.Value = "keys=3");
-            AddAssert("filter count is 2", () => songSelect!.FilterCount, () => Is.EqualTo(2));
-
-            // Change filterable mod. Should re-filter.
-            AddStep("change new filterable mod", () => SelectedMods.Value = new Mod[] { new ManiaModKey5() });
-            AddAssert("filter count is 3", () => songSelect!.FilterCount, () => Is.EqualTo(3));
-
-            // Add non-filterable mod. Should NOT re-filter.
-            AddStep("apply non-filterable mod", () => SelectedMods.Value = new Mod[] { new ManiaModNoFail(), new ManiaModKey5() });
-            AddAssert("filter count is 3", () => songSelect!.FilterCount, () => Is.EqualTo(3));
-
-            // Remove filterable mod. Should re-filter.
-            AddStep("remove filterable mod", () => SelectedMods.Value = new Mod[] { new ManiaModNoFail() });
-            AddAssert("filter count is 4", () => songSelect!.FilterCount, () => Is.EqualTo(4));
-
-            // Remove non-filterable mod. Should NOT re-filter.
-            AddStep("remove filterable mod", () => SelectedMods.Value = Array.Empty<Mod>());
-            AddAssert("filter count is 4", () => songSelect!.FilterCount, () => Is.EqualTo(4));
-
-            // Add filterable mod. Should re-filter.
-            AddStep("add filterable mod", () => SelectedMods.Value = new Mod[] { new ManiaModKey3() });
-            AddAssert("filter count is 5", () => songSelect!.FilterCount, () => Is.EqualTo(5));
-        }
-
-        private void waitForInitialSelection()
-        {
-            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
-            AddUntilStep("wait for difficulty panels visible", () => songSelect!.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
-        }
-
-        private int getBeatmapIndex(BeatmapSetInfo set, BeatmapInfo info) => set.Beatmaps.IndexOf(info);
-
-        private NoResultsPlaceholder? getPlaceholder() => songSelect!.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
-
-        private int getCurrentBeatmapIndex()
-        {
-            Debug.Assert(songSelect!.Carousel.SelectedBeatmapSet != null);
-            Debug.Assert(songSelect!.Carousel.SelectedBeatmapInfo != null);
-
-            return getBeatmapIndex(songSelect!.Carousel.SelectedBeatmapSet, songSelect!.Carousel.SelectedBeatmapInfo);
-        }
-
-        private int getDifficultyIconIndex(DrawableCarouselBeatmapSet set, FilterableDifficultyIcon icon)
-        {
-            return set.ChildrenOfType<FilterableDifficultyIcon>().ToList().FindIndex(i => i == icon);
-        }
-
-        private void addRulesetImportStep(int id)
-        {
-            Live<BeatmapSetInfo>? imported = null;
-            AddStep($"import test map for ruleset {id}", () => imported = importForRuleset(id));
-            // This is specifically for cases where the add is happening post song select load.
-            // For cases where song select is null, the assertions are provided by the load checks.
-            AddUntilStep("wait for imported to arrive in carousel", () => songSelect == null || songSelect!.Carousel.BeatmapSets.Any(s => s.ID == imported?.ID));
-        }
-
-        private Live<BeatmapSetInfo>? importForRuleset(int id) => manager.Import(TestResources.CreateTestBeatmapSetInfo(3, rulesets.AvailableRulesets.Where(r => r.OnlineID == id).ToArray()));
-
-        private void checkMusicPlaying(bool playing) =>
-            AddUntilStep($"music {(playing ? "" : "not ")}playing", () => music.IsPlaying == playing);
-
-        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.Acronym))}", () => SelectedMods.Value = mods);
-
-        private void changeRuleset(int id) => AddStep($"change ruleset to {id}", () => Ruleset.Value = rulesets.AvailableRulesets.First(r => r.OnlineID == id));
-
-        private void createSongSelect()
-        {
-            AddStep("create song select", () => LoadScreen(songSelect = new TestSongSelect()));
-            AddUntilStep("wait for present", () => songSelect!.IsCurrentScreen());
-            AddUntilStep("wait for carousel loaded", () => songSelect!.Carousel.IsAlive);
-        }
-
-        /// <summary>
-        /// Imports test beatmap sets to show in the carousel.
-        /// </summary>
-        /// <param name="difficultyCountPerSet">
-        /// The exact count of difficulties to create for each beatmap set.
-        /// A <see langword="null"/> value causes the count of difficulties to be selected randomly.
-        /// </param>
-        private void addManyTestMaps(int? difficultyCountPerSet = null)
-        {
-            AddStep("import test maps", () =>
-            {
-                var usableRulesets = rulesets.AvailableRulesets.Where(r => r.OnlineID != 2).ToArray();
-
-                for (int i = 0; i < 10; i++)
-                    manager.Import(TestResources.CreateTestBeatmapSetInfo(difficultyCountPerSet, usableRulesets));
-            });
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (rulesets.IsNotNull())
-                rulesets.Dispose();
-        }
-
-        private void waitForDismissed() => AddUntilStep("wait for not current", () => !songSelect.AsNonNull().IsCurrentScreen());
-
-        private partial class TestSongSelect : PlaySongSelect
-        {
-            public Action? StartRequested;
-
-            public new FilterControl FilterControl => base.FilterControl;
-
-            public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
-            public IWorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
-            public new BeatmapCarousel Carousel => base.Carousel;
-            public new ModSelectOverlay ModSelect => base.ModSelect;
-
-            public new void PresentScore(ScoreInfo score) => base.PresentScore(score);
-
-            public int FilterCount;
-
-            protected override bool OnStart()
-            {
-                StartRequested?.Invoke();
-                return base.OnStart();
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                FilterControl.FilterChanged += _ => FilterCount++;
-            }
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
index 7f34d7a901..29b4955d02 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
@@ -263,8 +263,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             var results = await runGrouping(GroupMode.Difficulty, beatmapSets);
             assertGroup(results, 0, "Below 1 Star", new[] { beatmapBelow1 }, ref total);
-            assertGroup(results, 1, "1 Star", new[] { beatmapAbove1 }, ref total);
-            assertGroup(results, 2, "2 Stars", new[] { beatmapAlmost2, beatmap2, beatmapAbove2 }, 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);
             assertTotal(results, total);
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
index f58d879141..bc507fbffa 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
@@ -36,6 +36,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
     public abstract partial class BeatmapCarouselTestScene : OsuManualInputManagerTestScene
     {
         protected readonly Stack<BeatmapSetInfo> BeatmapSetRequestedSelections = new Stack<BeatmapSetInfo>();
+        protected readonly Stack<BeatmapInfo> BeatmapRequestedSelections = new Stack<BeatmapInfo>();
 
         protected readonly BindableList<BeatmapSetInfo> BeatmapSets = new BindableList<BeatmapSetInfo>();
 
@@ -73,6 +74,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddStep("create components", () =>
             {
+                BeatmapRequestedSelections.Clear();
                 BeatmapSetRequestedSelections.Clear();
                 BeatmapRecommendationFunction = null;
                 NewItemsPresentedInvocationCount = 0;
@@ -113,6 +115,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                                     NewItemsPresented = _ => NewItemsPresentedInvocationCount++,
                                     RequestSelection = b =>
                                     {
+                                        BeatmapRequestedSelections.Push(b);
                                         Carousel.CurrentSelection = b;
                                     },
                                     RequestRecommendedSelection = beatmaps =>
@@ -150,26 +153,25 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     },
                 };
 
-                Carousel.Filter(new FilterCriteria());
+                // Prefer title sorting so that order of carousel panels match order of BeatmapSets bindable.
+                Carousel.Filter(new FilterCriteria { Sort = SortMode.Title });
             });
-
-            // Prefer title sorting so that order of carousel panels match order of BeatmapSets bindable.
-            SortBy(SortMode.Title);
         }
 
-        protected void SortBy(SortMode mode) => ApplyToFilter($"sort by {mode.GetDescription().ToLowerInvariant()}", c => c.Sort = mode);
-        protected void GroupBy(GroupMode mode) => ApplyToFilter($"group by {mode.GetDescription().ToLowerInvariant()}", c => c.Group = mode);
+        protected void SortBy(SortMode mode) => ApplyToFilterAndWaitForFilter($"sort by {mode.GetDescription().ToLowerInvariant()}", c => c.Sort = mode);
+
+        protected void GroupBy(GroupMode mode) => ApplyToFilterAndWaitForFilter($"group by {mode.GetDescription().ToLowerInvariant()}", c => c.Group = mode);
 
         protected void SortAndGroupBy(SortMode sort, GroupMode group)
         {
-            ApplyToFilter($"sort by {sort.GetDescription().ToLowerInvariant()} & group by {group.GetDescription().ToLowerInvariant()}", c =>
+            ApplyToFilterAndWaitForFilter($"sort by {sort.GetDescription().ToLowerInvariant()} & group by {group.GetDescription().ToLowerInvariant()}", c =>
             {
                 c.Sort = sort;
                 c.Group = group;
             });
         }
 
-        protected void ApplyToFilter(string description, Action<FilterCriteria>? apply)
+        protected void ApplyToFilterAndWaitForFilter(string description, Action<FilterCriteria>? apply)
         {
             AddStep(description, () =>
             {
@@ -177,16 +179,39 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 apply?.Invoke(criteria);
                 Carousel.Filter(criteria);
             });
+
+            WaitForFiltering();
         }
 
         protected void WaitForDrawablePanels() => AddUntilStep("drawable panels loaded", () => Carousel.ChildrenOfType<ICarouselPanel>().Count(), () => Is.GreaterThan(0));
         protected void WaitForFiltering() => AddUntilStep("filtering finished", () => Carousel.IsFiltering, () => Is.False);
         protected void WaitForScrolling() => AddUntilStep("scroll finished", () => Scroll.Current, () => Is.EqualTo(Scroll.Target));
 
+        protected void ToggleGroupCollapse() => AddStep("toggle group collapse", () =>
+        {
+            InputManager.PressKey(Key.ShiftLeft);
+            InputManager.Key(Key.Enter);
+            InputManager.ReleaseKey(Key.ShiftLeft);
+        });
+
+        protected void SelectNextGroup() => AddStep("select next group", () =>
+        {
+            InputManager.PressKey(Key.ShiftLeft);
+            InputManager.Key(Key.Right);
+            InputManager.ReleaseKey(Key.ShiftLeft);
+        });
+
+        protected void SelectPrevGroup() => AddStep("select prev group", () =>
+        {
+            InputManager.PressKey(Key.ShiftLeft);
+            InputManager.Key(Key.Left);
+            InputManager.ReleaseKey(Key.ShiftLeft);
+        });
+
         protected void SelectNextPanel() => AddStep("select next panel", () => InputManager.Key(Key.Down));
         protected void SelectPrevPanel() => AddStep("select prev panel", () => InputManager.Key(Key.Up));
-        protected void SelectNextGroup() => AddStep("select next group", () => InputManager.Key(Key.Right));
-        protected void SelectPrevGroup() => AddStep("select prev group", () => InputManager.Key(Key.Left));
+        protected void SelectNextSet() => AddStep("select next set", () => InputManager.Key(Key.Right));
+        protected void SelectPrevSet() => AddStep("select prev set", () => InputManager.Key(Key.Left));
 
         protected void Select() => AddStep("select", () => InputManager.Key(Key.Enter));
 
@@ -228,33 +253,51 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         protected ICarouselPanel? GetSelectedPanel() => Carousel.ChildrenOfType<ICarouselPanel>().SingleOrDefault(p => p.Selected.Value);
         protected ICarouselPanel? GetKeyboardSelectedPanel() => Carousel.ChildrenOfType<ICarouselPanel>().SingleOrDefault(p => p.KeyboardSelected.Value);
 
-        protected void WaitForGroupSelection(int group, int panel)
+        protected void WaitForExpandedGroup(int group)
         {
-            AddUntilStep($"selected is group{group} panel{panel}", () =>
+            AddUntilStep($"group {group} is expanded", () =>
             {
                 var groupingFilter = Carousel.Filters.OfType<BeatmapCarouselFilterGrouping>().Single();
 
                 GroupDefinition g = groupingFilter.GroupItems.Keys.ElementAt(group);
                 // offset by one because the group itself is included in the items list.
-                CarouselItem item = groupingFilter.GroupItems[g].ElementAt(panel + 1);
+                CarouselItem item = groupingFilter.GroupItems[g].ElementAt(0);
+
+                return item.Model is GroupDefinition def && def == Carousel.ExpandedGroup;
+            });
+        }
+
+        protected void WaitForBeatmapSelection(int group, int panel)
+        {
+            AddUntilStep($"selected is group{group} panel{panel}", () =>
+            {
+                var groupingFilter = Carousel.Filters.OfType<BeatmapCarouselFilterGrouping>().Single();
+
+                GroupDefinition? groupDefinition = groupingFilter.GroupItems.Keys.ElementAtOrDefault(group);
+
+                if (groupDefinition == null)
+                    return false;
+
+                // 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;
             });
         }
 
-        protected void WaitForSelection(int set, int? diff = null)
+        protected void WaitForSetSelection(int set, int? diff = null)
         {
-            AddUntilStep($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
+            if (diff != null)
             {
-                if (diff != null)
-                {
-                    return (Carousel.CurrentSelection as BeatmapInfo)?
-                        .Equals(BeatmapSets[set].Beatmaps[diff.Value]) == true;
-                }
-
-                return BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentSelection);
-            });
+                AddUntilStep($"selected is set{set} diff{diff.Value}",
+                    () => (Carousel.CurrentSelection as BeatmapInfo),
+                    () => Is.EqualTo(BeatmapSets[set].Beatmaps[diff.Value]));
+            }
+            else
+            {
+                AddUntilStep($"selected is set{set}", () => BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentSelection));
+            }
         }
 
         protected IEnumerable<T> GetVisiblePanels<T>()
@@ -306,8 +349,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         /// <param name="randomMetadata">Whether to randomise the metadata to make groupings more uniform.</param>
         protected void AddBeatmaps(int count, int? fixedDifficultiesPerSet = null, bool randomMetadata = false) => AddStep($"add {count} beatmaps{(randomMetadata ? " with random data" : "")}", () =>
         {
+            var beatmaps = new List<BeatmapSetInfo>();
+
             for (int i = 0; i < count; i++)
-                BeatmapSets.Add(CreateTestBeatmapSetInfo(fixedDifficultiesPerSet, randomMetadata));
+                beatmaps.Add(CreateTestBeatmapSetInfo(fixedDifficultiesPerSet, randomMetadata));
+
+            BeatmapSets.AddRange(beatmaps);
         });
 
         protected static BeatmapSetInfo CreateTestBeatmapSetInfo(int? fixedDifficultiesPerSet, bool randomMetadata)
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
index 75996fe158..c704f21fa4 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
@@ -196,7 +196,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 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()
                 {
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
index 0ce13c6963..521221f0c7 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
@@ -73,7 +73,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestCarouselRemembersSelection()
         {
-            SelectNextGroup();
+            SelectNextSet();
 
             object? selection = null;
 
@@ -108,23 +108,31 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestGroupSelectionOnHeader()
         {
-            SelectNextGroup();
-            WaitForGroupSelection(0, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 1);
 
             SelectPrevPanel();
             SelectPrevPanel();
 
+            ICarouselPanel? groupPanel = null;
+
+            AddStep("get group panel", () => groupPanel = GetKeyboardSelectedPanel());
+
             AddAssert("keyboard selected panel is expanded", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.True);
+            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, () => Is.EqualTo(groupPanel));
 
-            SelectPrevGroup();
+            SelectPrevSet();
 
-            WaitForGroupSelection(0, 1);
+            WaitForBeatmapSelection(0, 1);
             AddAssert("keyboard selected panel is contracted", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.False);
+            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, () => Is.EqualTo(groupPanel));
 
-            SelectPrevGroup();
+            SelectPrevSet();
 
-            WaitForGroupSelection(0, 1);
-            AddAssert("keyboard selected panel is expanded", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.True);
+            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>);
         }
 
         [Test]
@@ -143,37 +151,41 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SelectNextPanel();
             Select();
-            WaitForGroupSelection(3, 1);
+            WaitForBeatmapSelection(3, 1);
 
-            SelectNextGroup();
-            WaitForGroupSelection(3, 5);
+            SelectNextSet();
+            WaitForBeatmapSelection(3, 5);
 
-            SelectNextGroup();
-            WaitForGroupSelection(4, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(4, 1);
 
-            SelectPrevGroup();
-            WaitForGroupSelection(3, 5);
+            SelectPrevSet();
+            WaitForBeatmapSelection(3, 5);
 
-            SelectNextGroup();
-            WaitForGroupSelection(4, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(4, 1);
 
-            SelectNextGroup();
-            WaitForGroupSelection(4, 5);
+            SelectNextSet();
+            WaitForBeatmapSelection(4, 5);
 
-            SelectNextGroup();
-            WaitForGroupSelection(0, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 1);
+
+            // Difficulties should get immediate selection even when using up and down traversal.
+            SelectNextPanel();
+            WaitForBeatmapSelection(0, 2);
+            SelectNextPanel();
+            WaitForBeatmapSelection(0, 3);
 
             SelectNextPanel();
-            SelectNextPanel();
-            SelectNextPanel();
-            SelectNextPanel();
+            WaitForBeatmapSelection(0, 3);
 
-            SelectNextGroup();
-            WaitForGroupSelection(0, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 5);
 
             SelectNextPanel();
-            SelectNextGroup();
-            WaitForGroupSelection(1, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(1, 1);
         }
 
         [Test]
@@ -195,26 +207,25 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("no beatmaps visible", () => !GetVisiblePanels<PanelBeatmap>().Any());
 
             ClickVisiblePanelWithOffset<PanelBeatmapSet>(0, new Vector2(0, -(CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 1);
+            WaitForBeatmapSelection(0, 1);
 
             AddUntilStep("wait for beatmaps visible", () => GetVisiblePanels<PanelBeatmap>().Any());
 
             // Beatmap panels expand their selection area to cover holes from spacing.
             ClickVisiblePanelWithOffset<PanelBeatmap>(0, new Vector2(0, -(CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 1);
+            WaitForBeatmapSelection(0, 1);
 
-            ClickVisiblePanelWithOffset<PanelBeatmap>(1, new Vector2(0, (CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 2);
+            ClickVisiblePanelWithOffset<PanelBeatmap>(1, new Vector2(0, CarouselItem.DEFAULT_HEIGHT / 2 + 1));
+            WaitForBeatmapSelection(0, 2);
 
-            ClickVisiblePanelWithOffset<PanelBeatmapSet>(1, new Vector2(0, (CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 5);
+            ClickVisiblePanelWithOffset<PanelBeatmapSet>(1, new Vector2(0, CarouselItem.DEFAULT_HEIGHT / 2 + 1));
+            WaitForBeatmapSelection(0, 5);
         }
 
         [Test]
         public void TestBasicFiltering()
         {
-            ApplyToFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
 
             CheckDisplayedGroupsCount(1);
             CheckDisplayedBeatmapSetsCount(1);
@@ -224,17 +235,16 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SelectNextPanel();
             Select();
-            WaitForGroupSelection(0, 2);
+            WaitForBeatmapSelection(0, 2);
 
             for (int i = 0; i < 6; i++)
                 SelectNextPanel();
 
             Select();
 
-            WaitForGroupSelection(0, 3);
+            WaitForBeatmapSelection(0, 3);
 
-            ApplyToFilter("remove filter", c => c.SearchText = string.Empty);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
 
             CheckDisplayedGroupsCount(5);
             CheckDisplayedBeatmapSetsCount(10);
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
index 8f7c901c37..2ab0eda172 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
@@ -63,7 +63,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestCarouselRemembersSelection()
         {
-            SelectNextGroup();
+            SelectNextSet();
 
             object? selection = null;
 
@@ -98,28 +98,125 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestGroupSelectionOnHeaderKeyboard()
         {
-            SelectNextGroup();
-            WaitForGroupSelection(0, 0);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 0);
 
             SelectPrevPanel();
+
+            ICarouselPanel? groupPanel = null;
+
+            AddStep("get group panel", () => groupPanel = GetKeyboardSelectedPanel());
+
             AddAssert("keyboard selected panel is expanded", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.True);
+            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, () => Is.EqualTo(groupPanel));
 
-            SelectPrevGroup();
+            SelectPrevSet();
 
-            WaitForGroupSelection(0, 0);
+            WaitForBeatmapSelection(0, 0);
             AddAssert("keyboard selected panel is contracted", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.False);
+            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, () => Is.EqualTo(groupPanel));
+
+            SelectPrevSet();
+
+            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>);
+        }
+
+        [Test]
+        public void TestKeyboardGroupToggleCollapse_SelectionContained()
+        {
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 0);
+            checkBeatmapIsKeyboardSelected();
+
+            ToggleGroupCollapse();
+            checkGroupKeyboardSelected(0);
+
+            ToggleGroupCollapse();
+            checkBeatmapIsKeyboardSelected();
+        }
+
+        [Test]
+        public void TestKeyboardGroupToggleCollapse_SelectionNotContained()
+        {
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 0);
+            checkBeatmapIsKeyboardSelected();
+
+            SelectNextGroup();
+            checkGroupKeyboardSelected(1);
+
+            ToggleGroupCollapse();
+            checkGroupKeyboardSelected(1);
+
+            ToggleGroupCollapse();
+            checkGroupKeyboardSelected(1);
+        }
+
+        [Test]
+        public void TestKeyboardGroupTraversalSingleGroup()
+        {
+            RemoveAllBeatmaps();
+            AddBeatmaps(1, 1);
+
+            WaitForBeatmapSelection(0, 0);
+
+            SelectNextGroup();
+            checkBeatmapIsKeyboardSelected();
 
             SelectPrevGroup();
-
-            WaitForGroupSelection(0, 0);
-            AddAssert("keyboard selected panel is expanded", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.True);
+            checkBeatmapIsKeyboardSelected();
         }
 
+        [Test]
+        public void TestKeyboardGroupTraversal()
+        {
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 0);
+            checkBeatmapIsKeyboardSelected();
+
+            SelectNextGroup();
+            WaitForBeatmapSelection(0, 0);
+            WaitForExpandedGroup(1);
+            checkGroupKeyboardSelected(1);
+
+            SelectNextGroup();
+            WaitForBeatmapSelection(0, 0);
+            WaitForExpandedGroup(2);
+            checkGroupKeyboardSelected(2);
+
+            SelectNextGroup();
+            WaitForBeatmapSelection(0, 0);
+            WaitForExpandedGroup(0);
+            checkBeatmapIsKeyboardSelected();
+
+            SelectPrevGroup();
+            WaitForBeatmapSelection(0, 0);
+            WaitForExpandedGroup(2);
+            checkGroupKeyboardSelected(2);
+        }
+
+        private void checkBeatmapIsKeyboardSelected() =>
+            AddUntilStep("check keyboard selected group is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(Carousel.CurrentSelection));
+
+        private void checkGroupKeyboardSelected(int index) => AddUntilStep($"check keyboard selected group is {index}", () => GetKeyboardSelectedPanel()?.Item?.Model, () =>
+        {
+            var groupingFilter = Carousel.Filters.OfType<BeatmapCarouselFilterGrouping>().Single();
+
+            GroupDefinition g = groupingFilter.GroupItems.Keys.ElementAt(index);
+            // offset by one because the group itself is included in the items list.
+            CarouselItem item = groupingFilter.GroupItems[g].ElementAt(0);
+
+            return Is.EqualTo(item.Model);
+        });
+
         [Test]
         public void TestGroupSelectionOnHeaderMouse()
         {
-            SelectNextGroup();
-            WaitForGroupSelection(0, 0);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 0);
 
             AddAssert("keyboard selected panel is beatmap", GetKeyboardSelectedPanel, Is.TypeOf<PanelBeatmapStandalone>);
             AddAssert("selected panel is beatmap", GetSelectedPanel, Is.TypeOf<PanelBeatmapStandalone>);
@@ -129,9 +226,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("keyboard selected panel is contracted", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.False);
 
             ClickVisiblePanel<PanelGroupStarDifficulty>(0);
-            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, Is.TypeOf<PanelGroupStarDifficulty>);
-            AddAssert("keyboard selected panel is expanded", () => GetKeyboardSelectedPanel()?.Expanded.Value, () => Is.True);
-
+            // Expanding a group will move keyboard selection to the selected beatmap if contained.
+            AddAssert("keyboard selected panel is group", GetKeyboardSelectedPanel, Is.TypeOf<PanelBeatmapStandalone>);
             AddAssert("selected panel is still beatmap", GetSelectedPanel, Is.TypeOf<PanelBeatmapStandalone>);
         }
 
@@ -151,22 +247,22 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SelectNextPanel();
             Select();
-            WaitForGroupSelection(0, 0);
+            WaitForBeatmapSelection(0, 0);
 
-            SelectNextGroup();
-            WaitForGroupSelection(0, 1);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 1);
 
-            SelectNextGroup();
-            WaitForGroupSelection(0, 2);
+            SelectNextSet();
+            WaitForBeatmapSelection(0, 2);
 
-            SelectPrevGroup();
-            WaitForGroupSelection(0, 1);
+            SelectPrevSet();
+            WaitForBeatmapSelection(0, 1);
 
-            SelectPrevGroup();
-            WaitForGroupSelection(0, 0);
+            SelectPrevSet();
+            WaitForBeatmapSelection(0, 0);
 
-            SelectPrevGroup();
-            WaitForGroupSelection(2, 9);
+            SelectPrevSet();
+            WaitForBeatmapSelection(2, 9);
         }
 
         [Test]
@@ -187,27 +283,26 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             // Beatmap panels expand their selection area to cover holes from spacing.
             ClickVisiblePanelWithOffset<PanelBeatmapStandalone>(0, new Vector2(0, -(CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 0);
+            WaitForBeatmapSelection(0, 0);
 
             ClickVisiblePanelWithOffset<PanelBeatmapStandalone>(1, new Vector2(0, (CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForGroupSelection(0, 1);
+            WaitForBeatmapSelection(0, 1);
         }
 
         [Test]
         public void TestBasicFiltering()
         {
-            ApplyToFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
 
             CheckDisplayedGroupsCount(3);
             CheckDisplayedBeatmapsCount(3);
 
             // Single result gets selected automatically
-            WaitForGroupSelection(0, 0);
+            WaitForBeatmapSelection(0, 0);
 
             SelectNextPanel();
             Select();
-            WaitForGroupSelection(0, 0);
+            WaitForBeatmapSelection(0, 0);
 
             for (int i = 0; i < 5; i++)
                 SelectNextPanel();
@@ -216,10 +311,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextPanel();
             Select();
 
-            WaitForGroupSelection(1, 0);
+            WaitForBeatmapSelection(1, 0);
 
-            ApplyToFilter("remove filter", c => c.SearchText = string.Empty);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
 
             CheckDisplayedGroupsCount(3);
             CheckDisplayedBeatmapsCount(30);
@@ -228,19 +322,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestExpandedGroupStillExpandedAfterFilter()
         {
-            SelectPrevGroup();
+            SelectPrevSet();
 
-            WaitForGroupSelection(2, 9);
+            WaitForBeatmapSelection(2, 9);
             AddAssert("expanded group is last", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(6));
 
             SelectNextPanel();
             Select();
 
-            WaitForGroupSelection(2, 9);
+            WaitForBeatmapSelection(2, 9);
             AddAssert("expanded group is first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
 
             // doesn't actually filter anything away, but triggers a filter.
-            ApplyToFilter("filter", c => c.SearchText = "Some");
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = "Some");
 
             AddAssert("expanded group is still first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
index 00a00f7f24..78c12e2730 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
@@ -36,24 +36,22 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddAssert("invocation count correct", () => NewItemsPresentedInvocationCount, () => Is.EqualTo(1));
 
-            ApplyToFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
 
             AddAssert("invocation count correct", () => NewItemsPresentedInvocationCount, () => Is.EqualTo(2));
 
             CheckDisplayedBeatmapSetsCount(1);
             CheckDisplayedBeatmapsCount(3);
 
-            WaitForSelection(2, 0);
+            WaitForSetSelection(2, 0);
 
             for (int i = 0; i < 5; i++)
                 SelectNextPanel();
 
             Select();
-            WaitForSelection(2, 1);
+            WaitForSetSelection(2, 1);
 
-            ApplyToFilter("remove filter", c => c.SearchText = string.Empty);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
 
             AddAssert("invocation count correct", () => NewItemsPresentedInvocationCount, () => Is.EqualTo(3));
 
@@ -84,46 +82,39 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             WaitForDrawablePanels();
 
-            ApplyToFilter("filter [5..]", c =>
+            ApplyToFilterAndWaitForFilter("filter [5..]", c =>
             {
                 c.UserStarDifficulty.Min = 5;
                 c.UserStarDifficulty.Max = null;
             });
-            WaitForFiltering();
             CheckDisplayedBeatmapsCount(11);
 
-            ApplyToFilter("filter to [0..7]", c =>
+            ApplyToFilterAndWaitForFilter("filter to [0..7]", c =>
             {
                 c.UserStarDifficulty.Min = null;
                 c.UserStarDifficulty.Max = 7;
             });
-            WaitForFiltering();
             CheckDisplayedBeatmapsCount(7);
 
-            ApplyToFilter("filter to [5..7]", c =>
+            ApplyToFilterAndWaitForFilter("filter to [5..7]", c =>
             {
                 c.UserStarDifficulty.Min = 5;
                 c.UserStarDifficulty.Max = 7;
             });
-
-            WaitForFiltering();
             CheckDisplayedBeatmapsCount(3);
 
-            ApplyToFilter("filter to [2..2]", c =>
+            ApplyToFilterAndWaitForFilter("filter to [2..2]", c =>
             {
                 c.UserStarDifficulty.Min = 2;
                 c.UserStarDifficulty.Max = 2;
             });
-
-            WaitForFiltering();
             CheckDisplayedBeatmapsCount(1);
 
-            ApplyToFilter("filter to [0..]", c =>
+            ApplyToFilterAndWaitForFilter("filter to [0..]", c =>
             {
                 c.UserStarDifficulty.Min = 0;
                 c.UserStarDifficulty.Max = null;
             });
-            WaitForFiltering();
             CheckDisplayedBeatmapsCount(15);
         }
 
@@ -135,7 +126,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(50, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
+            SelectNextSet();
             SelectNextPanel();
             Select();
 
@@ -143,9 +134,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             for (int i = 0; i < 5; i++)
             {
-                ApplyToFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
+                ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
                 AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
-                ApplyToFilter("remove filter", c => c.SearchText = string.Empty);
+                ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
                 AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
             }
         }
@@ -156,11 +147,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(50, 3);
             WaitForDrawablePanels();
 
-            SelectPrevGroup();
-            WaitForSelection(49, 0);
+            SelectPrevSet();
+            WaitForSetSelection(49, 0);
 
-            ApplyToFilter("filter all but one", c => c.SearchText = BeatmapSets.First().Metadata.Title);
-            WaitForSelection(0, 0);
+            ApplyToFilterAndWaitForFilter("filter all but one", c => c.SearchText = BeatmapSets.First().Metadata.Title);
+            WaitForSetSelection(0, 0);
         }
 
         [Test]
@@ -170,8 +161,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForDrawablePanels();
 
             CheckNoSelection();
-            ApplyToFilter("filter all but one", c => c.SearchText = BeatmapSets.First().Metadata.Title);
-            WaitForSelection(0, 0);
+            ApplyToFilterAndWaitForFilter("filter all but one", c => c.SearchText = BeatmapSets.First().Metadata.Title);
+            WaitForSetSelection(0, 0);
         }
 
         [Test]
@@ -184,15 +175,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SortBy(SortMode.Difficulty);
 
-            SelectNextGroup();
+            SelectNextSet();
 
             AddStep("record selection", () => selectedID = ((BeatmapInfo)Carousel.CurrentSelection!).ID);
 
             for (int i = 0; i < 5; i++)
             {
-                ApplyToFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
+                ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
                 AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
-                ApplyToFilter("remove filter", c => c.SearchText = string.Empty);
+                ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
                 AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
             }
         }
@@ -223,10 +214,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestExternalRulesetChange()
         {
-            ApplyToFilter("allow converted beatmaps", c => c.AllowConvertedBeatmaps = true);
-            ApplyToFilter("filter to osu", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(0));
-
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("allow converted beatmaps, filter to osu", c =>
+            {
+                c.AllowConvertedBeatmaps = true;
+                c.Ruleset = rulesets.AvailableRulesets.ElementAt(0);
+            });
 
             AddStep("add mixed ruleset beatmapset", () =>
             {
@@ -250,9 +242,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                        && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1;
             });
 
-            ApplyToFilter("filter to taiko", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(1));
-
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter to taiko", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(1));
 
             AddUntilStep("wait for filtered difficulties", () =>
             {
@@ -263,9 +253,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                        && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 1) == 1;
             });
 
-            ApplyToFilter("filter to catch", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(2));
-
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter to catch", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(2));
 
             AddUntilStep("wait for filtered difficulties", () =>
             {
@@ -297,17 +285,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
 
             SortBy(SortMode.Difficulty);
-            WaitForFiltering();
 
             CheckDisplayedBeatmapsCount(local_set_count * diffs_per_set);
 
-            ApplyToFilter("filter to normal", c => c.SearchText = "Normal");
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter to normal", c => c.SearchText = "Normal");
 
             CheckDisplayedBeatmapsCount(local_set_count);
 
-            ApplyToFilter("filter to insane", c => c.SearchText = "Insane");
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter to insane", c => c.SearchText = "Insane");
 
             CheckDisplayedBeatmapsCount(local_set_count);
         }
@@ -318,20 +303,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(2, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
             CheckDisplayedBeatmapsCount(6);
 
-            ApplyToFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             CheckDisplayedBeatmapsCount(4);
 
-            SelectNextGroup();
-            WaitForSelection(0, 1);
-            SelectPrevGroup();
-            WaitForSelection(1, 1);
+            SelectNextSet();
+            WaitForSetSelection(1, 1);
+            SelectPrevSet();
+            WaitForSetSelection(0, 1);
         }
 
         [Test]
@@ -340,16 +324,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(5, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            SelectNextGroup();
-            SelectNextGroup();
-            WaitForSelection(2, 0);
+            SelectNextSet();
+            SelectNextSet();
+            SelectNextSet();
+            WaitForSetSelection(2, 0);
 
-            ApplyToFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
-            SelectNextGroup();
-            WaitForSelection(0, 1);
+            SelectNextSet();
+            WaitForSetSelection(0, 1);
         }
 
         [Test]
@@ -358,16 +341,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(5, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            SelectNextGroup();
-            SelectNextGroup();
-            WaitForSelection(2, 0);
+            SelectNextSet();
+            SelectNextSet();
+            SelectNextSet();
+            WaitForSetSelection(2, 0);
 
-            ApplyToFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
-            SelectPrevGroup();
-            WaitForSelection(4, 1);
+            SelectPrevSet();
+            WaitForSetSelection(4, 1);
         }
 
         [Test]
@@ -376,14 +358,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(2, 3);
             WaitForDrawablePanels();
 
-            SelectPrevGroup();
-            WaitForSelection(1, 0);
+            SelectPrevSet();
+            WaitForSetSelection(1, 0);
 
-            ApplyToFilter("filter last set away", c => c.SearchText = BeatmapSets.First().Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter last set away", c => c.SearchText = BeatmapSets.First().Metadata.Title);
 
-            SelectPrevGroup();
-            WaitForSelection(0, 0);
+            SelectPrevSet();
+            WaitForSetSelection(0, 0);
         }
 
         [Test]
@@ -392,14 +373,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(2, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
-            ApplyToFilter("filter first set away", c => c.SearchText = BeatmapSets.Last().Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first set away", c => c.SearchText = BeatmapSets.Last().Metadata.Title);
 
-            SelectNextGroup();
-            WaitForSelection(1, 0);
+            SelectNextSet();
+            WaitForSetSelection(1, 0);
         }
 
         [Test]
@@ -408,13 +388,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(5, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            SelectNextGroup();
-            SelectNextGroup();
-            WaitForSelection(2, 0);
+            SelectNextSet();
+            SelectNextSet();
+            SelectNextSet();
+            WaitForSetSelection(2, 0);
 
-            ApplyToFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectNextPanel();
             AddAssert("keyboard selected is first set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.First()));
@@ -426,13 +405,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(5, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            SelectNextGroup();
-            SelectNextGroup();
-            WaitForSelection(2, 0);
+            SelectNextSet();
+            SelectNextSet();
+            SelectNextSet();
+            WaitForSetSelection(2, 0);
 
-            ApplyToFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectPrevPanel();
             AddAssert("keyboard selected is last set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.Last()));
@@ -444,11 +422,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(2, 3);
             WaitForDrawablePanels();
 
-            SelectPrevGroup();
-            WaitForSelection(1, 0);
+            SelectPrevSet();
+            WaitForSetSelection(1, 0);
 
-            ApplyToFilter("filter last set away", c => c.SearchText = BeatmapSets.First().Metadata.Title);
-            WaitForFiltering();
+            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()));
@@ -460,11 +437,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(2, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
-            ApplyToFilter("filter first set away", c => c.SearchText = BeatmapSets.Last().Metadata.Title);
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("filter first set away", c => c.SearchText = BeatmapSets.Last().Metadata.Title);
 
             // Single result is automatically selected for us, so we iterate once backwards to the set header.
             SelectPrevPanel();
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
index 800cde8c50..648f531a6e 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
@@ -5,7 +5,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;
 using osuTK;
@@ -83,7 +82,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(10);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
+            SelectNextSet();
 
             object? selection = null;
 
@@ -117,10 +116,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(total_set_count);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
-            SelectPrevGroup();
-            WaitForSelection(total_set_count - 1, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
+            SelectPrevSet();
+            WaitForSetSelection(total_set_count - 1, 0);
         }
 
         [Test]
@@ -131,10 +130,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(total_set_count);
             WaitForDrawablePanels();
 
-            SelectPrevGroup();
-            WaitForSelection(total_set_count - 1, 0);
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectPrevSet();
+            WaitForSetSelection(total_set_count - 1, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
         }
 
         [Test]
@@ -143,17 +142,49 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(10, 3);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
-            SelectNextGroup();
-            WaitForSelection(1, 0);
+            SelectNextSet();
+            SelectNextSet();
+            WaitForSetSelection(1, 0);
 
             SelectPrevPanel();
-            SelectPrevGroup();
-            WaitForSelection(1, 0);
+            SelectPrevSet();
+            WaitForSetSelection(1, 0);
 
             SelectPrevPanel();
-            SelectNextGroup();
-            WaitForSelection(1, 0);
+            SelectNextSet();
+            WaitForSetSelection(1, 0);
+        }
+
+        [Test]
+        public void TestMultipleKeyboardOperationsPerFrame()
+        {
+            AddBeatmaps(10, 3);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
+
+            SelectNextPanel();
+            SelectNextPanel();
+            SelectNextPanel();
+
+            AddStep("Press two keys at once", () =>
+            {
+                InputManager.Key(Key.Down);
+                InputManager.Key(Key.Right);
+            });
+
+            // Second key is respected, so only set selection changes.
+            WaitForSetSelection(1, 0);
+
+            AddStep("Press two keys at once", () =>
+            {
+                InputManager.Key(Key.Left);
+                InputManager.Key(Key.Up);
+            });
+
+            // Second key is respected, so only keyboard selection changes.
+            WaitForSetSelection(1, 0);
         }
 
         [Test]
@@ -169,25 +200,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckNoSelection();
 
             Select();
-            WaitForSelection(3, 0);
+            WaitForSetSelection(3, 0);
 
             SelectNextPanel();
-            WaitForSelection(3, 0);
-
-            Select();
-            WaitForSelection(3, 1);
+            WaitForSetSelection(3, 1);
 
             SelectNextPanel();
-            WaitForSelection(3, 1);
-
-            Select();
-            WaitForSelection(3, 2);
+            WaitForSetSelection(3, 2);
 
             SelectNextPanel();
-            WaitForSelection(3, 2);
+            WaitForSetSelection(3, 2);
 
             Select();
-            WaitForSelection(4, 0);
+            WaitForSetSelection(4, 0);
         }
 
         [Test]
@@ -196,22 +221,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckNoSelection();
             AddBeatmaps(1, 3);
 
-            WaitForSelection(0, 0);
+            WaitForSetSelection(0, 0);
             CheckActivationCount(0);
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
-            // In the case of a grouped beatmap set, the header gets activated and re-selects the recommended difficulty.
-            // This is probably fine.
-            CheckActivationCount(1);
-            // We don't want it to request present though, which would start gameplay.
+            CheckActivationCount(0);
             CheckRequestPresentCount(0);
 
-            SelectPrevGroup();
-            WaitForSelection(0, 0);
+            SelectPrevSet();
+            WaitForSetSelection(0, 0);
 
-            CheckActivationCount(1);
+            CheckActivationCount(0);
             CheckRequestPresentCount(0);
         }
 
@@ -223,11 +245,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckNoSelection();
             AddBeatmaps(1, 1);
 
-            WaitForSelection(0, 0);
+            WaitForSetSelection(0, 0);
             CheckActivationCount(0);
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
             // In the case of a grouped beatmap set, the header gets activated and re-selects the recommended difficulty.
             // This is probably fine.
@@ -235,8 +257,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             // We don't want it to request present though, which would start gameplay.
             CheckRequestPresentCount(0);
 
-            SelectPrevGroup();
-            WaitForSelection(0, 0);
+            SelectPrevSet();
+            WaitForSetSelection(0, 0);
 
             CheckActivationCount(0);
             CheckRequestPresentCount(0);
@@ -248,13 +270,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextPanel();
             CheckNoSelection();
 
-            SelectNextGroup();
+            SelectNextSet();
             CheckNoSelection();
 
             SelectPrevPanel();
             CheckNoSelection();
 
-            SelectPrevGroup();
+            SelectPrevSet();
             CheckNoSelection();
         }
 
@@ -274,18 +296,20 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ClickVisiblePanelWithOffset<PanelBeatmapSet>(0, new Vector2(0, -(PanelBeatmapSet.HEIGHT / 2 - 1)));
 
             AddUntilStep("wait for beatmaps visible", () => GetVisiblePanels<PanelBeatmap>().Any());
-            WaitForSelection(0, 0);
+            WaitForSetSelection(0, 0);
 
             // Beatmap panels expand their selection area to cover holes from spacing.
-            ClickVisiblePanelWithOffset<PanelBeatmap>(1, new Vector2(0, -(CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForSelection(0, 0);
+            ClickVisiblePanelWithOffset<PanelBeatmap>(0, new Vector2(0, -(PanelBeatmap.HEIGHT / 2 + 1)));
+            WaitForSetSelection(0, 0);
 
-            // Panels with higher depth will handle clicks in the gutters for simplicity.
-            ClickVisiblePanelWithOffset<PanelBeatmap>(2, new Vector2(0, (CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForSelection(0, 2);
+            ClickVisiblePanelWithOffset<PanelBeatmap>(2, new Vector2(0, (PanelBeatmap.HEIGHT / 2 + 1)));
+            WaitForSetSelection(0, 2);
 
-            ClickVisiblePanelWithOffset<PanelBeatmap>(3, new Vector2(0, (CarouselItem.DEFAULT_HEIGHT / 2 + 1)));
-            WaitForSelection(0, 3);
+            ClickVisiblePanelWithOffset<PanelBeatmap>(2, new Vector2(0, -(PanelBeatmap.HEIGHT / 2 + 1)));
+            WaitForSetSelection(0, 2);
+
+            ClickVisiblePanelWithOffset<PanelBeatmap>(3, new Vector2(0, (PanelBeatmap.HEIGHT / 2 + 1)));
+            WaitForSetSelection(0, 3);
         }
 
         [Test]
@@ -295,21 +319,20 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForDrawablePanels();
 
             SortAndGroupBy(SortMode.Difficulty, GroupMode.None);
-            WaitForFiltering();
 
             AddUntilStep("standalone panels displayed", () => GetVisiblePanels<PanelBeatmapStandalone>().Any());
 
-            SelectNextGroup();
+            SelectNextSet();
             // both sets have a difficulty with 0.00* star rating.
             // in the case of a tie when sorting, the first tie-breaker is `DateAdded` descending, which will pick the last set added (see `TestResources.CreateTestBeatmapSetInfo()`).
-            WaitForSelection(1, 0);
+            WaitForSetSelection(1, 0);
 
-            SelectNextGroup();
-            WaitForSelection(0, 0);
+            SelectNextSet();
+            WaitForSetSelection(0, 0);
 
             SelectNextPanel();
             Select();
-            WaitForSelection(1, 1);
+            WaitForSetSelection(1, 1);
         }
 
         [Test]
@@ -319,11 +342,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForDrawablePanels();
 
             SortBy(SortMode.Difficulty);
-            WaitForFiltering();
 
             AddUntilStep("standalone panels displayed", () => GetVisiblePanels<PanelBeatmapStandalone>().Count(), () => Is.EqualTo(3));
 
-            WaitForSelection(0, 0);
+            WaitForSetSelection(0, 0);
 
             SortBy(SortMode.Title);
 
@@ -340,30 +362,30 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("set recommendation algorithm", () => BeatmapRecommendationFunction = beatmaps => beatmaps.Last());
 
-            SelectPrevGroup();
+            SelectPrevSet();
 
             // check recommended was selected
-            SelectNextGroup();
-            WaitForSelection(0, 2);
+            SelectNextSet();
+            WaitForSetSelection(0, 2);
 
             // change away from recommended
             SelectPrevPanel();
             Select();
-            WaitForSelection(0, 1);
+            WaitForSetSelection(0, 1);
 
             // next set, check recommended
-            SelectNextGroup();
-            WaitForSelection(1, 2);
+            SelectNextSet();
+            WaitForSetSelection(1, 2);
 
             // next set, check recommended
-            SelectNextGroup();
-            WaitForSelection(2, 2);
+            SelectNextSet();
+            WaitForSetSelection(2, 2);
 
             // go back to first set and ensure user selection was retained
             // todo: we don't do that yet. not sure if we will continue to have this.
-            // SelectPrevGroup();
-            // SelectPrevGroup();
-            // WaitForSelection(0, 1);
+            // SelectPrevSet();
+            // SelectPrevSet();
+            // WaitForSetSelection(0, 1);
         }
 
         private void checkSelectionIterating(bool isIterating)
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
index 6e9b30e25d..ed694c9e3d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
@@ -6,6 +6,7 @@ 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
 {
@@ -19,6 +20,66 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CreateCarousel();
         }
 
+        [Test]
+        public void TestRandomObeysFiltering()
+        {
+            AddBeatmaps(2, 10, true);
+
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[0].Beatmaps.Last().DifficultyName);
+
+            CheckDisplayedBeatmapSetsCount(1);
+            CheckDisplayedBeatmapsCount(1);
+
+            for (int i = 0; i < 10; i++)
+            {
+                nextRandom();
+                WaitForSetSelection(0, 9);
+            }
+        }
+
+        [Test]
+        public void TestGroupingModeChangeStillWorks()
+        {
+            BeatmapInfo originalSelected = null!;
+            GroupDefinition? expanded = null;
+
+            SortAndGroupBy(SortMode.Artist, GroupMode.Artist);
+            AddBeatmaps(10, 3, true);
+            WaitForDrawablePanels();
+
+            nextRandom();
+            ensureRandomDidNotRepeat();
+
+            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+
+            SortAndGroupBy(SortMode.Artist, GroupMode.Difficulty);
+            WaitForFiltering();
+
+            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+
+            storeExpandedGroup();
+
+            for (int i = 0; i < 5; i++)
+            {
+                nextRandom();
+                ensureRandomDidNotRepeat();
+                checkExpandedGroupUnchanged();
+            }
+
+            SortAndGroupBy(SortMode.Artist, GroupMode.None);
+            WaitForFiltering();
+
+            for (int i = 0; i < 5; i++)
+            {
+                nextRandom();
+                ensureRandomDidNotRepeat();
+            }
+
+            void storeExpandedGroup() => AddStep("store open group", () => expanded = Carousel.ExpandedGroup);
+
+            void checkExpandedGroupUnchanged() => AddAssert("expanded did not change", () => Carousel.ExpandedGroup, () => Is.EqualTo(expanded));
+        }
+
         /// <summary>
         /// Test random non-repeating algorithm
         /// </summary>
@@ -30,57 +91,139 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(10, 3, true);
             WaitForDrawablePanels();
 
-            nextRandom();
-            ensureRandomDidNotRepeat();
-            nextRandom();
-            ensureRandomDidNotRepeat();
-            nextRandom();
-            ensureRandomDidNotRepeat();
+            GroupDefinition? expanded = null;
 
-            prevRandom();
+            for (int i = 0; i < 2; i++)
+            {
+                nextRandom();
+                expanded ??= storeExpandedGroup();
+
+                ensureSetRandomDidNotRepeat();
+                checkExpandedGroupUnchanged();
+            }
+
+            nextRandom();
+            ensureSetRandomDidRepeat();
+            checkExpandedGroupUnchanged();
+
+            prevRandomSet();
             checkRewindCorrectSet();
-            prevRandom();
+            checkExpandedGroupUnchanged();
+            prevRandomSet();
             checkRewindCorrectSet();
+            checkExpandedGroupUnchanged();
 
             nextRandom();
-            ensureRandomDidNotRepeat();
+            ensureSetRandomDidNotRepeat();
+            checkExpandedGroupUnchanged();
             nextRandom();
-            ensureRandomDidNotRepeat();
+            ensureSetRandomDidRepeat();
+            checkExpandedGroupUnchanged();
 
-            nextRandom();
-            AddAssert("ensure repeat", () => BeatmapSetRequestedSelections.Contains(Carousel.SelectedBeatmapSet!));
+            GroupDefinition? storeExpandedGroup()
+            {
+                AddStep("store open group", () => expanded = Carousel.ExpandedGroup);
+                return null;
+            }
+
+            void checkExpandedGroupUnchanged() => AddAssert("expanded did not change", () => Carousel.ExpandedGroup, () => Is.EqualTo(expanded));
         }
 
         /// <summary>
         /// Test random non-repeating algorithm
         /// </summary>
         [Test]
-        public void TestRandomDifficultyGrouping()
+        public void TestRandomDifficultyGroupingRewindsCorrectly()
         {
             SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
 
-            AddBeatmaps(10, 3, true);
+            AddBeatmaps(3, 3, true);
             WaitForDrawablePanels();
 
-            nextRandom();
-            ensureRandomDidNotRepeat();
-            nextRandom();
-            ensureRandomDidNotRepeat();
-            nextRandom();
-            ensureRandomDidNotRepeat();
+            GroupDefinition? expanded = null;
 
-            prevRandom();
-            checkRewindCorrectSet();
-            prevRandom();
-            checkRewindCorrectSet();
+            for (int i = 0; i < 3; i++)
+            {
+                nextRandom();
+                expanded ??= storeExpandedGroup();
+
+                ensureRandomDidNotRepeat();
+                checkExpandedGroupUnchanged();
+            }
+
+            for (int i = 0; i < 2; i++)
+            {
+                prevRandom();
+                checkRewindCorrect();
+                checkExpandedGroupUnchanged();
+            }
+
+            for (int i = 0; i < 2; i++)
+            {
+                nextRandom();
+                ensureRandomDidNotRepeat();
+                checkExpandedGroupUnchanged();
+            }
 
             nextRandom();
-            ensureRandomDidNotRepeat();
-            nextRandom();
-            ensureRandomDidNotRepeat();
+            ensureRandomDidRepeat();
+            checkExpandedGroupUnchanged();
+
+            GroupDefinition? storeExpandedGroup()
+            {
+                AddStep("store open group", () => expanded = Carousel.ExpandedGroup);
+                return null;
+            }
+
+            void checkExpandedGroupUnchanged() => AddAssert("expanded did not change", () => Carousel.ExpandedGroup, () => Is.EqualTo(expanded));
+        }
+
+        /// <summary>
+        /// Test random non-repeating algorithm
+        /// </summary>
+        [Test]
+        public void TestRandomDifficultyGroupingRepeatsWhenExhausted()
+        {
+            SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
+
+            AddBeatmaps(3, 3, true);
+            WaitForDrawablePanels();
+
+            GroupDefinition? expanded = null;
+
+            for (int i = 0; i < 3; i++)
+            {
+                nextRandom();
+                expanded ??= storeExpandedGroup();
+
+                ensureRandomDidNotRepeat();
+                checkExpandedGroupUnchanged();
+            }
+
+            for (int i = 0; i < 3; i++)
+            {
+                nextRandom();
+                ensureRandomDidRepeat();
+            }
+
+            for (int i = 0; i < 5; i++)
+            {
+                prevRandom();
+                checkRewindCorrect();
+                checkExpandedGroupUnchanged();
+            }
 
             nextRandom();
-            AddAssert("ensure repeat", () => BeatmapSetRequestedSelections.Contains(Carousel.SelectedBeatmapSet!));
+            checkExpandedGroupUnchanged();
+            // can't assert repeat or otherwise as we went through multiple permutations.
+
+            GroupDefinition? storeExpandedGroup()
+            {
+                AddStep("store open group", () => expanded = Carousel.ExpandedGroup);
+                return null;
+            }
+
+            void checkExpandedGroupUnchanged() => AddAssert("expanded did not change", () => Carousel.ExpandedGroup, () => Is.EqualTo(expanded));
         }
 
         [Test]
@@ -92,18 +235,40 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(local_set_count, 3, true);
             WaitForDrawablePanels();
 
-            SelectNextGroup();
+            SelectNextSet();
 
             for (int i = 0; i < random_select_count; i++)
                 nextRandom();
 
             for (int i = 0; i < random_select_count; i++)
             {
-                prevRandom();
+                prevRandomSet();
                 checkRewindCorrectSet();
             }
         }
 
+        [Test]
+        public void TestRandomThenRewindSameFrame()
+        {
+            AddBeatmaps(10, 3, true);
+            WaitForDrawablePanels();
+
+            BeatmapInfo? originalSelected = null;
+
+            nextRandom();
+
+            CheckHasSelection();
+            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+
+            AddStep("random then rewind", () =>
+            {
+                Carousel.NextRandom();
+                Carousel.PreviousRandom();
+            });
+
+            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+        }
+
         [Test]
         public void TestRewindToDeletedBeatmap()
         {
@@ -128,20 +293,40 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
 
-            prevRandom();
+            prevRandomSet();
             AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
         }
 
         private void nextRandom() =>
             AddStep("select random next", () => Carousel.NextRandom());
 
+        private void ensureRandomDidRepeat() =>
+            AddAssert("did repeat", () => BeatmapRequestedSelections.Distinct().Count(), () => Is.LessThan(BeatmapRequestedSelections.Count));
+
         private void ensureRandomDidNotRepeat() =>
+            AddAssert("no repeats", () => BeatmapRequestedSelections.Distinct().Count(), () => Is.EqualTo(BeatmapRequestedSelections.Count));
+
+        private void ensureSetRandomDidRepeat() =>
+            AddAssert("did repeat", () => BeatmapSetRequestedSelections.Distinct().Count(), () => Is.LessThan(BeatmapSetRequestedSelections.Count));
+
+        private void ensureSetRandomDidNotRepeat() =>
             AddAssert("no repeats", () => BeatmapSetRequestedSelections.Distinct().Count(), () => Is.EqualTo(BeatmapSetRequestedSelections.Count));
 
+        private void checkRewindCorrect() =>
+            AddAssert("rewind matched expected beatmap", () => BeatmapRequestedSelections.Peek(), () => Is.EqualTo(Carousel.SelectedBeatmapInfo));
+
         private void checkRewindCorrectSet() =>
             AddAssert("rewind matched expected set", () => BeatmapSetRequestedSelections.Peek(), () => Is.EqualTo(Carousel.SelectedBeatmapSet));
 
-        private void prevRandom() => AddStep("select random last", () =>
+        private void prevRandom() => AddStep("select last random", () =>
+        {
+            Carousel.PreviousRandom();
+            BeatmapRequestedSelections.Pop();
+            // Pop twice because the PreviousRandom call also requests selection.
+            BeatmapRequestedSelections.Pop();
+        });
+
+        private void prevRandomSet() => AddStep("select last random set", () =>
         {
             Carousel.PreviousRandom();
             BeatmapSetRequestedSelections.Pop();
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
index 383ec47a69..29aa976fe3 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
@@ -97,8 +97,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddStep("scroll to end", () => Scroll.ScrollToEnd());
             WaitForScrolling();
 
-            ApplyToFilter("search", f => f.SearchText = "Some");
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("search", f => f.SearchText = "Some");
 
             AddUntilStep("select screen position returned to selection", () => Carousel.ChildrenOfType<PanelBeatmap>().Single(p => p.Selected.Value).ScreenSpaceDrawQuad,
                 () => Is.EqualTo(positionBefore));
@@ -121,8 +120,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("save selected screen position", () => positionBefore = Carousel.ChildrenOfType<PanelBeatmap>().FirstOrDefault(p => p.Selected.Value)!.ScreenSpaceDrawQuad);
 
-            ApplyToFilter("search", f => f.SearchText = "Some");
-            WaitForFiltering();
+            ApplyToFilterAndWaitForFilter("search", f => f.SearchText = "Some");
 
             AddUntilStep("select screen position returned to selection", () => Carousel.ChildrenOfType<PanelBeatmap>().Single(p => p.Selected.Value).ScreenSpaceDrawQuad,
                 () => Is.EqualTo(positionBefore));
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
index eb8877738f..fdc9cc93a5 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
@@ -94,9 +94,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestSelectionHeld()
         {
-            SelectNextGroup();
+            SelectNextSet();
 
-            WaitForSelection(1, 0);
+            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]));
 
@@ -110,9 +110,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test] // Checks that we keep selection based on online ID where possible.
         public void TestSelectionHeldDifficultyNameChanged()
         {
-            SelectNextGroup();
+            SelectNextSet();
 
-            WaitForSelection(1, 0);
+            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]));
 
@@ -126,9 +126,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test] // Checks that we fallback to keeping selection based on difficulty name.
         public void TestSelectionHeldDifficultyOnlineIDChanged()
         {
-            SelectNextGroup();
+            SelectNextSet();
 
-            WaitForSelection(1, 0);
+            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]));
 
@@ -172,7 +172,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             Guid[] originalOrder = null!;
 
             SortBy(SortMode.Artist);
-            WaitForFiltering();
 
             AddAssert("Items in descending added order", () => Carousel.PostFilterBeatmaps.Select(b => b.BeatmapSet!.DateAdded), () => Is.Ordered.Descending);
             AddStep("Save order", () => originalOrder = Carousel.PostFilterBeatmaps.Select(b => b.ID).ToArray());
@@ -188,7 +187,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
 
             SortBy(SortMode.Title);
-            WaitForFiltering();
 
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
         }
@@ -225,7 +223,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             Guid[] originalOrder = null!;
 
             SortBy(SortMode.Artist);
-            WaitForFiltering();
 
             AddAssert("Items in descending added order", () => Carousel.PostFilterBeatmaps.Select(b => b.BeatmapSet!.DateAdded), () => Is.Ordered.Descending);
             AddStep("Save order", () => originalOrder = Carousel.PostFilterBeatmaps.Select(b => b.ID).ToArray());
@@ -252,7 +249,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
 
             SortBy(SortMode.Title);
-            WaitForFiltering();
 
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardScore.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardScore.cs
index 1b6d56df16..0aca2d6a1c 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardScore.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardScore.cs
@@ -53,6 +53,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         fillFlow = new FillFlowContainer
                         {
+                            X = 100,
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             RelativeSizeAxes = Axes.X,
@@ -66,10 +67,23 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 foreach (var scoreInfo in getTestScores())
                 {
+                    BeatmapLeaderboardScore.HighlightType? highlightType = null;
+
+                    switch (scoreInfo.User.Id)
+                    {
+                        case 2:
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Own;
+                            break;
+
+                        case 1541390:
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Friend;
+                            break;
+                    }
+
                     fillFlow.Add(new BeatmapLeaderboardScore(scoreInfo)
                     {
                         Rank = scoreInfo.Position,
-                        IsPersonalBest = scoreInfo.User.Id == 2,
+                        Highlight = highlightType,
                         Shear = Vector2.Zero,
                     });
                 }
@@ -104,10 +118,23 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 foreach (var scoreInfo in getTestScores())
                 {
+                    BeatmapLeaderboardScore.HighlightType? highlightType = null;
+
+                    switch (scoreInfo.User.Id)
+                    {
+                        case 2:
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Own;
+                            break;
+
+                        case 1541390:
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Friend;
+                            break;
+                    }
+
                     fillFlow.Add(new BeatmapLeaderboardScore(scoreInfo, sheared: false)
                     {
                         Rank = scoreInfo.Position,
-                        IsPersonalBest = scoreInfo.User.Id == 2,
+                        Highlight = highlightType,
                     });
                 }
 
@@ -205,7 +232,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     Position = 999,
                     Rank = ScoreRank.X,
                     Accuracy = 1,
-                    MaxCombo = 244,
+                    MaxCombo = 3000,
                     TotalScore = RNG.Next(1_800_000, 2_000_000),
                     MaximumStatistics = { { HitResult.Great, 3000 } },
                     Ruleset = new OsuRuleset().RulesetInfo,
@@ -223,7 +250,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     Position = 22333,
                     Rank = ScoreRank.S,
                     Accuracy = 0.1f,
-                    MaxCombo = 32040,
+                    MaxCombo = 2204,
                     TotalScore = RNG.Next(1_200_000, 1_500_000),
                     MaximumStatistics = { { HitResult.Great, 3000 } },
                     Ruleset = new OsuRuleset().RulesetInfo,
@@ -255,7 +282,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 },
                 new ScoreInfo
                 {
-                    Position = 110000,
+                    Position = 2233,
                     Rank = ScoreRank.D,
                     Accuracy = 1,
                     MaxCombo = 244,
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardWedge.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardWedge.cs
index 992651d73c..8fcb3d7acc 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardWedge.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapLeaderboardWedge.cs
@@ -28,7 +28,6 @@ using osu.Game.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
-using osu.Game.Tests.Visual.SongSelect;
 using osu.Game.Users;
 using osuTK.Input;
 
@@ -118,8 +117,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             setScope(BeatmapLeaderboardScope.Global);
 
-            AddStep(@"New Scores", () => leaderboard.SetScores(TestSceneBeatmapLeaderboard.GenerateSampleScores(new BeatmapInfo())));
-            AddStep(@"New Scores with teams", () => leaderboard.SetScores(TestSceneBeatmapLeaderboard.GenerateSampleScores(new BeatmapInfo()).Select(s =>
+            AddStep(@"New Scores", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo())));
+            AddStep(@"New Scores with teams", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()).Select(s =>
             {
                 s.User.Team = new APITeam();
                 return s;
@@ -150,7 +149,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestUseTheseModsDoesNotCopySystemMods()
         {
-            AddStep(@"set scores", () => leaderboard.SetScores(TestSceneBeatmapLeaderboard.GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
+            AddStep(@"set scores", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
             {
                 OnlineID = 1337,
                 Position = 999,
@@ -297,7 +296,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private void showPersonalBestWithNullPosition()
         {
-            leaderboard.SetScores(TestSceneBeatmapLeaderboard.GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
+            leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
             {
                 OnlineID = 1337,
                 Rank = ScoreRank.XH,
@@ -318,7 +317,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private void showPersonalBest()
         {
-            leaderboard.SetScores(TestSceneBeatmapLeaderboard.GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
+            leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()), new ScoreInfo
             {
                 OnlineID = 1337,
                 Position = 999,
@@ -347,7 +346,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddStep(@"Import new scores", () =>
             {
-                foreach (var score in TestSceneBeatmapLeaderboard.GenerateSampleScores(beatmapInfo()))
+                foreach (var score in GenerateSampleScores(beatmapInfo()))
                     scoreManager.Import(score);
             });
         }
@@ -368,5 +367,216 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             public new void SetState(LeaderboardState state) => base.SetState(state);
             public new void SetScores(IEnumerable<ScoreInfo> scores, ScoreInfo? userScore = null, int? totalCount = null) => base.SetScores(scores, userScore, totalCount);
         }
+
+        public static ScoreInfo[] GenerateSampleScores(BeatmapInfo beatmapInfo)
+        {
+            return new[]
+            {
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.XH,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now,
+                    Mods = new Mod[]
+                    {
+                        new OsuModHidden(),
+                        new OsuModFlashlight
+                        {
+                            FollowDelay = { Value = 200 },
+                            SizeMultiplier = { Value = 5 },
+                        },
+                        new OsuModDifficultyAdjust
+                        {
+                            CircleSize = { Value = 11 },
+                            ApproachRate = { Value = 10 },
+                            OverallDifficulty = { Value = 10 },
+                            DrainRate = { Value = 10 },
+                            ExtendedLimits = { Value = true }
+                        }
+                    },
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    User = new APIUser
+                    {
+                        Id = 6602580,
+                        Username = @"waaiiru",
+                        CountryCode = CountryCode.ES,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.X,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddSeconds(-30),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Id = 4608074,
+                        Username = @"Skycries",
+                        CountryCode = CountryCode.BR,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.SH,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddSeconds(-70),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 1014222,
+                        Username = @"eLy",
+                        CountryCode = CountryCode.JP,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.S,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddMinutes(-40),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 1541390,
+                        Username = @"Toukai",
+                        CountryCode = CountryCode.CA,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.A,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddHours(-2),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 2243452,
+                        Username = @"Satoruu",
+                        CountryCode = CountryCode.VE,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.B,
+                    Accuracy = 0.9826,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddHours(-25),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 2705430,
+                        Username = @"Mooha",
+                        CountryCode = CountryCode.FR,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.C,
+                    Accuracy = 0.9654,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddHours(-50),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 7151382,
+                        Username = @"Mayuri Hana",
+                        CountryCode = CountryCode.TH,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.D,
+                    Accuracy = 0.6025,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddHours(-72),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 2051389,
+                        Username = @"FunOrange",
+                        CountryCode = CountryCode.CA,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.D,
+                    Accuracy = 0.5140,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddMonths(-10),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 6169483,
+                        Username = @"-Hebel-",
+                        CountryCode = CountryCode.MX,
+                    },
+                },
+                new ScoreInfo
+                {
+                    Rank = ScoreRank.D,
+                    Accuracy = 0.4222,
+                    MaxCombo = 244,
+                    TotalScore = 1707827,
+                    Date = DateTime.Now.AddYears(-2),
+                    Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
+                    BeatmapInfo = beatmapInfo,
+                    BeatmapHash = beatmapInfo.Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+
+                    User = new APIUser
+                    {
+                        Id = 6702666,
+                        Username = @"prhtnsm",
+                        CountryCode = CountryCode.DE,
+                    },
+                },
+            };
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyRangeSlider.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyRangeSlider.cs
index 3cadbeb1e3..f97af65fd9 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyRangeSlider.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyRangeSlider.cs
@@ -59,7 +59,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     Scale = new Vector2(1),
                     LowerBound = customStart,
                     UpperBound = customEnd,
-                    TooltipSuffix = "suffix",
                     NubWidth = 32,
                     MinRange = 0.1f,
                 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
index 3dd6fed708..0ee742a09d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyStatisticsDisplay.cs
@@ -162,5 +162,23 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("statistics still visible", () => display.ChildrenOfType<BeatmapTitleWedge.StatisticDifficulty>().First().Parent!.Alpha == 1);
             AddAssert("tiny statistics still hidden", () => display.ChildrenOfType<GridContainer>().Last().Alpha == 0);
         }
+
+        [Test]
+        public void TestMaximumLength()
+        {
+            AddStep("setup auto size", () => Child = display = new BeatmapTitleWedge.DifficultyStatisticsDisplay(true)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            AddStep("set long statistics", () => display.Statistics = new[]
+            {
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 1", 0.2f, 0.2f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 2", 0.7f, 0.7f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 3", 0.4f, 0.8f, 1f),
+                new BeatmapTitleWedge.StatisticDifficulty.Data("Very Long Statistic 4", 0.3f, 0.3f, 1f),
+            });
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
index 8e27c395c8..c339f16bb4 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
@@ -48,6 +48,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddStep("modified", () => changeMods(new List<Mod> { new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } }));
             AddStep("modified + one", () => changeMods(new List<Mod> { new OsuModHidden(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } }));
             AddStep("modified + two", () => changeMods(new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } }));
+            AddStep("modified + five", () => changeMods(new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } }, new OsuModClassic(), new OsuModDifficultyAdjust(), new OsuModRandom() }));
+            AddStep("modified + six", () => changeMods(new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } }, new OsuModClassic(), new OsuModDifficultyAdjust(), new OsuModRandom(), new OsuModAlternate() }));
 
             AddStep("clear mods", () => changeMods(Array.Empty<Mod>()));
             AddWaitStep("wait", 3);
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
index 781691d3db..8156842eb9 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
@@ -23,23 +23,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             };
         });
 
-        [Test]
-        public void TestNullBeatmap()
-        {
-            AddStep("null beatmap", () => button.BeatmapSet = null);
-            AddAssert("button invisible", () => button.Alpha == 0f);
-        }
-
-        [Test]
-        public void TestUpdatedBeatmap()
-        {
-            AddStep("updated beatmap", () => button.BeatmapSet = new BeatmapSetInfo
-            {
-                Beatmaps = { new BeatmapInfo() }
-            });
-            AddAssert("button invisible", () => button.Alpha == 0f);
-        }
-
         [Test]
         public void TestNonUpdatedBeatmap()
         {
@@ -58,5 +41,22 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddAssert("button visible", () => button.Alpha == 1f);
         }
+
+        [Test]
+        public void TestNullBeatmap()
+        {
+            AddStep("null beatmap", () => button.BeatmapSet = null);
+            AddAssert("button invisible", () => button.Alpha == 0f);
+        }
+
+        [Test]
+        public void TestUpdatedBeatmap()
+        {
+            AddStep("updated beatmap", () => button.BeatmapSet = new BeatmapSetInfo
+            {
+                Beatmaps = { new BeatmapInfo() }
+            });
+            AddAssert("button invisible", () => button.Alpha == 0f);
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
index bdecebd64f..e247b92f52 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
@@ -114,11 +114,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddWaitStep("wait for transition", 3);
 
             AddStep("show overlay", () => externalOverlay.Show());
-            AddAssert("content displayed in footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
+            contentDisplayed();
             AddUntilStep("other buttons hidden", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
 
             AddStep("hide overlay", () => externalOverlay.Hide());
-            AddUntilStep("content hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
+            contentHidden();
             AddUntilStep("other buttons returned", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
         }
 
@@ -133,11 +133,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddStep("add external overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
             AddStep("show external overlay", () => externalOverlay.Show());
             AddAssert("footer shown", () => screenFooter.State.Value == Visibility.Visible);
-            AddAssert("content displayed in footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
+            contentDisplayed();
 
             AddStep("hide external overlay", () => externalOverlay.Hide());
             AddAssert("footer hidden", () => screenFooter.State.Value == Visibility.Hidden);
-            AddUntilStep("content hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
+            contentHidden();
 
             AddStep("show footer", () => screenFooter.Show());
             AddAssert("content still hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
@@ -216,17 +216,27 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddWaitStep("wait for transition", 3);
 
             AddStep("show overlay", () => externalOverlay.Show());
-            AddAssert("content displayed in footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
+            contentDisplayed();
             AddUntilStep("other buttons hidden", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
 
             AddStep("resize active button", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(240, 300, Easing.OutQuint));
             AddStep("resize active button back", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(116, 300, Easing.OutQuint));
 
             AddStep("hide overlay", () => externalOverlay.Hide());
-            AddUntilStep("content hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
+            contentHidden();
             AddUntilStep("other buttons returned", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
         }
 
+        private void contentHidden()
+        {
+            AddUntilStep("content hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
+        }
+
+        private void contentDisplayed()
+        {
+            AddUntilStep("content displayed in footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
+        }
+
         private partial class TestShearedOverlayContainer : ShearedOverlayContainer
         {
             public TestShearedOverlayContainer()
@@ -261,7 +271,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 [BackgroundDependencyLoader]
                 private void load()
                 {
-                    RelativeSizeAxes = Axes.Both;
+                    AutoSizeAxes = Axes.Both;
 
                     InternalChild = new FillFlowContainer
                     {
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
index dcd745395b..69bdb97617 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Online.API;
 using osu.Game.Overlays.Dialog;
 using osu.Game.Overlays.Mods;
@@ -25,6 +26,7 @@ using osu.Game.Screens.SelectV2;
 using osuTK.Input;
 using FooterButtonMods = osu.Game.Screens.SelectV2.FooterButtonMods;
 using FooterButtonOptions = osu.Game.Screens.SelectV2.FooterButtonOptions;
+using FooterButtonRandom = osu.Game.Screens.SelectV2.FooterButtonRandom;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
@@ -105,6 +107,39 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             void onScreenPushed(IScreen lastScreen, IScreen newScreen) => screensPushed.Add(lastScreen);
         }
 
+        [Test]
+        public void TestInvalidRulesetDoesNotEnterGameplay()
+        {
+            var screensPushed = new List<IScreen>();
+
+            ImportBeatmapForRuleset(0);
+            ImportBeatmapForRuleset(1);
+
+            LoadSongSelect();
+            AddStep("subscribe to screen pushed", () => Stack.ScreenPushed += onScreenPushed);
+
+            AddStep("change ruleset to taiko", () => Ruleset.Value = Rulesets.AvailableRulesets.Single(r => r.OnlineID == 1));
+
+            AddStep("disable converts", () => Config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
+
+            AddUntilStep("wait for taiko beatmap selected", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(1));
+
+            AddStep("change ruleset back and start gameplay immediately", () =>
+            {
+                Ruleset.Value = Rulesets.AvailableRulesets.Single(r => r.OnlineID == 0);
+
+                InputManager.MoveMouseTo(this.ChildrenOfType<OsuLogo>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("no screens pushed", () => screensPushed, () => Is.Empty);
+            AddStep("unsubscribe from screen pushed", () => Stack.ScreenPushed -= onScreenPushed);
+
+            AddUntilStep("wait for osu beatmap selected", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(0));
+
+            void onScreenPushed(IScreen lastScreen, IScreen newScreen) => screensPushed.Add(lastScreen);
+        }
+
         #region Hotkeys
 
         [Test]
@@ -417,71 +452,113 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddStep("Hide", () => this.ChildrenOfType<ModSelectOverlay>().Single().Hide());
         }
 
-        // add these test cases when functionality is implemented.
-        // [Test]
-        // public void TestFooterRandom()
-        // {
-        //     loadSongSelect();
-        //
-        //     AddStep("press F2", () => InputManager.Key(Key.F2));
-        //     AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
-        // }
-        //
-        // [Test]
-        // public void TestFooterRandomViaMouse()
-        // {
-        //     loadSongSelect();
-        //
-        //     AddStep("click button", () =>
-        //     {
-        //         InputManager.MoveMouseTo(randomButton);
-        //         InputManager.Click(MouseButton.Left);
-        //     });
-        //     AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
-        // }
-        //
-        // [Test]
-        // public void TestFooterRewind()
-        // {
-        //     loadSongSelect();
-        //
-        //     AddStep("press Shift+F2", () =>
-        //     {
-        //         InputManager.PressKey(Key.LShift);
-        //         InputManager.PressKey(Key.F2);
-        //         InputManager.ReleaseKey(Key.F2);
-        //         InputManager.ReleaseKey(Key.LShift);
-        //     });
-        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        // }
-        //
-        // [Test]
-        // public void TestFooterRewindViaShiftMouseLeft()
-        // {
-        //     loadSongSelect();
-        //
-        //     AddStep("shift + click button", () =>
-        //     {
-        //         InputManager.PressKey(Key.LShift);
-        //         InputManager.MoveMouseTo(randomButton);
-        //         InputManager.Click(MouseButton.Left);
-        //         InputManager.ReleaseKey(Key.LShift);
-        //     });
-        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        // }
-        //
-        // [Test]
-        // public void TestFooterRewindViaMouseRight()
-        // {
-        //     loadSongSelect();
-        //
-        //     AddStep("right click button", () =>
-        //     {
-        //         InputManager.MoveMouseTo(randomButton);
-        //         InputManager.Click(MouseButton.Right);
-        //     });
-        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        // }
+        [Test]
+        public void TestFooterRandom()
+        {
+            LoadSongSelect();
+
+            bool nextRandomCalled = false;
+            bool previousRandomCalled = false;
+            AddStep("hook events", () =>
+            {
+                randomButton.NextRandom = () => nextRandomCalled = true;
+                randomButton.PreviousRandom = () => previousRandomCalled = true;
+            });
+
+            AddStep("press F2", () => InputManager.Key(Key.F2));
+            AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
+        }
+
+        [Test]
+        public void TestFooterRandomViaMouse()
+        {
+            LoadSongSelect();
+
+            bool nextRandomCalled = false;
+            bool previousRandomCalled = false;
+            AddStep("hook events", () =>
+            {
+                randomButton.NextRandom = () => nextRandomCalled = true;
+                randomButton.PreviousRandom = () => previousRandomCalled = true;
+            });
+
+            AddStep("click button", () =>
+            {
+                InputManager.MoveMouseTo(randomButton);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
+        }
+
+        [Test]
+        public void TestFooterRewind()
+        {
+            LoadSongSelect();
+
+            bool nextRandomCalled = false;
+            bool previousRandomCalled = false;
+            AddStep("hook events", () =>
+            {
+                randomButton.NextRandom = () => nextRandomCalled = true;
+                randomButton.PreviousRandom = () => previousRandomCalled = true;
+            });
+
+            AddStep("press Shift+F2", () =>
+            {
+                InputManager.PressKey(Key.LShift);
+                InputManager.PressKey(Key.F2);
+                InputManager.ReleaseKey(Key.F2);
+                InputManager.ReleaseKey(Key.LShift);
+            });
+
+            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        }
+
+        [Test]
+        public void TestFooterRewindViaShiftMouseLeft()
+        {
+            LoadSongSelect();
+
+            bool nextRandomCalled = false;
+            bool previousRandomCalled = false;
+            AddStep("hook events", () =>
+            {
+                randomButton.NextRandom = () => nextRandomCalled = true;
+                randomButton.PreviousRandom = () => previousRandomCalled = true;
+            });
+
+            AddStep("shift + click button", () =>
+            {
+                InputManager.PressKey(Key.LShift);
+                InputManager.MoveMouseTo(randomButton);
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.LShift);
+            });
+            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        }
+
+        [Test]
+        public void TestFooterRewindViaMouseRight()
+        {
+            LoadSongSelect();
+
+            bool nextRandomCalled = false;
+            bool previousRandomCalled = false;
+            AddStep("hook events", () =>
+            {
+                randomButton.NextRandom = () => nextRandomCalled = true;
+                randomButton.PreviousRandom = () => previousRandomCalled = true;
+            });
+
+            AddStep("right click button", () =>
+            {
+                InputManager.MoveMouseTo(randomButton);
+                InputManager.Click(MouseButton.Right);
+            });
+            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        }
+
+        private FooterButtonRandom randomButton => Footer.ChildrenOfType<FooterButtonRandom>().Single();
 
         [Test]
         public void TestFooterOptions()
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
index 4665262097..19fccdf94d 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
 using FilterControl = osu.Game.Screens.SelectV2.FilterControl;
 using NoResultsPlaceholder = osu.Game.Screens.SelectV2.NoResultsPlaceholder;
 
@@ -65,6 +66,28 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("filter count is 0", () => filterOperationsCount, () => Is.EqualTo(0));
         }
 
+        [Test]
+        public void TestFilterSingleResult_RetainsSelectedDifficulty()
+        {
+            LoadSongSelect();
+
+            ImportBeatmapForRuleset(0);
+
+            AddUntilStep("wait for single set", () => Carousel.ChildrenOfType<PanelBeatmapSet>().Count(), () => Is.EqualTo(1));
+
+            AddStep("select last difficulty", () =>
+            {
+                Beatmap.Value = Beatmaps.GetWorkingBeatmap(Beatmaps.GetAllUsableBeatmapSets().First().Beatmaps.Last());
+            });
+
+            AddStep("set filter text", () => filterTextBox.Current.Value = " ");
+
+            AddWaitStep("wait for debounce", 5);
+            AddUntilStep("wait for filter", () => !Carousel.IsFiltering);
+
+            AddAssert("selection unchanged", () => Beatmap.Value.BeatmapInfo, () => Is.EqualTo(Beatmaps.GetAllUsableBeatmapSets().First().Beatmaps.Last()));
+        }
+
         [Test]
         public void TestFilterOnResumeAfterChange()
         {
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneGhostIcon.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneGhostIcon.cs
new file mode 100644
index 0000000000..5ae46d0224
--- /dev/null
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneGhostIcon.cs
@@ -0,0 +1,22 @@
+// 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.Game.Graphics;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public partial class TestSceneGhostIcon : OsuTestScene
+    {
+        public TestSceneGhostIcon()
+        {
+            Add(new GhostIcon
+            {
+                Size = new Vector2(64),
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingLayer.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingLayer.cs
index dc40ecde43..66bf870f90 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingLayer.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingLayer.cs
@@ -67,11 +67,11 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("show", () => overlay.Show());
 
-            AddUntilStep("wait for content dim", () => overlay.BackgroundDimLayer.Alpha > 0);
+            AddUntilStep("wait for content dim", () => overlay.Alpha > 0);
 
             AddStep("hide", () => overlay.Hide());
 
-            AddUntilStep("wait for content restore", () => Precision.AlmostEquals(overlay.BackgroundDimLayer.Alpha, 0));
+            AddUntilStep("wait for content restore", () => Precision.AlmostEquals(overlay.Alpha, 0));
         }
 
         [Test]
@@ -90,8 +90,6 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private partial class TestLoadingLayer : LoadingLayer
         {
-            public new Box BackgroundDimLayer => base.BackgroundDimLayer;
-
             public TestLoadingLayer(bool dimBackground = false, bool withBox = true)
                 : base(dimBackground, withBox)
             {
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingSpinner.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingSpinner.cs
index bd36be846b..b3d943b93d 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingSpinner.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneLoadingSpinner.cs
@@ -11,7 +11,7 @@ namespace osu.Game.Tests.Visual.UserInterface
     public partial class TestSceneLoadingSpinner : OsuGridTestScene
     {
         public TestSceneLoadingSpinner()
-            : base(2, 2)
+            : base(2, 3)
         {
             LoadingSpinner loading;
 
@@ -52,6 +52,29 @@ namespace osu.Game.Tests.Visual.UserInterface
             loading.Show();
 
             Cell(3).AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = Color4.White,
+                    RelativeSizeAxes = Axes.Both
+                },
+                loading = new LoadingSpinner(false, true)
+            });
+
+            loading.Show();
+
+            Cell(4).AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    Colour = Color4.Black,
+                    RelativeSizeAxes = Axes.Both
+                },
+                loading = new LoadingSpinner(true, true)
+            });
+            loading.Show();
+
+            Cell(5).AddRange(new Drawable[]
             {
                 loading = new LoadingSpinner()
             });
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneLogoTrackingContainer.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneLogoTrackingContainer.cs
index 8d5c961265..931b5afa12 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneLogoTrackingContainer.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneLogoTrackingContainer.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Linq;
+using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -28,6 +29,9 @@ namespace osu.Game.Tests.Visual.UserInterface
         private Drawable logoFacade;
         private bool randomPositions;
 
+        [CanBeNull]
+        private IDisposable logoTracking;
+
         private const float visual_box_size = 72;
 
         [SetUpSteps]
@@ -150,14 +154,15 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("Perform logo movements", () =>
             {
-                trackingContainer.StopTracking();
+                logoTracking?.Dispose();
+
                 logo.MoveTo(new Vector2(0.5f), 500, Easing.InOutExpo);
 
                 visualBox.Colour = Color4.White;
 
                 Scheduler.AddDelayed(() =>
                 {
-                    trackingContainer.StartTracking(logo, 1000, Easing.InOutExpo);
+                    logoTracking = trackingContainer.StartTracking(logo, 1000, Easing.InOutExpo);
                     visualBox.Colour = Color4.Tomato;
                 }, 700);
             });
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
index 65c8b913d3..3648291816 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
@@ -456,7 +457,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             {
                 applyUpdate = false;
 
-                var updateNotification = new UpdateManager.UpdateProgressNotification
+                var updateNotification = new UpdateManager.UpdateDownloadProgressNotification(CancellationToken.None)
                 {
                     CompletionClickAction = () => applyUpdate = true
                 };
@@ -468,9 +469,9 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkProgressingCount(1);
             waitForCompletion();
 
-            UpdateManager.UpdateApplicationCompleteNotification? completionNotification = null;
+            UpdateManager.UpdateReadyNotification? completionNotification = null;
             AddUntilStep("wait for completion notification",
-                () => (completionNotification = notificationOverlay.ChildrenOfType<UpdateManager.UpdateApplicationCompleteNotification>().SingleOrDefault()) != null);
+                () => (completionNotification = notificationOverlay.ChildrenOfType<UpdateManager.UpdateReadyNotification>().SingleOrDefault()) != null);
             AddStep("click notification", () => completionNotification?.TriggerClick());
 
             AddUntilStep("wait for update applied", () => applyUpdate);
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneShearedRangeSlider.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneShearedRangeSlider.cs
index 21fa82eda8..fdc5b5948a 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneShearedRangeSlider.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneShearedRangeSlider.cs
@@ -64,7 +64,6 @@ namespace osu.Game.Tests.Visual.UserInterface
                     Scale = new Vector2(1),
                     LowerBound = customStart,
                     UpperBound = customEnd,
-                    TooltipSuffix = "suffix",
                     NubWidth = 32,
                     DefaultStringLowerBound = "0.0",
                     DefaultStringUpperBound = "∞",
diff --git a/osu.Game.Tests/WaveformTestBeatmap.cs b/osu.Game.Tests/WaveformTestBeatmap.cs
index 12660ed2e1..2da54eb055 100644
--- a/osu.Game.Tests/WaveformTestBeatmap.cs
+++ b/osu.Game.Tests/WaveformTestBeatmap.cs
@@ -39,12 +39,6 @@ namespace osu.Game.Tests
             trackStore = audioManager.GetTrackStore(getZipReader());
         }
 
-        ~WaveformTestBeatmap()
-        {
-            // Remove the track store from the audio manager
-            trackStore?.Dispose();
-        }
-
         private static Stream getStream() => TestResources.GetTestBeatmapStream();
 
         private static ZipArchiveReader getZipReader() => new ZipArchiveReader(getStream());
diff --git a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
index 25f98c812c..d25a171023 100644
--- a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
+++ b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
@@ -64,6 +64,20 @@ namespace osu.Game.Beatmaps
 
         private static string getVersionString(IBeatmapInfo beatmapInfo) => string.IsNullOrEmpty(beatmapInfo.DifficultyName) ? string.Empty : $"[{beatmapInfo.DifficultyName}]";
 
+        /// <summary>
+        /// Whether gameplay is allowed for this beatmap with the provided ruleset (via conversion or direct compatibility).
+        /// </summary>
+        public static bool AllowGameplayWithRuleset(this IBeatmapInfo beatmap, RulesetInfo ruleset, bool allowConversion)
+        {
+            if (beatmap.Ruleset.ShortName == ruleset.ShortName)
+                return true;
+
+            if (allowConversion && beatmap.Ruleset.OnlineID == 0 && ruleset.OnlineID != 0)
+                return true;
+
+            return false;
+        }
+
         /// <summary>
         /// Get the beatmap info page URL, or <c>null</c> if unavailable.
         /// </summary>
diff --git a/osu.Game/Beatmaps/Drawables/Cards/IconPill.cs b/osu.Game/Beatmaps/Drawables/Cards/IconPill.cs
index 16be57ac95..7cdd50e7ea 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/IconPill.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/IconPill.cs
@@ -20,6 +20,12 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             set => iconContainer.Size = value;
         }
 
+        public MarginPadding IconPadding
+        {
+            get => iconContainer.Padding;
+            set => iconContainer.Padding = value;
+        }
+
         private readonly Container iconContainer;
 
         protected IconPill(IconUsage icon)
diff --git a/osu.Game/Beatmaps/Formats/LegacyDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
index 6c290c4f1c..6fb762b9ee 100644
--- a/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
@@ -16,6 +16,8 @@ namespace osu.Game.Beatmaps.Formats
     public abstract class LegacyDecoder<T> : Decoder<T>
         where T : new()
     {
+        // If this is updated, a new release of `osu-server-beatmap-submission` is required with updated packages.
+        // See usage at https://github.com/ppy/osu-server-beatmap-submission/blob/master/osu.Server.BeatmapSubmission/Services/BeatmapPackageParser.cs#L96-L97.
         public const int LATEST_VERSION = 14;
 
         public const int MAX_COMBO_COLOUR_COUNT = 8;
diff --git a/osu.Game/Beatmaps/IBeatmapDifficultyInfo.cs b/osu.Game/Beatmaps/IBeatmapDifficultyInfo.cs
index 48f6564084..2dd73a2541 100644
--- a/osu.Game/Beatmaps/IBeatmapDifficultyInfo.cs
+++ b/osu.Game/Beatmaps/IBeatmapDifficultyInfo.cs
@@ -92,8 +92,8 @@ namespace osu.Game.Beatmaps
         /// </list>
         /// </param>
         /// <returns>Value to which the difficulty value maps in the specified range.</returns>
-        static double DifficultyRange(double difficulty, (double od0, double od5, double od10) range)
-            => DifficultyRange(difficulty, range.od0, range.od5, range.od10);
+        static double DifficultyRange(double difficulty, DifficultyRange range)
+            => DifficultyRange(difficulty, range.Min, range.Mid, range.Max);
 
         /// <summary>
         /// Inverse function to <see cref="DifficultyRange(double,double,double,double)"/>.
@@ -110,5 +110,23 @@ namespace osu.Game.Beatmaps
                 ? (difficultyValue - diff5) / (diff10 - diff5) * 5 + 5
                 : (difficultyValue - diff5) / (diff5 - diff0) * 5 + 5;
         }
+
+        /// <summary>
+        /// Inverse function to <see cref="DifficultyRange(double,osu.Game.Beatmaps.DifficultyRange)"/>.
+        /// Maps a value returned by the function above back to the difficulty that produced it.
+        /// </summary>
+        /// <param name="difficultyValue">The difficulty-dependent value to be unmapped.</param>
+        /// <param name="range">Minimum of the resulting range which will be achieved by a difficulty value of 0.</param>
+        /// <returns>Value to which the difficulty value maps in the specified range.</returns>
+        static double InverseDifficultyRange(double difficultyValue, DifficultyRange range)
+            => InverseDifficultyRange(difficultyValue, range.Min, range.Mid, range.Max);
     }
+
+    /// <summary>
+    /// Represents a piecewise-linear difficulty curve for a given gameplay quantity.
+    /// </summary>
+    /// <param name="Min">Minimum of the resulting range which will be achieved by a difficulty value of 0.</param>
+    /// <param name="Mid">Midpoint of the resulting range which will be achieved by a difficulty value of 5.</param>
+    /// <param name="Max">Maximum of the resulting range which will be achieved by a difficulty value of 10.</param>
+    public record struct DifficultyRange(double Min, double Mid, double Max);
 }
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index b0f6082406..4ea26b46f8 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -124,18 +124,16 @@ namespace osu.Game.Beatmaps
             Track.Looping = looping;
             Track.RestartPoint = Metadata.PreviewTime;
 
-            if (Track.RestartPoint == -1)
+            if (!Track.IsLoaded)
             {
-                if (!Track.IsLoaded)
-                {
-                    // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
-                    Track.Seek(Track.CurrentTime);
-                }
-
-                Track.RestartPoint = 0.4f * Track.Length;
+                // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
+                Track.Seek(Track.CurrentTime);
             }
 
-            Track.RestartPoint += offsetFromPreviewPoint;
+            if (Track.RestartPoint < 0 || Track.RestartPoint > Track.Length)
+                Track.RestartPoint = 0.4f * Track.Length;
+
+            Track.RestartPoint = Math.Clamp(Track.RestartPoint + offsetFromPreviewPoint, 0, Track.Length);
         }
 
         /// <summary>
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index df3e7d88af..bca905e7bb 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -63,7 +63,7 @@ namespace osu.Game.Configuration
 
             SetDefault(OsuSetting.ToolbarClockDisplayMode, ToolbarClockDisplayMode.Full);
 
-            SetDefault(OsuSetting.SongSelectBackgroundBlur, true);
+            SetDefault(OsuSetting.SongSelectBackgroundBlur, false);
 
             // Online settings
             SetDefault(OsuSetting.Username, string.Empty);
diff --git a/osu.Game/Configuration/SessionStatics.cs b/osu.Game/Configuration/SessionStatics.cs
index b816d1a88b..59e107a23e 100644
--- a/osu.Game/Configuration/SessionStatics.cs
+++ b/osu.Game/Configuration/SessionStatics.cs
@@ -8,6 +8,8 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
 using osu.Game.Users;
 
 namespace osu.Game.Configuration
@@ -25,6 +27,7 @@ namespace osu.Game.Configuration
             SetDefault(Static.FeaturedArtistDisclaimerShownOnce, false);
             SetDefault(Static.LastHoverSoundPlaybackTime, (double?)null);
             SetDefault(Static.LastModSelectPanelSamplePlaybackTime, (double?)null);
+            SetDefault(Static.LastRankChangeSamplePlaybackTime, (double?)null);
             SetDefault<APISeasonalBackgrounds?>(Static.SeasonalBackgrounds, null);
             SetDefault(Static.TouchInputActive, RuntimeInfo.IsMobile);
             SetDefault<ScoreInfo?>(Static.LastLocalUserScore, null);
@@ -72,6 +75,12 @@ namespace osu.Game.Configuration
         /// </summary>
         LastModSelectPanelSamplePlaybackTime,
 
+        /// <summary>
+        /// The last playback time in milliseconds of a rank up/down sample (in <see cref="DefaultRankDisplay"/> and <see cref="LegacyRankDisplay"/>).
+        /// Used to debounce rank change sounds game-wide to avoid potential volume saturation from multiple simultaneous playback.
+        /// </summary>
+        LastRankChangeSamplePlaybackTime,
+
         /// <summary>
         /// Whether the last positional input received was a touch input.
         /// Used in touchscreen detection scenarios (<see cref="TouchInputInterceptor"/>).
diff --git a/osu.Game/Database/LegacySkinExporter.cs b/osu.Game/Database/LegacySkinExporter.cs
index 14a3907916..98c4c5dbea 100644
--- a/osu.Game/Database/LegacySkinExporter.cs
+++ b/osu.Game/Database/LegacySkinExporter.cs
@@ -13,6 +13,8 @@ namespace osu.Game.Database
         {
         }
 
+        protected override bool UseFixedEncoding => false;
+
         protected override string FileExtension => @".osk";
     }
 }
diff --git a/osu.Game/Database/ModelManager.cs b/osu.Game/Database/ModelManager.cs
index 7a5fb5efbf..e96a8cc1b1 100644
--- a/osu.Game/Database/ModelManager.cs
+++ b/osu.Game/Database/ModelManager.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using osu.Framework.Extensions;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
@@ -85,6 +86,7 @@ namespace osu.Game.Database
         /// </summary>
         public void AddFile(TModel item, Stream contents, string filename, Realm realm)
         {
+            filename = filename.ToStandardisedPath();
             var existing = item.GetFile(filename);
 
             if (existing != null)
diff --git a/osu.Game/Database/RealmAccess.cs b/osu.Game/Database/RealmAccess.cs
index 7142f2b300..59cbfcb1e3 100644
--- a/osu.Game/Database/RealmAccess.cs
+++ b/osu.Game/Database/RealmAccess.cs
@@ -98,8 +98,9 @@ namespace osu.Game.Database
         /// 46   2024-12-26    Change beat snap divisor bindings to match stable directionality ¯\_(ツ)_/¯.
         /// 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.
         /// </summary>
-        private const int schema_version = 48;
+        private const int schema_version = 49;
 
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking realm retrieval during blocking periods.
@@ -542,6 +543,44 @@ namespace osu.Game.Database
             return writeTask;
         }
 
+        /// <summary>
+        /// Write changes to realm asynchronously, guaranteeing order of execution.
+        /// </summary>
+        /// <param name="action">The work to run.</param>
+        public Task<T> WriteAsync<T>(Func<Realm, T> action)
+        {
+            ObjectDisposedException.ThrowIf(isDisposed, this);
+
+            // Required to ensure the write is tracked and accounted for before disposal.
+            // Can potentially be avoided if we have a need to do so in the future.
+            if (!ThreadSafety.IsUpdateThread)
+                throw new InvalidOperationException(@$"{nameof(WriteAsync)} must be called from the update thread.");
+
+            // CountdownEvent will fail if already at zero.
+            if (!pendingAsyncWrites.TryAddCount())
+                pendingAsyncWrites.Reset(1);
+
+            // Regardless of calling Realm.GetInstance or Realm.GetInstanceAsync, there is a blocking overhead on retrieval.
+            // Adding a forced Task.Run resolves this.
+            var writeTask = Task.Run(async () =>
+            {
+                T result;
+                total_writes_async.Value++;
+
+                // Not attempting to use Realm.GetInstanceAsync as there's seemingly no benefit to us (for now) and it adds complexity due to locking
+                // concerns in getRealmInstance(). On a quick check, it looks to be more suited to cases where realm is connecting to an online sync
+                // server, which we don't use. May want to report upstream or revisit in the future.
+                using (var realm = getRealmInstance())
+                    // ReSharper disable once AccessToDisposedClosure (WriteAsync should be marked as [InstantHandle]).
+                    result = await realm.WriteAsync(() => action(realm)).ConfigureAwait(false);
+
+                pendingAsyncWrites.Signal();
+                return result;
+            });
+
+            return writeTask;
+        }
+
         /// <summary>
         /// Subscribe to a realm collection and begin watching for asynchronous changes.
         /// </summary>
@@ -1255,6 +1294,12 @@ namespace osu.Game.Database
                     foreach (var beatmap in beatmaps)
                         beatmap.ResetOnlineInfo(resetOnlineId: false);
                     break;
+
+                case 49:
+                    foreach (var score in migration.NewRealm.All<ScoreInfo>().Where(s => s.LegacyOnlineID == 0))
+                        score.LegacyOnlineID = -1;
+
+                    break;
             }
 
             Logger.Log($"Migration completed in {stopwatch.ElapsedMilliseconds}ms");
diff --git a/osu.Game/Database/RealmObjectExtensions.cs b/osu.Game/Database/RealmObjectExtensions.cs
index 538ac1dff7..d43f90c292 100644
--- a/osu.Game/Database/RealmObjectExtensions.cs
+++ b/osu.Game/Database/RealmObjectExtensions.cs
@@ -14,6 +14,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Models;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
+using osu.Game.Skinning;
 using Realms;
 
 namespace osu.Game.Database
@@ -177,6 +178,7 @@ namespace osu.Game.Database
             c.CreateMap<RealmUser, RealmUser>();
             c.CreateMap<RealmFile, RealmFile>();
             c.CreateMap<RealmNamedFileUsage, RealmNamedFileUsage>();
+            c.CreateMap<SkinInfo, SkinInfo>();
         }
 
         /// <summary>
diff --git a/osu.Game/Extensions/ModelExtensions.cs b/osu.Game/Extensions/ModelExtensions.cs
index ec6b5ac6de..18c991297a 100644
--- a/osu.Game/Extensions/ModelExtensions.cs
+++ b/osu.Game/Extensions/ModelExtensions.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.IO;
-using System.Text.RegularExpressions;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.IO;
@@ -16,8 +15,6 @@ namespace osu.Game.Extensions
 {
     public static class ModelExtensions
     {
-        private static readonly Regex invalid_filename_chars = new Regex(@"(?!$)[^A-Za-z0-9_()[\]. \-]", RegexOptions.Compiled);
-
         /// <summary>
         /// Get the relative path in osu! storage for this file.
         /// </summary>
@@ -156,15 +153,34 @@ namespace osu.Game.Extensions
             return instance.OnlineID.Equals(other.OnlineID);
         }
 
+        // intentionally chosen to match stable.
+        // see https://referencesource.microsoft.com/#mscorlib/system/io/path.cs,88
+        private static readonly char[] invalid_filename_chars =
+        {
+            '\"', '<', '>', '|', '\0', (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10, (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17,
+            (char)18, (char)19, (char)20, (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30, (char)31, ':', '*', '?', '\\', '/'
+        };
+
         /// <summary>
         /// Create a valid filename which should work across all platforms.
         /// </summary>
         /// <remarks>
-        /// This function replaces all characters not included in a very pessimistic list which should be compatible
-        /// across all operating systems. We are using this in place of <see cref="Path.GetInvalidFileNameChars"/> as
-        /// that function does not have per-platform considerations (and is only made to work on windows).
+        /// <para>
+        /// We are using this in place of <see cref="Path.GetInvalidFileNameChars"/>
+        /// as that function works per-platform, and therefore returns a different set of characters on different OSes.
+        /// </para>
+        /// <para>
+        /// Note that the behaviour of this method is LOAD-BEARING for things such as interoperability of beatmap exports with stable,
+        /// especially with respect to beatmap submission.
+        /// DO NOT CHANGE THE SEMANTICS OF THIS METHOD unless you know well what you are doing.
+        /// </para>
         /// </remarks>
-        public static string GetValidFilename(this string filename) => invalid_filename_chars.Replace(filename, "_");
+        public static string GetValidFilename(this string filename)
+        {
+            foreach (char c in invalid_filename_chars)
+                filename = filename.Replace(c.ToString(), string.Empty);
+            return filename;
+        }
 
         public static bool RequiresSupporter(this BeatmapLeaderboardScope scope, bool filterMods)
         {
diff --git a/osu.Game/Graphics/Carousel/Carousel.cs b/osu.Game/Graphics/Carousel/Carousel.cs
index 8db0c683c2..b0e2ad428e 100644
--- a/osu.Game/Graphics/Carousel/Carousel.cs
+++ b/osu.Game/Graphics/Carousel/Carousel.cs
@@ -13,6 +13,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Development;
+using osu.Framework.Extensions.PolygonExtensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -107,7 +108,7 @@ namespace osu.Game.Graphics.Carousel
             get => currentSelection.Model;
             set
             {
-                if (currentSelection.Model != value)
+                if (!CheckModelEquality(currentSelection.Model, value))
                 {
                     HandleItemSelected(value);
 
@@ -209,7 +210,7 @@ namespace osu.Game.Graphics.Carousel
         /// <summary>
         /// Check whether two models are the same for display purposes.
         /// </summary>
-        protected virtual bool CheckModelEquality(object x, object y) => ReferenceEquals(x, y);
+        protected virtual bool CheckModelEquality(object? x, object? y) => ReferenceEquals(x, y);
 
         /// <summary>
         /// Create a drawable for the given carousel item so it can be displayed.
@@ -237,17 +238,30 @@ namespace osu.Game.Graphics.Carousel
         /// </summary>
         /// <param name="item">The candidate item.</param>
         /// <returns>Whether the provided item is a valid group target. If <c>false</c>, more panels will be checked in the user's requested direction until a valid target is found.</returns>
-        protected virtual bool CheckValidForGroupSelection(CarouselItem item) => true;
+        protected virtual bool CheckValidForGroupSelection(CarouselItem item) => false;
+
+        /// <summary>
+        /// When a user is traversing the carousel via set selection keys, assert whether the item provided is a valid target.
+        /// </summary>
+        /// <param name="item">The candidate item.</param>
+        /// <returns>Whether the provided item is a valid set target. If <c>false</c>, more panels will be checked in the user's requested direction until a valid target is found.</returns>
+        protected virtual bool CheckValidForSetSelection(CarouselItem item) => true;
+
+        /// <summary>
+        /// Keyboard selection usually does not automatically activate an item. There may be exceptions to this rule.
+        /// Returning <c>true</c> here will make keyboard traversal act like set traversal for the target item.
+        /// </summary>
+        protected virtual bool ShouldActivateOnKeyboardSelection(CarouselItem item) => false;
 
         /// <summary>
         /// Called after an item becomes the <see cref="CurrentSelection"/>.
-        /// Should be used to handle any group expansion, item visibility changes, etc.
+        /// Should be used to handle any set expansion, item visibility changes, etc.
         /// </summary>
         protected virtual void HandleItemSelected(object? model) { }
 
         /// <summary>
         /// Called when the <see cref="CurrentSelection"/> changes to a new selection.
-        /// Should be used to handle any group expansion, item visibility changes, etc.
+        /// Should be used to handle any set expansion, item visibility changes, etc.
         /// </summary>
         protected virtual void HandleItemDeselected(object? model) { }
 
@@ -293,7 +307,7 @@ namespace osu.Game.Graphics.Carousel
         /// <summary>
         /// Retrieve a list of all <see cref="CarouselItem"/>s currently displayed.
         /// </summary>
-        protected IReadOnlyCollection<CarouselItem>? GetCarouselItems() => carouselItems;
+        public IReadOnlyCollection<CarouselItem>? GetCarouselItems() => carouselItems;
 
         private List<CarouselItem>? carouselItems;
 
@@ -395,6 +409,15 @@ namespace osu.Game.Graphics.Carousel
             offset += spacing;
             item.CarouselYPosition = offset;
 
+            // ensure there are no input gaps where clicking will fall through the carousel.
+            // notably, only do this where there's positive spacing between panels (negative spacing means they overlap already and there is no gap to fill).
+            if (spacing > 0)
+            {
+                item.CarouselInputLenienceAbove = spacing / 2;
+                if (previousVisible != null)
+                    previousVisible.CarouselInputLenienceBelow = item.CarouselInputLenienceAbove;
+            }
+
             if (item.IsVisible)
             {
                 offset += item.DrawHeight;
@@ -435,27 +458,88 @@ namespace osu.Game.Graphics.Carousel
                 // if the selection is changed more than once during an update frame,
                 // which can happen if repeat inputs are enqueued for processing at a rate faster than the update refresh rate.
                 // `refreshAfterSelection()` is the method responsible for updating the index of the selected item here which runs once per frame.
+                case GlobalAction.SelectPrevious:
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Keyboard, -1));
+                    return true;
 
                 case GlobalAction.SelectNext:
-                    Scheduler.AddOnce(traverseKeyboardSelection, 1);
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Keyboard, 1));
                     return true;
 
-                case GlobalAction.SelectPrevious:
-                    Scheduler.AddOnce(traverseKeyboardSelection, -1);
+                case GlobalAction.ActivatePreviousSet:
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Set, -1));
                     return true;
 
-                case GlobalAction.SelectNextGroup:
-                    Scheduler.AddOnce(traverseGroupSelection, 1);
+                case GlobalAction.ActivateNextSet:
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Set, 1));
                     return true;
 
-                case GlobalAction.SelectPreviousGroup:
-                    Scheduler.AddOnce(traverseGroupSelection, -1);
+                case GlobalAction.ExpandPreviousGroup:
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Group, -1));
+                    return true;
+
+                case GlobalAction.ExpandNextGroup:
+                    Scheduler.AddOnce(traverseFromKey, new TraversalOperation(TraversalType.Group, 1));
+                    return true;
+
+                case GlobalAction.ToggleCurrentGroup:
+                    if (carouselItems == null || carouselItems.Count == 0)
+                        return true;
+
+                    if (currentKeyboardSelection.CarouselItem == null || currentKeyboardSelection.Index == null)
+                        return true;
+
+                    if (CheckValidForGroupSelection(currentKeyboardSelection.CarouselItem))
+                    {
+                        // If keyboard selection is a group, toggle group and then change keyboard selection to actual selection.
+                        Activate(currentKeyboardSelection.CarouselItem);
+                    }
+                    else
+                    {
+                        // If current keyboard selection is not a group, toggle the closest group and move keyboard selection to that group.
+                        for (int i = currentKeyboardSelection.Index.Value; i >= 0; i--)
+                        {
+                            var newItem = carouselItems[i];
+
+                            if (CheckValidForGroupSelection(newItem))
+                            {
+                                Activate(newItem);
+                                return true;
+                            }
+                        }
+                    }
+
                     return true;
             }
 
             return false;
+
+            void traverseFromKey(TraversalOperation traversal)
+            {
+                switch (traversal.Type)
+                {
+                    case TraversalType.Keyboard:
+                        traverseKeyboardSelection(traversal.Direction);
+                        break;
+
+                    case TraversalType.Set:
+                        traverseSetSelection(traversal.Direction);
+                        break;
+
+                    case TraversalType.Group:
+                        traverseGroupSelection(traversal.Direction);
+                        break;
+
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
         }
 
+        private enum TraversalType { Keyboard, Set, Group }
+
+        private record TraversalOperation(TraversalType Type, int Direction);
+
         public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
         }
@@ -490,31 +574,52 @@ namespace osu.Game.Graphics.Carousel
 
                 if (newItem.IsVisible)
                 {
-                    playTraversalSound();
-                    setKeyboardSelection(newItem.Model);
+                    if (!CheckModelEquality(currentSelection.Model, newItem.Model) && ShouldActivateOnKeyboardSelection(newItem))
+                        Activate(newItem);
+                    else
+                    {
+                        playTraversalSound();
+                        setKeyboardSelection(newItem.Model);
+                    }
+
                     return;
                 }
             } while (newIndex != originalIndex);
         }
 
         /// <summary>
-        /// Select the next valid selection relative to a current selection.
+        /// Select the next valid group selection relative to a current selection.
         /// This is generally for keyboard based traversal.
         /// </summary>
         /// <param name="direction">Positive for downwards, negative for upwards.</param>
         /// <returns>Whether selection was possible.</returns>
-        private void traverseGroupSelection(int direction)
-        {
-            if (carouselItems == null || carouselItems.Count == 0) return;
+        private void traverseGroupSelection(int direction) => traverseSelection(direction, CheckValidForGroupSelection);
 
+        /// <summary>
+        /// Select the next valid set selection relative to a current selection.
+        /// This is generally for keyboard based traversal.
+        /// </summary>
+        /// <param name="direction">Positive for downwards, negative for upwards.</param>
+        /// <returns>Whether selection was possible.</returns>
+        private void traverseSetSelection(int direction)
+        {
             // If the user has a different keyboard selection and requests
-            // group selection, first transfer the keyboard selection to actual selection.
+            // set selection, first transfer the keyboard selection to actual selection.
+            //
+            // It is assumed that selecting a set will immediately change selection to one of its children.
             if (currentKeyboardSelection.CarouselItem != null && currentSelection.CarouselItem != currentKeyboardSelection.CarouselItem)
             {
                 Activate(currentKeyboardSelection.CarouselItem);
                 return;
             }
 
+            traverseSelection(direction, CheckValidForSetSelection);
+        }
+
+        private void traverseSelection(int direction, Func<CarouselItem, bool> predicate)
+        {
+            if (carouselItems == null || carouselItems.Count == 0) return;
+
             int originalIndex;
             int newIndex;
 
@@ -527,11 +632,11 @@ namespace osu.Game.Graphics.Carousel
             {
                 newIndex = originalIndex = currentKeyboardSelection.Index.Value;
 
-                // As a second special case, if we're group selecting backwards and the current selection isn't a group,
-                // make sure to go back to the group header this item belongs to, so that the block below doesn't find it and stop too early.
+                // As a second special case, if we're set selecting backwards and the current selection isn't a set,
+                // make sure to go back to the set header this item belongs to, so that the block below doesn't find it and stop too early.
                 if (direction < 0)
                 {
-                    while (newIndex > 0 && !CheckValidForGroupSelection(carouselItems[newIndex]))
+                    while (newIndex > 0 && !predicate(carouselItems[newIndex]))
                         newIndex--;
                 }
             }
@@ -547,9 +652,9 @@ namespace osu.Game.Graphics.Carousel
 
                 var newItem = carouselItems[newIndex];
 
-                if (CheckValidForGroupSelection(newItem))
+                if (!newItem.IsExpanded && predicate(newItem))
                 {
-                    HandleItemActivated(newItem);
+                    Activate(newItem);
                     return;
                 }
             } while (true);
@@ -565,7 +670,7 @@ namespace osu.Game.Graphics.Carousel
 
         private void loadSamples(AudioManager audio)
         {
-            sampleKeyboardTraversal = audio.Samples.Get(@"UI/button-hover");
+            sampleKeyboardTraversal = audio.Samples.Get(@"SongSelect/select-difficulty");
         }
 
         private void playTraversalSound()
@@ -710,9 +815,7 @@ namespace osu.Game.Graphics.Carousel
 
             if (range != displayedRange)
             {
-                Logger.Log($"Updating displayed range of carousel from {displayedRange} to {range}");
                 displayedRange = range;
-
                 updateDisplayedRange(range);
             }
 
@@ -845,6 +948,8 @@ namespace osu.Game.Graphics.Carousel
                     throw new InvalidOperationException($"Carousel panel drawables must implement {typeof(ICarouselPanel)}");
 
                 carouselPanel.Item = item;
+                carouselPanel.DrawYPosition = item.CarouselYPosition;
+
                 Scroll.Add(drawable);
             }
 
@@ -853,6 +958,7 @@ namespace osu.Game.Graphics.Carousel
                 // To make transitions of items appearing in the flow look good, do a pass and make sure newly added items spawn from
                 // just beneath the *current interpolated position* of the previous panel.
                 var orderedPanels = Scroll.Panels
+                                          .Where(p => Scroll.ScreenSpaceDrawQuad.Intersects(p.ScreenSpaceDrawQuad))
                                           .OfType<ICarouselPanel>()
                                           .Where(p => p.Item != null)
                                           .OrderBy(p => p.Item!.CarouselYPosition)
@@ -868,8 +974,6 @@ namespace osu.Game.Graphics.Carousel
                         // It's usually off-screen anyway.
                         if (i > 0 && i < orderedPanels.Count - 1)
                             panel.DrawYPosition = orderedPanels[i - 1].DrawYPosition;
-                        else
-                            panel.DrawYPosition = panel.Item!.CarouselYPosition;
                     }
                 }
             }
@@ -924,7 +1028,7 @@ namespace osu.Game.Graphics.Carousel
         /// 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 CarouselScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
+        public partial class CarouselScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
         {
             public readonly Container Panels;
 
@@ -986,6 +1090,29 @@ namespace osu.Game.Graphics.Carousel
                     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;
diff --git a/osu.Game/Graphics/Carousel/CarouselItem.cs b/osu.Game/Graphics/Carousel/CarouselItem.cs
index 741e4d32fc..e1e93dd036 100644
--- a/osu.Game/Graphics/Carousel/CarouselItem.cs
+++ b/osu.Game/Graphics/Carousel/CarouselItem.cs
@@ -20,10 +20,27 @@ namespace osu.Game.Graphics.Carousel
 
         /// <summary>
         /// The current Y position in the carousel.
+        ///
         /// This is managed by <see cref="Carousel{T}"/> and should not be set manually.
         /// </summary>
         public double CarouselYPosition { get; set; }
 
+        /// <summary>
+        /// The amount of input padding/lenience to be added to the area above this panel.
+        /// Calculated as half of the calculated spacing between this panel and the panel above it.
+        ///
+        /// This is managed by <see cref="Carousel{T}"/> and should not be set manually.
+        /// </summary>
+        public float CarouselInputLenienceAbove { get; set; }
+
+        /// <summary>
+        /// The amount of input padding/lenience to be added to the area below this panel.
+        /// Calculated as half of the calculated spacing between this panel and the panel below it.
+        ///
+        /// This is managed by <see cref="Carousel{T}"/> and should not be set manually.
+        /// </summary>
+        public float CarouselInputLenienceBelow { get; set; }
+
         /// <summary>
         /// The height this item will take when displayed. Defaults to <see cref="DEFAULT_HEIGHT"/>.
         /// </summary>
diff --git a/osu.Game/Graphics/Containers/ExpandingContainer.cs b/osu.Game/Graphics/Containers/ExpandingContainer.cs
index 477de616ac..4b70fd6987 100644
--- a/osu.Game/Graphics/Containers/ExpandingContainer.cs
+++ b/osu.Game/Graphics/Containers/ExpandingContainer.cs
@@ -40,21 +40,24 @@ namespace osu.Game.Graphics.Containers
             RelativeSizeAxes = Axes.Y;
             Width = contractedWidth;
 
-            InternalChild = new OsuScrollContainer
+            InternalChild = CreateScrollContainer().With(s =>
             {
-                RelativeSizeAxes = Axes.Both,
-                ScrollbarVisible = false,
-                Child = FillFlow = new FillFlowContainer
+                s.RelativeSizeAxes = Axes.Both;
+                s.ScrollbarVisible = false;
+            }).WithChild(
+                FillFlow = new FillFlowContainer
                 {
                     Origin = Anchor.CentreLeft,
                     Anchor = Anchor.CentreLeft,
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
                     Direction = FillDirection.Vertical,
-                },
-            };
+                }
+            );
         }
 
+        protected virtual OsuScrollContainer CreateScrollContainer() => new OsuScrollContainer();
+
         private ScheduledDelegate? hoverExpandEvent;
 
         protected override void LoadComplete()
diff --git a/osu.Game/Graphics/Containers/LogoTrackingContainer.cs b/osu.Game/Graphics/Containers/LogoTrackingContainer.cs
index 6819d97bc5..694388b92c 100644
--- a/osu.Game/Graphics/Containers/LogoTrackingContainer.cs
+++ b/osu.Game/Graphics/Containers/LogoTrackingContainer.cs
@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
@@ -32,7 +34,7 @@ namespace osu.Game.Graphics.Containers
         /// <param name="logo">The instance of the logo to be used for tracking.</param>
         /// <param name="duration">The duration of the initial transform. Default is instant.</param>
         /// <param name="easing">The easing type of the initial transform.</param>
-        public void StartTracking(OsuLogo logo, double duration = 0, Easing easing = Easing.None)
+        public IDisposable StartTracking(OsuLogo logo, double duration = 0, Easing easing = Easing.None)
         {
             if (Logo != null && Logo != logo)
                 throw new InvalidOperationException("A different logo is already being tracked.");
@@ -42,6 +44,9 @@ namespace osu.Game.Graphics.Containers
             if (logo.IsTracking && Logo == null)
                 throw new InvalidOperationException($"Cannot track an instance of {typeof(OsuLogo)} to multiple {typeof(LogoTrackingContainer)}s");
 
+            if (logo.IsTracking)
+                throw new InvalidOperationException("A previous tracking operation is still active. Dispose of its return value before starting a new tracking operation.");
+
             Logo = logo;
             Logo.IsTracking = true;
 
@@ -50,17 +55,16 @@ namespace osu.Game.Graphics.Containers
 
             startTime = null;
             startPosition = null;
-        }
 
-        /// <summary>
-        /// Stops the logo assigned in <see cref="StartTracking"/> from tracking the facade's position.
-        /// </summary>
-        public void StopTracking()
-        {
-            if (Logo == null) return;
+            return new InvokeOnDisposal(stopTracking);
 
-            Logo.IsTracking = false;
-            Logo = null;
+            void stopTracking()
+            {
+                Debug.Assert(Logo != null);
+
+                Logo.IsTracking = false;
+                Logo = null;
+            }
         }
 
         /// <summary>
diff --git a/osu.Game/Graphics/GhostIcon.cs b/osu.Game/Graphics/GhostIcon.cs
new file mode 100644
index 0000000000..9ff036adf0
--- /dev/null
+++ b/osu.Game/Graphics/GhostIcon.cs
@@ -0,0 +1,147 @@
+// 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.Runtime.InteropServices;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Rendering.Vertices;
+using osu.Framework.Graphics.Shaders;
+using osu.Framework.Graphics.Shaders.Types;
+using osu.Framework.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Graphics
+{
+    /// <summary>
+    /// A (very cute) animated version of the <see cref="FontAwesome.Solid.Ghost"/> icon.
+    /// </summary>
+    public partial class GhostIcon : Drawable
+    {
+        private IShader ghostShader = null!;
+
+        /// <summary>
+        /// How long one complete loop of the ghost's animation takes, in milliseconds
+        /// </summary>
+        public float AnimationDuration = 2000;
+
+        [BackgroundDependencyLoader]
+        private void load(ShaderManager shaders)
+        {
+            ghostShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "Ghost");
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Invalidate(Invalidation.DrawNode);
+        }
+
+        protected override DrawNode CreateDrawNode() => new GhostIconDrawNode(this);
+
+        private class GhostIconDrawNode : DrawNode
+        {
+            protected new GhostIcon Source => (GhostIcon)base.Source;
+
+            public GhostIconDrawNode(IDrawable source)
+                : base(source)
+            {
+            }
+
+            private Quad screenSpaceDrawQuad;
+            private Vector4 drawRectangle;
+            private Vector2 blend;
+            private IShader shader = null!;
+            private float time;
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                screenSpaceDrawQuad = Source.ScreenSpaceDrawQuad;
+                drawRectangle = new Vector4(0, 0, Source.DrawWidth, Source.DrawHeight);
+                shader = Source.ghostShader;
+                blend = new Vector2(Math.Min(Source.DrawWidth, Source.DrawHeight) / Math.Min(screenSpaceDrawQuad.Width, screenSpaceDrawQuad.Height));
+                time = (float)(Source.Time.Current / Source.AnimationDuration) % 1f;
+            }
+
+            private IUniformBuffer<GhostParameters>? ghostParametersBuffer;
+
+            private IVertexBatch<TexturedVertex2D>? quadBatch;
+
+            protected override void Draw(IRenderer renderer)
+            {
+                base.Draw(renderer);
+
+                if (!renderer.BindTexture(renderer.WhitePixel))
+                    return;
+
+                quadBatch ??= renderer.CreateQuadBatch<TexturedVertex2D>(1, 2);
+                ghostParametersBuffer ??= renderer.CreateUniformBuffer<GhostParameters>();
+
+                ghostParametersBuffer.Data = new GhostParameters
+                {
+                    Time = time
+                };
+
+                shader.Bind();
+                shader.BindUniformBlock("m_GhostParameters", ghostParametersBuffer);
+
+                var vertexAction = quadBatch.AddAction;
+
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.BottomLeft,
+                    TexturePosition = new Vector2(0, 1),
+                    TextureRect = drawRectangle,
+                    BlendRange = blend,
+                    Colour = DrawColourInfo.Colour.BottomLeft.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.BottomRight,
+                    TexturePosition = new Vector2(1, 1),
+                    TextureRect = drawRectangle,
+                    BlendRange = blend,
+                    Colour = DrawColourInfo.Colour.BottomRight.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.TopRight,
+                    TexturePosition = new Vector2(1, 0),
+                    TextureRect = drawRectangle,
+                    BlendRange = blend,
+                    Colour = DrawColourInfo.Colour.TopRight.SRGB,
+                });
+                vertexAction(new TexturedVertex2D(renderer)
+                {
+                    Position = screenSpaceDrawQuad.TopLeft,
+                    TexturePosition = Vector2.Zero,
+                    TextureRect = drawRectangle,
+                    BlendRange = blend,
+                    Colour = DrawColourInfo.Colour.TopLeft.SRGB,
+                });
+
+                shader.Unbind();
+            }
+
+            [StructLayout(LayoutKind.Sequential, Pack = 1)]
+            private record struct GhostParameters
+            {
+                public UniformFloat Time;
+                private UniformPadding12 pad;
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                ghostParametersBuffer?.Dispose();
+                quadBatch?.Dispose();
+            }
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterface/LoadingLayer.cs b/osu.Game/Graphics/UserInterface/LoadingLayer.cs
index 9059b61a33..916b041696 100644
--- a/osu.Game/Graphics/UserInterface/LoadingLayer.cs
+++ b/osu.Game/Graphics/UserInterface/LoadingLayer.cs
@@ -4,7 +4,6 @@
 #nullable disable
 
 using System;
-using JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
@@ -22,9 +21,6 @@ namespace osu.Game.Graphics.UserInterface
     {
         private readonly bool blockInput;
 
-        [CanBeNull]
-        protected Box BackgroundDimLayer { get; }
-
         /// <summary>
         /// Construct a new loading spinner.
         /// </summary>
@@ -42,11 +38,11 @@ namespace osu.Game.Graphics.UserInterface
 
             if (dimBackground)
             {
-                AddInternal(BackgroundDimLayer = new Box
+                AddInternal(new Box
                 {
                     Depth = float.MaxValue,
                     Colour = Color4.Black,
-                    Alpha = 0,
+                    Alpha = 0.5f,
                     RelativeSizeAxes = Axes.Both,
                 });
             }
@@ -74,23 +70,11 @@ namespace osu.Game.Graphics.UserInterface
             return true;
         }
 
-        protected override void PopIn()
-        {
-            BackgroundDimLayer?.FadeTo(0.5f, TRANSITION_DURATION * 2, Easing.OutQuint);
-            base.PopIn();
-        }
-
-        protected override void PopOut()
-        {
-            BackgroundDimLayer?.FadeOut(TRANSITION_DURATION, Easing.OutQuint);
-            base.PopOut();
-        }
-
         protected override void Update()
         {
             base.Update();
 
-            MainContents.Size = new Vector2(Math.Clamp(Math.Min(DrawWidth, DrawHeight) * 0.25f, 20, 100));
+            MainContents.Size = new Vector2(Math.Clamp(Math.Min(DrawWidth, DrawHeight) * 0.25f, 20, 80));
         }
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/LoadingSpinner.cs b/osu.Game/Graphics/UserInterface/LoadingSpinner.cs
index df921c5c81..b4bc6fb8c3 100644
--- a/osu.Game/Graphics/UserInterface/LoadingSpinner.cs
+++ b/osu.Game/Graphics/UserInterface/LoadingSpinner.cs
@@ -1,10 +1,14 @@
 // 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.Diagnostics;
+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.Graphics.Sprites;
+using osu.Game.Graphics.Backgrounds;
 using osuTK;
 using osuTK.Graphics;
 
@@ -15,13 +19,19 @@ namespace osu.Game.Graphics.UserInterface
     /// </summary>
     public partial class LoadingSpinner : VisibilityContainer
     {
+        public const float TRANSITION_DURATION = 500;
+
         private readonly SpriteIcon spinner;
 
         protected override bool StartHidden => true;
 
         protected Container MainContents;
 
-        public const float TRANSITION_DURATION = 500;
+        private readonly TrianglesV2 triangles;
+
+        private readonly Container? trianglesMasking;
+
+        private readonly bool withBox;
 
         private const float spin_duration = 900;
 
@@ -32,37 +42,100 @@ namespace osu.Game.Graphics.UserInterface
         /// <param name="inverted">Whether colours should be inverted (black spinner instead of white).</param>
         public LoadingSpinner(bool withBox = false, bool inverted = false)
         {
+            this.withBox = withBox;
+
             Size = new Vector2(60);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            Child = MainContents = new Container
+            if (withBox)
             {
-                RelativeSizeAxes = Axes.Both,
-                Masking = true,
-                CornerRadius = 20,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Children = new Drawable[]
+                Child = MainContents = new Container
                 {
-                    new Box
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    CornerRadius = 20,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
                     {
-                        Colour = inverted ? Color4.White : Color4.Black,
-                        RelativeSizeAxes = Axes.Both,
-                        Alpha = withBox ? 0.7f : 0
-                    },
-                    spinner = new SpriteIcon
+                        new Box
+                        {
+                            Colour = inverted ? Color4.White : Color4.Black,
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.7f,
+                        },
+                        triangles = new TrianglesV2
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = inverted ? Color4.White : Color4.Black,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Alpha = 0.2f,
+                            ScaleAdjust = 0.4f,
+                            Velocity = 0.8f,
+                            SpawnRatio = 2
+                        },
+                        spinner = new SpriteIcon
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Colour = inverted ? Color4.Black : Color4.White,
+                            Scale = new Vector2(0.6f),
+                            RelativeSizeAxes = Axes.Both,
+                            Icon = FontAwesome.Solid.CircleNotch
+                        }
+                    }
+                };
+            }
+            else
+            {
+                Children = new[]
+                {
+                    MainContents = new Container
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Colour = inverted ? Color4.Black : Color4.White,
-                        Scale = new Vector2(withBox ? 0.6f : 1),
                         RelativeSizeAxes = Axes.Both,
-                        Icon = FontAwesome.Solid.CircleNotch
-                    }
-                }
-            };
+                        Children = new Drawable[]
+                        {
+                            spinner = new SpriteIcon
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Colour = inverted ? Color4.Black : Color4.White,
+                                RelativeSizeAxes = Axes.Both,
+                                Icon = FontAwesome.Solid.CircleNotch
+                            }
+                        }
+                    },
+                    trianglesMasking = new Container
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(0.8f),
+                        Masking = true,
+                        CornerRadius = 20,
+                        Children = new Drawable[]
+                        {
+                            triangles = new TrianglesV2
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.4f,
+                                Colour = ColourInfo.GradientVertical(
+                                    inverted ? Color4.Black.Opacity(0) : Color4.White.Opacity(0),
+                                    inverted ? Color4.Black : Color4.White),
+                                RelativeSizeAxes = Axes.Both,
+                                ScaleAdjust = 0.4f,
+                                SpawnRatio = 4,
+                            },
+                        }
+                    },
+                };
+            }
         }
 
         protected override void LoadComplete()
@@ -72,11 +145,20 @@ namespace osu.Game.Graphics.UserInterface
             rotate();
         }
 
-        protected override void Update()
+        protected override void UpdateAfterChildren()
         {
-            base.Update();
+            base.UpdateAfterChildren();
 
-            MainContents.CornerRadius = MainContents.DrawWidth / 4;
+            if (withBox)
+            {
+                MainContents.CornerRadius = MainContents.DrawWidth / 4;
+                triangles.Rotation = -MainContents.Rotation;
+            }
+            else
+            {
+                Debug.Assert(trianglesMasking != null);
+                trianglesMasking.CornerRadius = MainContents.DrawWidth / 2;
+            }
         }
 
         protected override void PopIn()
@@ -86,13 +168,13 @@ namespace osu.Game.Graphics.UserInterface
                 rotate();
 
             MainContents.ScaleTo(1, TRANSITION_DURATION, Easing.OutQuint);
-            this.FadeIn(TRANSITION_DURATION * 2, Easing.OutQuint);
+            this.FadeIn(TRANSITION_DURATION, Easing.OutQuint);
         }
 
         protected override void PopOut()
         {
-            MainContents.ScaleTo(0.8f, TRANSITION_DURATION / 2, Easing.In);
-            this.FadeOut(TRANSITION_DURATION, Easing.OutQuint);
+            MainContents.ScaleTo(0.6f, TRANSITION_DURATION, Easing.OutQuint);
+            this.FadeOut(TRANSITION_DURATION / 2, Easing.OutQuint);
         }
 
         private void rotate()
diff --git a/osu.Game/Graphics/UserInterface/OsuDropdown.cs b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
index af335efdc4..e0179f8bc4 100644
--- a/osu.Game/Graphics/UserInterface/OsuDropdown.cs
+++ b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
@@ -18,6 +18,7 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
+using osu.Game.Resources.Localisation.Web;
 using osuTK;
 using osuTK.Graphics;
 
@@ -440,6 +441,11 @@ namespace osu.Game.Graphics.UserInterface
 
                 private partial class DropdownSearchTextBox : OsuTextBox
                 {
+                    public DropdownSearchTextBox()
+                    {
+                        PlaceholderText = HomeStrings.SearchPlaceholder;
+                    }
+
                     [BackgroundDependencyLoader]
                     private void load(OverlayColourProvider? colourProvider)
                     {
diff --git a/osu.Game/Graphics/UserInterface/ShearedButton.cs b/osu.Game/Graphics/UserInterface/ShearedButton.cs
index 16891babf3..2047fc74f4 100644
--- a/osu.Game/Graphics/UserInterface/ShearedButton.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedButton.cs
@@ -179,7 +179,7 @@ namespace osu.Game.Graphics.UserInterface
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             Content.ScaleTo(0.9f, 2000, Easing.OutQuint);
-            return base.OnMouseDown(e);
+            return true;
         }
 
         protected override void OnMouseUp(MouseUpEvent e)
diff --git a/osu.Game/Graphics/UserInterface/ShearedRangeSlider.cs b/osu.Game/Graphics/UserInterface/ShearedRangeSlider.cs
index 3aaa143987..417474cba3 100644
--- a/osu.Game/Graphics/UserInterface/ShearedRangeSlider.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedRangeSlider.cs
@@ -5,6 +5,7 @@ using System;
 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;
@@ -54,20 +55,14 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         /// <summary>
-        /// Lower bound display for when it is set to its default value.
+        /// Lower bound display for when it is set to its default value, or null to display the value directly.
         /// </summary>
-        public string DefaultStringLowerBound { get; init; } = string.Empty;
+        public LocalisableString? DefaultStringLowerBound { get; init; }
 
         /// <summary>
-        /// Upper bound display for when it is set to its default value.
+        /// Upper bound display for when it is set to its default value, or null to display the value directly.
         /// </summary>
-        public string DefaultStringUpperBound { get; init; } = string.Empty;
-
-        public LocalisableString DefaultTooltipLowerBound { get; init; } = string.Empty;
-
-        public LocalisableString DefaultTooltipUpperBound { get; init; } = string.Empty;
-
-        public string TooltipSuffix { get; init; } = string.Empty;
+        public LocalisableString? DefaultStringUpperBound { get; init; }
 
         private float minRange = 0.1f;
 
@@ -144,9 +139,7 @@ namespace osu.Game.Graphics.UserInterface
                                 {
                                     d.KeyboardStep = 0.1f;
                                     d.RelativeSizeAxes = Axes.X;
-                                    d.TooltipSuffix = TooltipSuffix;
                                     d.DefaultString = DefaultStringUpperBound;
-                                    d.DefaultTooltip = DefaultTooltipUpperBound;
                                     d.NubWidth = NubWidth;
                                     d.Current = upperBound;
                                 }),
@@ -154,9 +147,7 @@ namespace osu.Game.Graphics.UserInterface
                                 {
                                     d.KeyboardStep = 0.1f;
                                     d.RelativeSizeAxes = Axes.X;
-                                    d.TooltipSuffix = TooltipSuffix;
                                     d.DefaultString = DefaultStringLowerBound;
-                                    d.DefaultTooltip = DefaultTooltipLowerBound;
                                     d.NubWidth = NubWidth;
                                     d.Current = lowerBound;
                                 }),
@@ -188,14 +179,20 @@ namespace osu.Game.Graphics.UserInterface
 
             public new ShearedNub Nub => base.Nub;
 
-            public string? DefaultString;
-            public LocalisableString? DefaultTooltip;
-            public string? TooltipSuffix;
+            public LocalisableString? DefaultString;
 
             public float NubWidth { get; set; } = ShearedNub.HEIGHT;
 
-            public override LocalisableString TooltipText =>
-                (Current.IsDefault ? DefaultTooltip : Current.Value.ToString($@"0.## {TooltipSuffix}")) ?? Current.Value.ToString($@"0.## {TooltipSuffix}");
+            public override LocalisableString TooltipText
+            {
+                get
+                {
+                    if (Current.IsDefault)
+                        return string.Empty;
+
+                    return Current.Value.ToLocalisableString(@"N1");
+                }
+            }
 
             protected OsuSpriteText NubText { get; private set; } = null!;
 
@@ -245,8 +242,10 @@ namespace osu.Game.Graphics.UserInterface
 
             protected virtual void UpdateDisplay(double value)
             {
-                string defaultString = DefaultString ?? value.ToString("N1");
-                NubText.Text = Current.IsDefault ? defaultString : value.ToString("N1");
+                if (Current.IsDefault && DefaultString != null)
+                    NubText.Text = DefaultString.Value;
+                else
+                    NubText.Text = value.ToLocalisableString(@"N1");
             }
 
             public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
diff --git a/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs
index aeeda82bfb..efeebb2fc1 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs
@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
 
@@ -78,13 +77,9 @@ namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
                 Flow.Height = 25;
                 Flow.Margin = new MarginPadding { Horizontal = 10, };
 
-                AddRangeInternal(new Drawable[]
+                AddInternal(new BackgroundLayer(0.5f)
                 {
-                    new BackgroundLayer(0.5f)
-                    {
-                        Depth = 1
-                    },
-                    new HoverClickSounds(),
+                    Depth = 1
                 });
 
                 Flow.Add(new SpriteIcon
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormButton.cs b/osu.Game/Graphics/UserInterfaceV2/FormButton.cs
index 1c5d4b5d80..85198191b8 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FormButton.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FormButton.cs
@@ -129,7 +129,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
             private void load(OverlayColourProvider overlayColourProvider)
             {
                 DefaultBackgroundColour = overlayColourProvider.Colour3;
-                triangleGradientSecondColour ??= overlayColourProvider.Colour1;
+                triangleGradientSecondColour ??= DefaultBackgroundColour.Lighten(0.2f);
 
                 if (Text == default)
                 {
diff --git a/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs b/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
index 9b57ebb200..bf92f20526 100644
--- a/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
         {
             // Many buttons have local colours, but this provides a sane default for all other cases.
             DefaultBackgroundColour = overlayColourProvider?.Colour3 ?? colours.Blue3;
-            triangleGradientSecondColour ??= overlayColourProvider?.Colour1 ?? colours.Blue3.Lighten(0.2f);
+            triangleGradientSecondColour ??= DefaultBackgroundColour.Lighten(0.2f);
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game/Input/Bindings/GlobalActionContainer.cs b/osu.Game/Input/Bindings/GlobalActionContainer.cs
index 6de2dabe2b..2aeb73d6c5 100644
--- a/osu.Game/Input/Bindings/GlobalActionContainer.cs
+++ b/osu.Game/Input/Bindings/GlobalActionContainer.cs
@@ -89,9 +89,6 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(InputKey.Up, GlobalAction.SelectPrevious),
             new KeyBinding(InputKey.Down, GlobalAction.SelectNext),
 
-            new KeyBinding(InputKey.Left, GlobalAction.SelectPreviousGroup),
-            new KeyBinding(InputKey.Right, GlobalAction.SelectNextGroup),
-
             new KeyBinding(InputKey.Space, GlobalAction.Select),
             new KeyBinding(InputKey.Enter, GlobalAction.Select),
             new KeyBinding(InputKey.KeypadEnter, GlobalAction.Select),
@@ -199,6 +196,14 @@ namespace osu.Game.Input.Bindings
 
         private static IEnumerable<KeyBinding> songSelectKeyBindings => new[]
         {
+            new KeyBinding(InputKey.Left, GlobalAction.ActivatePreviousSet),
+            new KeyBinding(InputKey.Right, GlobalAction.ActivateNextSet),
+
+            new KeyBinding(new[] { InputKey.Shift, InputKey.Left }, GlobalAction.ExpandPreviousGroup),
+            new KeyBinding(new[] { InputKey.Shift, InputKey.Right }, GlobalAction.ExpandNextGroup),
+
+            new KeyBinding(new[] { InputKey.Shift, InputKey.Enter }, GlobalAction.ToggleCurrentGroup),
+
             new KeyBinding(InputKey.F1, GlobalAction.ToggleModSelection),
             new KeyBinding(InputKey.F2, GlobalAction.SelectNextRandom),
             new KeyBinding(new[] { InputKey.Shift, InputKey.F2 }, GlobalAction.SelectPreviousRandom),
@@ -396,11 +401,11 @@ namespace osu.Game.Input.Bindings
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorDecreaseDistanceSpacing))]
         EditorDecreaseDistanceSpacing,
 
-        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.SelectPreviousGroup))]
-        SelectPreviousGroup,
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.ActivatePreviousSet))]
+        ActivatePreviousSet,
 
-        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.SelectNextGroup))]
-        SelectNextGroup,
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.ActivateNextSet))]
+        ActivateNextSet,
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.DeselectAllMods))]
         DeselectAllMods,
@@ -506,6 +511,15 @@ namespace osu.Game.Input.Bindings
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorDiscardUnsavedChanges))]
         EditorDiscardUnsavedChanges,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.ExpandPreviousGroup))]
+        ExpandPreviousGroup,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.ExpandNextGroup))]
+        ExpandNextGroup,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.ToggleCurrentGroup))]
+        ToggleCurrentGroup,
     }
 
     public enum GlobalActionCategory
diff --git a/osu.Game/Localisation/BeatmapStatisticStrings.cs b/osu.Game/Localisation/BeatmapStatisticStrings.cs
new file mode 100644
index 0000000000..47cc153ac7
--- /dev/null
+++ b/osu.Game/Localisation/BeatmapStatisticStrings.cs
@@ -0,0 +1,69 @@
+// 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 BeatmapStatisticStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.BeatmapStatisticStrings";
+
+        /// <summary>
+        /// "Circles"
+        /// </summary>
+        public static LocalisableString Circles => new TranslatableString(getKey(@"circles"), @"Circles");
+
+        /// <summary>
+        /// "Sliders"
+        /// </summary>
+        public static LocalisableString Sliders => new TranslatableString(getKey(@"sliders"), @"Sliders");
+
+        /// <summary>
+        /// "Spinners"
+        /// </summary>
+        public static LocalisableString Spinners => new TranslatableString(getKey(@"spinners"), @"Spinners");
+
+        /// <summary>
+        /// "Hits"
+        /// </summary>
+        public static LocalisableString Hits => new TranslatableString(getKey(@"hits"), @"Hits");
+
+        /// <summary>
+        /// "Drumrolls"
+        /// </summary>
+        public static LocalisableString Drumrolls => new TranslatableString(getKey(@"drumrolls"), @"Drumrolls");
+
+        /// <summary>
+        /// "Swells"
+        /// </summary>
+        public static LocalisableString Swells => new TranslatableString(getKey(@"swells"), @"Swells");
+
+        /// <summary>
+        /// "Fruits"
+        /// </summary>
+        public static LocalisableString Fruits => new TranslatableString(getKey(@"fruits"), @"Fruits");
+
+        /// <summary>
+        /// "Juice Streams"
+        /// </summary>
+        public static LocalisableString JuiceStreams => new TranslatableString(getKey(@"juice_streams"), @"Juice Streams");
+
+        /// <summary>
+        /// "Banana Showers"
+        /// </summary>
+        public static LocalisableString BananaShowers => new TranslatableString(getKey(@"banana_showers"), @"Banana Showers");
+
+        /// <summary>
+        /// "Notes"
+        /// </summary>
+        public static LocalisableString Notes => new TranslatableString(getKey(@"notes"), @"Notes");
+
+        /// <summary>
+        /// "Hold Notes"
+        /// </summary>
+        public static LocalisableString HoldNotes => new TranslatableString(getKey(@"hold_notes"), @"Hold Notes");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/osu.Game/Localisation/ContextMenuStrings.cs b/osu.Game/Localisation/ContextMenuStrings.cs
index cb18a2159c..b2ca941287 100644
--- a/osu.Game/Localisation/ContextMenuStrings.cs
+++ b/osu.Game/Localisation/ContextMenuStrings.cs
@@ -29,6 +29,16 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString SpectatePlayer => new TranslatableString(getKey(@"spectate_player"), @"Spectate");
 
+        /// <summary>
+        /// "Are you sure you want to block {0}?"
+        /// </summary>
+        public static LocalisableString ConfirmBlockUser(string username) => new TranslatableString(getKey(@"confirm_block_user"), @"Are you sure you want to block {0}?", username);
+
+        /// <summary>
+        /// "Are you sure you want to unblock {0}?"
+        /// </summary>
+        public static LocalisableString ConfirmUnblockUser(string username) => new TranslatableString(getKey(@"confirm_unblock_user"), @"Are you sure you want to unblock {0}?", username);
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/DefaultRankDisplayStrings.cs b/osu.Game/Localisation/DefaultRankDisplayStrings.cs
new file mode 100644
index 0000000000..88e3b4309a
--- /dev/null
+++ b/osu.Game/Localisation/DefaultRankDisplayStrings.cs
@@ -0,0 +1,19 @@
+// 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 DefaultRankDisplayStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.DefaultRankDisplay";
+
+        /// <summary>
+        /// "Play samples on rank change"
+        /// </summary>
+        public static LocalisableString PlaySamplesOnRankChange => new TranslatableString(getKey(@"play_samples_on_rank_change"), @"Play samples on rank change");
+
+        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 4ce3e7f12b..eeccdc8e8a 100644
--- a/osu.Game/Localisation/EditorStrings.cs
+++ b/osu.Game/Localisation/EditorStrings.cs
@@ -154,6 +154,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString TimelineShowTimingChanges => new TranslatableString(getKey(@"timeline_show_timing_changes"), @"Show timing changes");
 
+        /// <summary>
+        /// "Finish editing and import changes"
+        /// </summary>
+        public static LocalisableString FinishEditingExternally => new TranslatableString(getKey(@"Finish editing and import changes"), @"Finish editing and import changes");
+
         /// <summary>
         /// "Show breaks"
         /// </summary>
diff --git a/osu.Game/Localisation/GeneralSettingsStrings.cs b/osu.Game/Localisation/GeneralSettingsStrings.cs
index 0f4dd0805e..20db5983fd 100644
--- a/osu.Game/Localisation/GeneralSettingsStrings.cs
+++ b/osu.Game/Localisation/GeneralSettingsStrings.cs
@@ -79,23 +79,26 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString LearnMoreAboutLazerTooltip => new TranslatableString(getKey(@"check_out_the_feature_comparison"), @"Check out the feature comparison and FAQ");
 
+        /// <summary>
+        /// "Check with your package manager / provider for other release streams."
+        /// </summary>
+        public static LocalisableString ChangeReleaseStreamPackageManagerWarning => new TranslatableString(getKey(@"change_release_stream_package_warning"), @"Check with your package manager / provider for other release streams.");
+
         /// <summary>
         /// "Are you sure you want to run a potentially unstable version of the game?"
         /// </summary>
-        public static LocalisableString ChangeReleaseStreamConfirmation => new TranslatableString(getKey(@"change_release stream_confirmation"),
-            @"Are you sure you want to run a potentially unstable version of the game?");
+        public static LocalisableString ChangeReleaseStreamConfirmation => new TranslatableString(getKey(@"change_release_stream_confirmation"), @"Are you sure you want to run a potentially unstable version of the game?");
 
         /// <summary>
         /// "If you run into issues starting the game, you can usually run the installer from the official site to recover."
         /// </summary>
-        public static LocalisableString ChangeReleaseStreamConfirmationInfo => new TranslatableString(getKey(@"change_release stream_confirmation_info"),
-            @"If you run into issues starting the game, you can usually run the installer from the official site to recover.");
+        public static LocalisableString ChangeReleaseStreamConfirmationInfo => new TranslatableString(getKey(@"change_release_stream_confirmation_info"), @"If you run into issues starting the game, you can usually run the installer from the official site to recover.");
 
         /// <summary>
         /// "You are running the latest release ({0})"
         /// </summary>
         public static LocalisableString RunningLatestRelease(string version) => new TranslatableString(getKey(@"running_latest_release"), @"You are running the latest release ({0})", version);
 
-        private static string getKey(string key) => $"{prefix}:{key}";
+        private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
index 34b9e1fecc..9c484a5cb0 100644
--- a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
+++ b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
@@ -130,14 +130,29 @@ namespace osu.Game.Localisation
         public static LocalisableString SelectNext => new TranslatableString(getKey(@"select_next"), @"Next selection");
 
         /// <summary>
-        /// "Select previous group"
+        /// "Activate previous set"
         /// </summary>
-        public static LocalisableString SelectPreviousGroup => new TranslatableString(getKey(@"select_previous_group"), @"Select previous group");
+        public static LocalisableString ActivatePreviousSet => new TranslatableString(getKey(@"activate_previous_set"), @"Activate previous set");
 
         /// <summary>
-        /// "Select next group"
+        /// "Activate next set"
         /// </summary>
-        public static LocalisableString SelectNextGroup => new TranslatableString(getKey(@"select_next_group"), @"Select next group");
+        public static LocalisableString ActivateNextSet => new TranslatableString(getKey(@"activate_next_set"), @"Activate next set");
+
+        /// <summary>
+        /// "Expand previous group"
+        /// </summary>
+        public static LocalisableString ExpandPreviousGroup => new TranslatableString(getKey(@"expand_previous_group"), @"Expand previous group");
+
+        /// <summary>
+        /// "Expand next group"
+        /// </summary>
+        public static LocalisableString ExpandNextGroup => new TranslatableString(getKey(@"expand_next_group"), @"Expand next group");
+
+        /// <summary>
+        /// "Toggle expansion of current group"
+        /// </summary>
+        public static LocalisableString ToggleCurrentGroup => new TranslatableString(getKey(@"toggle_current_group"), @"Toggle expansion of current group");
 
         /// <summary>
         /// "Home"
diff --git a/osu.Game/Localisation/MenuTipStrings.cs b/osu.Game/Localisation/MenuTipStrings.cs
index 9d398e8e64..977c0928b2 100644
--- a/osu.Game/Localisation/MenuTipStrings.cs
+++ b/osu.Game/Localisation/MenuTipStrings.cs
@@ -149,6 +149,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString DragAndDropImageInSkinEditor => new TranslatableString(getKey(@"drag_and_drop_image_in_skin_editor"), @"Drag and drop any image into the skin editor to load it in quickly!");
 
+        /// <summary>
+        /// "Try holding your right mouse button near the beatmap carousel to quickly scroll to an absolute position!"
+        /// </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>
         /// "a tip for you:"
         /// </summary>
diff --git a/osu.Game/Localisation/ResultsScreenStrings.cs b/osu.Game/Localisation/ResultsScreenStrings.cs
index 54e7717af9..143d5b70bc 100644
--- a/osu.Game/Localisation/ResultsScreenStrings.cs
+++ b/osu.Game/Localisation/ResultsScreenStrings.cs
@@ -19,6 +19,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString NoPPForUnrankedMods => new TranslatableString(getKey(@"no_pp_for_unranked_mods"), @"Performance points are not granted for this score because of unranked mods.");
 
+        /// <summary>
+        /// "Performance points are not granted for failed scores."
+        /// </summary>
+        public static LocalisableString NoPPForFailedScores => new TranslatableString(getKey(@"no_pp_for_failed_scores"), @"Performance points are not granted for failed scores.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/SkinComponents/BeatmapAttributeTextStrings.cs b/osu.Game/Localisation/SkinComponents/BeatmapAttributeTextStrings.cs
index 390a6f9ca4..4ddffe615f 100644
--- a/osu.Game/Localisation/SkinComponents/BeatmapAttributeTextStrings.cs
+++ b/osu.Game/Localisation/SkinComponents/BeatmapAttributeTextStrings.cs
@@ -14,11 +14,6 @@ namespace osu.Game.Localisation.SkinComponents
         /// </summary>
         public static LocalisableString Attribute => new TranslatableString(getKey(@"attribute"), @"Attribute");
 
-        /// <summary>
-        /// "The attribute to be displayed."
-        /// </summary>
-        public static LocalisableString AttributeDescription => new TranslatableString(getKey(@"attribute_description"), @"The attribute to be displayed.");
-
         /// <summary>
         /// "Template"
         /// </summary>
diff --git a/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
index b21446e18a..2f34987e8e 100644
--- a/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
+++ b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
@@ -14,31 +14,16 @@ namespace osu.Game.Localisation.SkinComponents
         /// </summary>
         public static LocalisableString SpriteName => new TranslatableString(getKey(@"sprite_name"), @"Sprite name");
 
-        /// <summary>
-        /// "The filename of the sprite"
-        /// </summary>
-        public static LocalisableString SpriteNameDescription => new TranslatableString(getKey(@"sprite_name_description"), @"The filename of the sprite");
-
         /// <summary>
         /// "Font"
         /// </summary>
         public static LocalisableString Font => new TranslatableString(getKey(@"font"), @"Font");
 
-        /// <summary>
-        /// "The font to use."
-        /// </summary>
-        public static LocalisableString FontDescription => new TranslatableString(getKey(@"font_description"), @"The font to use.");
-
         /// <summary>
         /// "Text"
         /// </summary>
         public static LocalisableString TextElementText => new TranslatableString(getKey(@"text_element_text"), @"Text");
 
-        /// <summary>
-        /// "The text to be displayed."
-        /// </summary>
-        public static LocalisableString TextElementTextDescription => new TranslatableString(getKey(@"text_element_text_description"), @"The text to be displayed.");
-
         /// <summary>
         /// "Corner radius"
         /// </summary>
@@ -54,36 +39,37 @@ namespace osu.Game.Localisation.SkinComponents
         /// </summary>
         public static LocalisableString ShowLabel => new TranslatableString(getKey(@"show_label"), @"Show label");
 
-        /// <summary>
-        /// "Whether the component&#39;s label should be shown."
-        /// </summary>
-        public static LocalisableString ShowLabelDescription => new TranslatableString(getKey(@"show_label_description"), @"Whether the component's label should be shown.");
-
         /// <summary>
         /// "Colour"
         /// </summary>
         public static LocalisableString Colour => new TranslatableString(getKey(@"colour"), @"Colour");
 
-        /// <summary>
-        /// "The colour of the component."
-        /// </summary>
-        public static LocalisableString ColourDescription => new TranslatableString(getKey(@"colour_description"), @"The colour of the component.");
-
         /// <summary>
         /// "Text colour"
         /// </summary>
         public static LocalisableString TextColour => new TranslatableString(getKey(@"text_colour"), @"Text colour");
 
         /// <summary>
-        /// "The colour of the text."
+        /// "Text weight"
         /// </summary>
-        public static LocalisableString TextColourDescription => new TranslatableString(getKey(@"text_colour_description"), @"The colour of the text.");
+        public static LocalisableString TextWeight => new TranslatableString(getKey(@"text_weight"), @"Text weight");
 
         /// <summary>
         /// "Use relative size"
         /// </summary>
         public static LocalisableString UseRelativeSize => new TranslatableString(getKey(@"use_relative_size"), @"Use relative size");
 
+        /// <summary>
+        /// "Collapse during gameplay"
+        /// </summary>
+        public static LocalisableString CollapseDuringGameplay => new TranslatableString(getKey(@"collapse_during_gameplay"), @"Collapse during gameplay");
+
+        /// <summary>
+        /// "If enabled, the leaderboard will become more compact during active gameplay."
+        /// </summary>
+        public static LocalisableString CollapseDuringGameplayDescription =>
+            new TranslatableString(getKey(@"if_enabled_the_leaderboard_will"), @"If enabled, the leaderboard will become more compact during active gameplay.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/SongSelectStrings.cs b/osu.Game/Localisation/SongSelectStrings.cs
index e715ba8880..055caccc87 100644
--- a/osu.Game/Localisation/SongSelectStrings.cs
+++ b/osu.Game/Localisation/SongSelectStrings.cs
@@ -54,6 +54,46 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString EditBeatmap => new TranslatableString(getKey(@"edit_beatmap"), @"Edit beatmap");
 
+        /// <summary>
+        /// "Circle Size"
+        /// </summary>
+        public static LocalisableString CircleSize => new TranslatableString(getKey(@"circle_size"), @"Circle Size");
+
+        /// <summary>
+        /// "Key Count"
+        /// </summary>
+        public static LocalisableString KeyCount => new TranslatableString(getKey(@"key_count"), @"Key Count");
+
+        /// <summary>
+        /// "Approach Rate"
+        /// </summary>
+        public static LocalisableString ApproachRate => new TranslatableString(getKey(@"approach_rate"), @"Approach Rate");
+
+        /// <summary>
+        /// "Accuracy"
+        /// </summary>
+        public static LocalisableString Accuracy => new TranslatableString(getKey(@"accuracy"), @"Accuracy");
+
+        /// <summary>
+        /// "HP Drain"
+        /// </summary>
+        public static LocalisableString HPDrain => new TranslatableString(getKey(@"hp_drain"), @"HP Drain");
+
+        /// <summary>
+        /// "Submitted"
+        /// </summary>
+        public static LocalisableString Submitted => new TranslatableString(getKey(@"submitted"), @"Submitted");
+
+        /// <summary>
+        /// "Ranked"
+        /// </summary>
+        public static LocalisableString Ranked => new TranslatableString(getKey(@"ranked"), @"Ranked");
+
+        /// <summary>
+        /// "{0} stars"
+        /// </summary>
+        public static LocalisableString Stars(LocalisableString value) => new TranslatableString(getKey(@"stars"), @"{0} stars", value);
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
index c6cf0f735f..e8e08059b9 100644
--- a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
@@ -80,11 +80,22 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty("artist_unicode")]
         public string ArtistUnicode { get; set; } = string.Empty;
 
+        /// <summary>
+        /// 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.
+        /// </remarks>
+        [JsonProperty(@"user")]
         public APIUser Author = new APIUser();
 
         /// <summary>
-        /// Helper property to deserialize a username to <see cref="APIUser"/>.
+        /// The ID of the beatmap set's creator.
         /// </summary>
+        /// <remarks>
+        /// Helper property to deserialize the ID to <see cref="Author"/>.
+        /// </remarks>
         [JsonProperty(@"user_id")]
         public int AuthorID
         {
@@ -93,8 +104,11 @@ namespace osu.Game.Online.API.Requests.Responses
         }
 
         /// <summary>
-        /// Helper property to deserialize a username to <see cref="APIUser"/>.
+        /// The username of the beatmap set's creator.
         /// </summary>
+        /// <remarks>
+        /// Helper property to deserialize the username to <see cref="Author"/>.
+        /// </remarks>
         [JsonProperty(@"creator")]
         public string AuthorString
         {
diff --git a/osu.Game/Online/API/Requests/Responses/APIUpdateStream.cs b/osu.Game/Online/API/Requests/Responses/APIUpdateStream.cs
index dac72f2488..7586f56a0e 100644
--- a/osu.Game/Online/API/Requests/Responses/APIUpdateStream.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIUpdateStream.cs
@@ -39,7 +39,8 @@ namespace osu.Game.Online.API.Requests.Responses
             ["stable"] = new Color4(34, 153, 187, 255),
             ["beta40"] = new Color4(255, 221, 85, 255),
             ["cuttingedge"] = new Color4(238, 170, 0, 255),
-            [OsuGameBase.CLIENT_STREAM_NAME] = new Color4(237, 18, 33, 255),
+            ["lazer"] = new Color4(237, 18, 33, 255),
+            ["tachyon"] = new Color4(206, 0, 255, 255),
             ["web"] = new Color4(136, 102, 238, 255)
         };
 
diff --git a/osu.Game/Online/Rooms/MatchType.cs b/osu.Game/Online/Rooms/MatchType.cs
index 28f2da897a..ade28458e8 100644
--- a/osu.Game/Online/Rooms/MatchType.cs
+++ b/osu.Game/Online/Rooms/MatchType.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Online.Rooms
         [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesHeadToHead))]
         HeadToHead,
 
-        [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVs))]
+        [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVersus))]
         TeamVersus,
     }
 }
diff --git a/osu.Game/Online/Rooms/RoomExtensions.cs b/osu.Game/Online/Rooms/RoomExtensions.cs
new file mode 100644
index 0000000000..b7348e8997
--- /dev/null
+++ b/osu.Game/Online/Rooms/RoomExtensions.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 osu.Game.Online.API;
+
+namespace osu.Game.Online.Rooms
+{
+    public static class RoomExtensions
+    {
+        /// <summary>
+        /// Get the room page URL, or <c>null</c> if unavailable.
+        /// </summary>
+        public static string? GetOnlineURL(this Room room, IAPIProvider api)
+        {
+            if (!room.RoomID.HasValue)
+                return null;
+
+            return $@"{api.Endpoints.WebsiteUrl}/multiplayer/rooms/{room.RoomID.Value}";
+        }
+    }
+}
diff --git a/osu.Game/Online/Spectator/SpectatorClient.cs b/osu.Game/Online/Spectator/SpectatorClient.cs
index dd0e03463c..7f09fbdc9e 100644
--- a/osu.Game/Online/Spectator/SpectatorClient.cs
+++ b/osu.Game/Online/Spectator/SpectatorClient.cs
@@ -247,12 +247,10 @@ namespace osu.Game.Online.Spectator
 
                 var convertedFrame = convertible.ToLegacy(currentBeatmap);
 
-                // only keep the last recorded frame for a given timestamp.
                 // this reduces redundancy of frames in the resulting replay.
-                //
-                // this is also done at `ReplayRecorded`, but needs to be done here as well
+                // it is also done at `ReplayRecorder`, but needs to be done here as well
                 // due to the flow being handled differently.
-                if (pendingFrames.LastOrDefault()?.Time == convertedFrame.Time)
+                if (pendingFrames.LastOrDefault()?.IsEquivalentTo(convertedFrame) == true)
                     pendingFrames[^1] = convertedFrame;
                 else
                     pendingFrames.Add(convertedFrame);
diff --git a/osu.Game/Online/Spectator/SpectatorScoreProcessor.cs b/osu.Game/Online/Spectator/SpectatorScoreProcessor.cs
index 3242e21994..7da0b4f279 100644
--- a/osu.Game/Online/Spectator/SpectatorScoreProcessor.cs
+++ b/osu.Game/Online/Spectator/SpectatorScoreProcessor.cs
@@ -39,6 +39,11 @@ namespace osu.Game.Online.Spectator
         /// </summary>
         public readonly BindableInt Combo = new BindableInt();
 
+        /// <summary>
+        /// The highest combo achieved in the score thus far.
+        /// </summary>
+        public readonly BindableInt HighestCombo = new BindableInt();
+
         /// <summary>
         /// The <see cref="ScoringMode"/> used to calculate scores.
         /// </summary>
@@ -157,6 +162,7 @@ namespace osu.Game.Online.Spectator
 
             Accuracy.Value = frame.Header.Accuracy;
             Combo.Value = frame.Header.Combo;
+            HighestCombo.Value = frame.Header.MaxCombo;
             TotalScore.Value = frame.Header.TotalScore;
         }
 
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 32ffc52be1..57ed6a5dbf 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -227,6 +227,8 @@ namespace osu.Game
 
         private Bindable<string> configSkin;
 
+        private RealmDetachedBeatmapStore detachedBeatmapStore;
+
         private readonly string[] args;
 
         private readonly List<OsuFocusedOverlayContainer> focusedOverlays = new List<OsuFocusedOverlayContainer>();
@@ -312,6 +314,8 @@ namespace osu.Game
             foreach (var overlay in focusedOverlays)
                 overlay.Hide();
 
+            ScreenFooter.ActiveOverlay?.Hide();
+
             if (hideToolbar) Toolbar.Hide();
         }
 
@@ -519,7 +523,7 @@ namespace osu.Game
                     else
                     {
                         string[] changelogArgs = argString.Split("/");
-                        ShowChangelogBuild(changelogArgs[0], changelogArgs[1]);
+                        ShowChangelogBuild($"{changelogArgs[1]}-{changelogArgs[0]}");
                     }
 
                     break;
@@ -600,9 +604,8 @@ namespace osu.Game
         /// <summary>
         /// Show changelog's build as an overlay
         /// </summary>
-        /// <param name="updateStream">The update stream name</param>
-        /// <param name="version">The build version of the update stream</param>
-        public void ShowChangelogBuild(string updateStream, string version) => waitForReady(() => changelogOverlay, _ => changelogOverlay.ShowBuild(updateStream, version));
+        /// <param name="version">The build version, including stream suffix.</param>
+        public void ShowChangelogBuild(string version) => waitForReady(() => changelogOverlay, _ => changelogOverlay.ShowBuild(version));
 
         /// <summary>
         /// Joins a multiplayer or playlists room with the given <paramref name="id"/>.
@@ -1001,6 +1004,10 @@ namespace osu.Game
 
         protected override void Dispose(bool isDisposing)
         {
+            // Without this, tests may deadlock due to cancellation token not becoming cancelled before disposal.
+            // To reproduce, run `TestSceneButtonSystemNavigation` ensuring `TestConstructor` runs before `TestFastShortcutKeys`.
+            detachedBeatmapStore?.Dispose();
+
             base.Dispose(isDisposing);
             SentryLogger.Dispose();
         }
@@ -1025,6 +1032,10 @@ namespace osu.Game
             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 =>
@@ -1240,7 +1251,7 @@ namespace osu.Game
             loadComponentSingleFile(new MedalOverlay(), topMostOverlayContent.Add);
 
             loadComponentSingleFile(new BackgroundDataStoreProcessor(), Add);
-            loadComponentSingleFile<BeatmapStore>(new RealmDetachedBeatmapStore(), Add, true);
+            loadComponentSingleFile<BeatmapStore>(detachedBeatmapStore = new RealmDetachedBeatmapStore(), Add, true);
 
             Add(externalLinkOpener = new ExternalLinkOpener());
             Add(new MusicKeyBindingHandler());
@@ -1306,6 +1317,9 @@ namespace osu.Game
 
         private void handleBackButton()
         {
+            // TODO: this is SUPER SUPER bad.
+            // It can potentially exit the wrong screen if screens are not loaded yet.
+            // ScreenFooter / ScreenBackButton should be aware of which screen it is currently being handled by.
             if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen)) return;
 
             if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowUserExit && !currentScreen.OnBackButton())) ScreenStack.Exit();
@@ -1746,7 +1760,12 @@ namespace osu.Game
                     if (newOsuScreen.IsLoaded)
                         updateFooterButtons();
                     else
+                    {
+                        // ensure the current buttons are immediately disabled on screen change (so they can't be pressed).
+                        ScreenFooter.SetButtons(Array.Empty<ScreenFooterButton>());
+
                         newOsuScreen.OnLoadComplete += _ => updateFooterButtons();
+                    }
 
                     void updateFooterButtons()
                     {
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 3bbebb9244..3c23ccc5cf 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -83,8 +83,6 @@ namespace osu.Game
 
         public const string OSU_PROTOCOL = "osu://";
 
-        public const string CLIENT_STREAM_NAME = @"lazer";
-
         /// <summary>
         /// The filename of the main client database.
         /// </summary>
@@ -120,8 +118,6 @@ namespace osu.Game
 
         public bool IsDeployedBuild => AssemblyVersion.Major > 0;
 
-        internal const string BUILD_SUFFIX = "lazer";
-
         public virtual string Version
         {
             get
@@ -129,8 +125,16 @@ namespace osu.Game
                 if (!IsDeployedBuild)
                     return @"local " + (DebugUtils.IsDebugBuild ? @"debug" : @"release");
 
-                var version = AssemblyVersion;
-                return $@"{version.Major}.{version.Minor}.{version.Build}-{BUILD_SUFFIX}";
+                string informationalVersion = Assembly.GetEntryAssembly()?
+                    .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+                    .InformationalVersion;
+
+                // Example: [assembly: AssemblyInformationalVersion("2025.613.0-tachyon+d934e574b2539e8787956c3c9ecce9dadebb10ee")]
+                if (!string.IsNullOrEmpty(informationalVersion))
+                    return informationalVersion.Split('+').First();
+
+                Version version = AssemblyVersion;
+                return $@"{version.Major}.{version.Minor}.{version.Build}-lazer";
             }
         }
 
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs b/osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs
index 74b523fdec..f2630caa83 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs
@@ -38,6 +38,7 @@ namespace osu.Game.Overlays.BeatmapSet
 
         public readonly Bindable<APIBeatmap?> Beatmap = new Bindable<APIBeatmap?>();
         private APIBeatmapSet? beatmapSet;
+        private readonly Box background;
 
         public APIBeatmapSet? BeatmapSet
         {
@@ -68,12 +69,29 @@ namespace osu.Game.Overlays.BeatmapSet
                     Direction = FillDirection.Vertical,
                     Children = new Drawable[]
                     {
-                        Difficulties = new DifficultiesContainer
+                        new Container
                         {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.Both,
                             Margin = new MarginPadding { Left = -(tile_icon_padding + tile_spacing / 2), Bottom = 10 },
-                            OnLostHover = () => showBeatmap(Beatmap.Value, withStarRating: false),
+                            Children = new Drawable[]
+                            {
+                                new Container
+                                {
+                                    Masking = true,
+                                    CornerRadius = 10,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Child = background = new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Alpha = 0.5f
+                                    }
+                                },
+                                Difficulties = new DifficultiesContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    OnLostHover = () => showBeatmap(Beatmap.Value, withStarRating: false),
+                                },
+                            }
                         },
                         infoContainer = new LinkFlowContainer(t => t.Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 11))
                         {
@@ -108,9 +126,10 @@ namespace osu.Game.Overlays.BeatmapSet
         private IBindable<RulesetInfo> ruleset { get; set; } = null!;
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider colourProvider)
         {
             updateDisplay();
+            background.Colour = colourProvider.Background3;
         }
 
         protected override void LoadComplete()
@@ -123,6 +142,12 @@ namespace osu.Game.Overlays.BeatmapSet
             Beatmap.TriggerChange();
         }
 
+        protected override void Update()
+        {
+            base.Update();
+            Difficulties.MaximumSize = new Vector2(DrawWidth, float.MaxValue);
+        }
+
         private void updateDisplay()
         {
             Difficulties.Clear();
@@ -240,8 +265,8 @@ namespace osu.Game.Overlays.BeatmapSet
         public partial class DifficultySelectorButton : OsuClickableContainer, IStateful<DifficultySelectorState>
         {
             private const float transition_duration = 100;
-            private const float size = 54;
-            private const float background_size = size - 2;
+            private const float size = 40;
+            private const float background_size = size - 1;
 
             private readonly Container background;
             private readonly Box backgroundBox;
@@ -276,7 +301,6 @@ namespace osu.Game.Overlays.BeatmapSet
             {
                 Beatmap = beatmapInfo;
                 Size = new Vector2(size);
-                Margin = new MarginPadding { Horizontal = tile_spacing / 2 };
 
                 Children = new Drawable[]
                 {
@@ -284,7 +308,8 @@ namespace osu.Game.Overlays.BeatmapSet
                     {
                         Size = new Vector2(background_size),
                         Masking = true,
-                        CornerRadius = 4,
+                        CornerRadius = 10,
+                        BorderThickness = 3,
                         Child = backgroundBox = new Box
                         {
                             RelativeSizeAxes = Axes.Both,
@@ -338,6 +363,7 @@ namespace osu.Game.Overlays.BeatmapSet
             private void load(OverlayColourProvider colourProvider)
             {
                 backgroundBox.Colour = colourProvider.Background6;
+                background.BorderColour = colourProvider.Light2;
             }
         }
 
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
index 9b10f6156d..f75e7b1d3c 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
@@ -16,6 +16,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
+using osu.Game.Beatmaps.Drawables.Cards;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
@@ -46,6 +47,8 @@ namespace osu.Game.Overlays.BeatmapSet
         private readonly Box coverGradient;
         private readonly LinkFlowContainer title, artist;
         private readonly AuthorInfo author;
+        private readonly VideoIconPill videoIconPill;
+        private readonly StoryboardIconPill storyboardIconPill;
 
         private ExternalLinkButton externalLink;
 
@@ -175,13 +178,42 @@ namespace osu.Game.Overlays.BeatmapSet
                         Spacing = new Vector2(10),
                         Children = new Drawable[]
                         {
-                            onlineStatusPill = new BeatmapSetOnlineStatusPill
+                            new FillFlowContainer
                             {
-                                Anchor = Anchor.TopRight,
-                                Origin = Anchor.TopRight,
-                                TextSize = 14,
-                                TextPadding = new MarginPadding { Horizontal = 35, Vertical = 10 }
+                                AutoSizeAxes = Axes.Y,
+                                RelativeSizeAxes = Axes.X,
+                                Direction = FillDirection.Horizontal,
+                                Spacing = new Vector2(10),
+                                Children = new Drawable[]
+                                {
+                                    onlineStatusPill = new BeatmapSetOnlineStatusPill
+                                    {
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        TextSize = 14,
+                                        TextPadding = new MarginPadding { Horizontal = 35, Vertical = 10 }
+                                    },
+                                    storyboardIconPill = new StoryboardIconPill
+                                    {
+                                        AutoSizeAxes = Axes.X,
+                                        RelativeSizeAxes = Axes.Y,
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        IconSize = new Vector2(34),
+                                        IconPadding = new MarginPadding(10),
+                                    },
+                                    videoIconPill = new VideoIconPill
+                                    {
+                                        AutoSizeAxes = Axes.X,
+                                        RelativeSizeAxes = Axes.Y,
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        IconSize = new Vector2(34),
+                                        IconPadding = new MarginPadding(10),
+                                    },
+                                }
                             },
+
                             Details = new Details(),
                         },
                     },
@@ -218,6 +250,8 @@ namespace osu.Game.Overlays.BeatmapSet
                 if (setInfo.NewValue == null)
                 {
                     onlineStatusPill.FadeTo(0.5f, 500, Easing.OutQuint);
+                    videoIconPill.Hide();
+                    storyboardIconPill.Hide();
                     fadeContent.Hide();
 
                     loading.Show();
@@ -235,6 +269,16 @@ namespace osu.Game.Overlays.BeatmapSet
 
                     loading.Hide();
 
+                    if (setInfo.NewValue.HasVideo)
+                        videoIconPill.Show();
+                    else
+                        videoIconPill.Hide();
+
+                    if (setInfo.NewValue.HasStoryboard)
+                        storyboardIconPill.Show();
+                    else
+                        storyboardIconPill.Hide();
+
                     var titleText = new RomanisableString(setInfo.NewValue.TitleUnicode, setInfo.NewValue.Title);
                     var artistText = new RomanisableString(setInfo.NewValue.ArtistUnicode, setInfo.NewValue.Artist);
 
diff --git a/osu.Game/Overlays/ChangelogOverlay.cs b/osu.Game/Overlays/ChangelogOverlay.cs
index 4cc38c41e4..dafa14f7e7 100644
--- a/osu.Game/Overlays/ChangelogOverlay.cs
+++ b/osu.Game/Overlays/ChangelogOverlay.cs
@@ -76,16 +76,18 @@ namespace osu.Game.Overlays
             Show();
         }
 
-        public void ShowBuild([NotNull] string updateStream, [NotNull] string version)
+        public void ShowBuild([NotNull] string version)
         {
-            ArgumentNullException.ThrowIfNull(updateStream);
             ArgumentNullException.ThrowIfNull(version);
 
             Show();
 
             performAfterFetch(() =>
             {
-                var build = builds.Find(b => b.Version == version && b.UpdateStream.Name == updateStream)
+                string versionPart = version.Split('-')[0];
+                string updateStream = version.Split('-')[1];
+
+                var build = builds.Find(b => b.Version == versionPart && b.UpdateStream.Name == updateStream)
                             ?? Streams.Find(s => s.Name == updateStream)?.LatestBuild;
 
                 if (build != null)
diff --git a/osu.Game/Overlays/Chat/DrawableChatUsername.cs b/osu.Game/Overlays/Chat/DrawableChatUsername.cs
index 57338dde9f..bd39cf0253 100644
--- a/osu.Game/Overlays/Chat/DrawableChatUsername.cs
+++ b/osu.Game/Overlays/Chat/DrawableChatUsername.cs
@@ -28,6 +28,7 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
+using osu.Game.Users;
 using osuTK;
 using osuTK.Graphics;
 using ChatStrings = osu.Game.Localisation.ChatStrings;
@@ -92,6 +93,9 @@ namespace osu.Game.Overlays.Chat
         [Resolved]
         private Bindable<Channel?>? currentChannel { get; set; }
 
+        [Resolved]
+        private IDialogOverlay? dialogOverlay { get; set; }
+
         private readonly APIUser user;
         private readonly OsuSpriteText drawableText;
 
@@ -208,6 +212,9 @@ namespace osu.Game.Overlays.Chat
 
                 items.Add(new OsuMenuItemSpacer());
                 items.Add(new OsuMenuItem(UsersStrings.ReportButtonText, MenuItemType.Destructive, ReportRequested));
+                items.Add(api.Blocks.Any(b => b.TargetID == user.OnlineID)
+                    ? new OsuMenuItem(UsersStrings.BlocksButtonUnblock, MenuItemType.Standard, () => dialogOverlay?.Push(ConfirmBlockActionDialog.Unblock(user)))
+                    : new OsuMenuItem(UsersStrings.BlocksButtonBlock, MenuItemType.Destructive, () => dialogOverlay?.Push(ConfirmBlockActionDialog.Block(user))));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Overlays/Dashboard/CurrentlyOnlineDisplay.cs b/osu.Game/Overlays/Dashboard/CurrentlyOnlineDisplay.cs
index 39df3ba22c..02fe681492 100644
--- a/osu.Game/Overlays/Dashboard/CurrentlyOnlineDisplay.cs
+++ b/osu.Game/Overlays/Dashboard/CurrentlyOnlineDisplay.cs
@@ -197,6 +197,7 @@ namespace osu.Game.Overlays.Dashboard
                     case UserActivity.InSoloGame:
                     case UserActivity.InMultiplayerGame:
                     case UserActivity.InPlaylistGame:
+                    case UserActivity.PlayingDailyChallenge:
                         spectateButton.Enabled.Value = true;
                         break;
                 }
diff --git a/osu.Game/Overlays/FirstRunSetup/ScreenUIScale.cs b/osu.Game/Overlays/FirstRunSetup/ScreenUIScale.cs
index fc64408775..edadc333c8 100644
--- a/osu.Game/Overlays/FirstRunSetup/ScreenUIScale.cs
+++ b/osu.Game/Overlays/FirstRunSetup/ScreenUIScale.cs
@@ -25,7 +25,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Screens;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -101,11 +101,14 @@ namespace osu.Game.Overlays.FirstRunSetup
             }
         }
 
-        private partial class NestedSongSelect : PlaySongSelect
+        private partial class NestedSongSelect : SoloSongSelect
         {
-            protected override bool ControlGlobalMusic => false;
-
             public override bool? ApplyModTrackAdjustments => false;
+
+            public NestedSongSelect()
+            {
+                ControlGlobalMusic = false;
+            }
         }
 
         private partial class UIScaleSlider : RoundedSliderBar<float>
@@ -145,16 +148,17 @@ namespace osu.Game.Overlays.FirstRunSetup
             protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
                 new DependencyContainer(new DependencyIsolationContainer(base.CreateChildDependencies(parent)));
 
+            private ScreenFooter footer;
+
             [BackgroundDependencyLoader]
             private void load(AudioManager audio, TextureStore textures, RulesetStore rulesets)
             {
-                Beatmap.Value = new DummyWorkingBeatmap(audio, textures);
+                Beatmap.Default = Beatmap.Value = new DummyWorkingBeatmap(audio, textures);
 
                 Ruleset.Value = rulesets.AvailableRulesets.First();
 
                 OsuScreenStack stack;
                 OsuLogo logo;
-                ScreenFooter footer;
 
                 Padding = new MarginPadding(5);
 
@@ -192,6 +196,13 @@ namespace osu.Game.Overlays.FirstRunSetup
                 // intentionally load synchronously so it is included in the initial load of the first run screen.
                 stack.PushSynchronously(screen);
             }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                footer.Show();
+            }
         }
 
         private class DependencyIsolationContainer : IReadOnlyDependencyContainer
diff --git a/osu.Game/Overlays/Profile/Header/CentreHeaderContainer.cs b/osu.Game/Overlays/Profile/Header/CentreHeaderContainer.cs
index d964364510..3f669ebfe3 100644
--- a/osu.Game/Overlays/Profile/Header/CentreHeaderContainer.cs
+++ b/osu.Game/Overlays/Profile/Header/CentreHeaderContainer.cs
@@ -55,6 +55,10 @@ namespace osu.Game.Overlays.Profile.Header
                         {
                             User = { BindTarget = User }
                         },
+                        new UserActionsButton
+                        {
+                            User = { BindTarget = User }
+                        }
                     }
                 },
                 new Container
diff --git a/osu.Game/Overlays/Profile/Header/Components/UserActionsButton.cs b/osu.Game/Overlays/Profile/Header/Components/UserActionsButton.cs
new file mode 100644
index 0000000000..b8e7e96665
--- /dev/null
+++ b/osu.Game/Overlays/Profile/Header/Components/UserActionsButton.cs
@@ -0,0 +1,211 @@
+// 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.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+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.UserInterfaceV2;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Resources.Localisation.Web;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Overlays.Profile.Header.Components
+{
+    public partial class UserActionsButton : OsuHoverContainer, IHasPopover
+    {
+        public readonly Bindable<UserProfileData?> User = new Bindable<UserProfileData?>();
+
+        private Box background = null!;
+
+        protected override IEnumerable<Drawable> EffectTargets => [background];
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            IdleColour = colourProvider.Background2;
+            HoverColour = colourProvider.Background1;
+
+            Size = new Vector2(40);
+            Masking = true;
+            CornerRadius = 20;
+
+            Child = new CircularContainer
+            {
+                Masking = true,
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new SpriteIcon
+                    {
+                        Size = new Vector2(12),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Icon = FontAwesome.Solid.EllipsisV,
+                    },
+                }
+            };
+
+            Action = this.ShowPopover;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            User.BindValueChanged(_ => Alpha = User.Value?.User.OnlineID == api.LocalUser.Value.OnlineID ? 0 : 1, true);
+        }
+
+        public Popover GetPopover() => new UserActionPopover(User.Value!.User);
+
+        private partial class UserActionPopover : OsuPopover
+        {
+            private readonly APIUser user;
+
+            public UserActionPopover(APIUser user)
+                : base(false)
+            {
+                this.user = user;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider, IAPIProvider api, IDialogOverlay? dialogOverlay)
+            {
+                Background.Colour = colourProvider.Background6;
+
+                bool userBlocked = api.Blocks.Any(b => b.TargetID == user.Id);
+
+                AllowableAnchors = [Anchor.BottomCentre, Anchor.TopCentre];
+
+                Child = new FillFlowContainer
+                {
+                    Width = 160,
+                    AutoSizeAxes = Axes.Y,
+                    Padding = new MarginPadding { Horizontal = 5, Vertical = 10 },
+                    Children = new Drawable[]
+                    {
+                        new UserAction(FontAwesome.Solid.Ban, userBlocked ? UsersStrings.BlocksButtonUnblock : UsersStrings.BlocksButtonBlock)
+                        {
+                            Action = () =>
+                            {
+                                dialogOverlay?.Push(userBlocked ? ConfirmBlockActionDialog.Unblock(user) : ConfirmBlockActionDialog.Block(user));
+                                this.HidePopover();
+                            }
+                        }
+                    }
+                };
+            }
+        }
+
+        private partial class UserAction : OsuClickableContainer
+        {
+            private readonly IconUsage icon;
+            private readonly LocalisableString caption;
+
+            private Box background = null!;
+            private CircularContainer indicator = null!;
+
+            public UserAction(IconUsage icon, LocalisableString caption)
+            {
+                this.icon = icon;
+                this.caption = caption;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                RelativeSizeAxes = Content.RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Content.AutoSizeAxes = Axes.Y;
+
+                Masking = true;
+                CornerRadius = 4;
+                Children = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background5,
+                        Alpha = 0,
+                    },
+                    indicator = new Circle
+                    {
+                        Width = 4,
+                        Height = 14,
+                        X = 10,
+                        Colour = colourProvider.Highlight1,
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.Centre,
+                        Alpha = 0,
+                    },
+                    new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Y,
+                        RelativeSizeAxes = Axes.X,
+                        Padding = new MarginPadding { Horizontal = 25, Vertical = 5 },
+                        Direction = FillDirection.Horizontal,
+                        Spacing = new Vector2(5, 0),
+                        Children = new Drawable[]
+                        {
+                            new SpriteIcon
+                            {
+                                Icon = icon,
+                                Size = new Vector2(11),
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                            },
+                            new OsuSpriteText
+                            {
+                                Text = caption,
+                                Font = OsuFont.Style.Body,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                UseFullGlyphHeight = false,
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateState();
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateState();
+                base.OnHoverLost(e);
+            }
+
+            private void updateState()
+            {
+                background.Alpha = indicator.Alpha = IsHovered ? 1 : 0;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs b/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
index ac6215f3ad..f0428a4c92 100644
--- a/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/General/UpdateSettings.cs
@@ -28,9 +28,9 @@ namespace osu.Game.Overlays.Settings.Sections.General
         protected override LocalisableString Header => GeneralSettingsStrings.UpdateHeader;
 
         private SettingsButton checkForUpdatesButton = null!;
+        private SettingsEnumDropdown<ReleaseStream> releaseStreamDropdown = null!;
 
         private readonly Bindable<ReleaseStream> configReleaseStream = new Bindable<ReleaseStream>();
-        private SettingsEnumDropdown<ReleaseStream> releaseStreamDropdown = null!;
 
         [Resolved]
         private UpdateManager? updateManager { get; set; }
@@ -44,50 +44,50 @@ namespace osu.Game.Overlays.Settings.Sections.General
         [Resolved]
         private OsuGame? game { get; set; }
 
+        [Resolved]
+        private IDialogOverlay? dialogOverlay { get; set; }
+
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config, IDialogOverlay? dialogOverlay)
+        private void load(OsuConfigManager config)
         {
             config.BindWith(OsuSetting.ReleaseStream, configReleaseStream);
 
-            if (updateManager?.CanCheckForUpdate == true)
+            bool isDesktop = RuntimeInfo.IsDesktop;
+            bool canCheckUpdates = updateManager?.CanCheckForUpdate == true;
+
+            if (canCheckUpdates)
             {
-                Add(releaseStreamDropdown = new SettingsEnumDropdown<ReleaseStream>
+                // For simplicity, hide the concept of release streams from mobile users.
+                if (isDesktop)
                 {
-                    LabelText = GeneralSettingsStrings.ReleaseStream,
-                    Current = { Value = configReleaseStream.Value },
-                });
+                    Add(releaseStreamDropdown = new SettingsEnumDropdown<ReleaseStream>
+                    {
+                        LabelText = GeneralSettingsStrings.ReleaseStream,
+                        Current = { Value = configReleaseStream.Value },
+                        Keywords = new[] { @"version" },
+                    });
+
+                    if (updateManager!.FixedReleaseStream != null)
+                    {
+                        configReleaseStream.Value = updateManager.FixedReleaseStream.Value;
+
+                        releaseStreamDropdown.ShowsDefaultIndicator = false;
+                        releaseStreamDropdown.Items = [updateManager.FixedReleaseStream.Value];
+                        releaseStreamDropdown.SetNoticeText(GeneralSettingsStrings.ChangeReleaseStreamPackageManagerWarning);
+                    }
+
+                    releaseStreamDropdown.Current.BindValueChanged(releaseStreamChanged);
+                }
 
                 Add(checkForUpdatesButton = new SettingsButton
                 {
                     Text = GeneralSettingsStrings.CheckUpdate,
                     Action = () => checkForUpdates().FireAndForget()
                 });
-
-                releaseStreamDropdown.Current.BindValueChanged(stream =>
-                {
-                    if (stream.NewValue == ReleaseStream.Tachyon)
-                    {
-                        dialogOverlay?.Push(new ConfirmDialog(GeneralSettingsStrings.ChangeReleaseStreamConfirmation,
-                            () =>
-                            {
-                                configReleaseStream.Value = ReleaseStream.Tachyon;
-                            },
-                            () =>
-                            {
-                                releaseStreamDropdown.Current.Value = ReleaseStream.Lazer;
-                            })
-                        {
-                            BodyText = GeneralSettingsStrings.ChangeReleaseStreamConfirmationInfo
-                        });
-
-                        return;
-                    }
-
-                    configReleaseStream.Value = stream.NewValue;
-                });
             }
 
-            if (RuntimeInfo.IsDesktop)
+            // Loosely update-related maintenance buttons.
+            if (isDesktop)
             {
                 Add(new SettingsButton
                 {
@@ -111,6 +111,24 @@ namespace osu.Game.Overlays.Settings.Sections.General
             }
         }
 
+        private void releaseStreamChanged(ValueChangedEvent<ReleaseStream> stream)
+        {
+            if (stream.NewValue == ReleaseStream.Tachyon)
+            {
+                dialogOverlay?.Push(
+                    new ConfirmDialog(GeneralSettingsStrings.ChangeReleaseStreamConfirmation,
+                        () => configReleaseStream.Value = ReleaseStream.Tachyon,
+                        () => releaseStreamDropdown.Current.Value = ReleaseStream.Lazer)
+                    {
+                        BodyText = GeneralSettingsStrings.ChangeReleaseStreamConfirmationInfo
+                    });
+
+                return;
+            }
+
+            configReleaseStream.Value = stream.NewValue;
+        }
+
         private async Task checkForUpdates()
         {
             if (updateManager == null || game == null)
@@ -126,7 +144,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
             try
             {
-                bool foundUpdate = await updateManager.CheckForUpdateAsync().ConfigureAwait(true);
+                bool foundUpdate = await updateManager.CheckForUpdateAsync(checkingNotification.CancellationToken).ConfigureAwait(true);
 
                 if (!foundUpdate)
                 {
@@ -142,8 +160,9 @@ namespace osu.Game.Overlays.Settings.Sections.General
             }
             finally
             {
-                // This sequence allows the notification to be immediately dismissed.
-                checkingNotification.State = ProgressNotificationState.Cancelled;
+                // This sequence allows the notification to be immediately dismissed without posting a continuation message.
+                checkingNotification.CompletionTarget = null;
+                checkingNotification.State = ProgressNotificationState.Completed;
                 checkingNotification.Close(false);
                 checkForUpdatesButton.Enabled.Value = true;
             }
diff --git a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
index 3ce546785a..6aebec88a9 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
@@ -5,7 +5,6 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -113,15 +112,12 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                             AutoSizeAxes = Axes.Y,
                         }.With(t =>
                         {
-                            if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows || RuntimeInfo.OS == RuntimeInfo.Platform.Linux)
-                            {
-                                t.NewLine();
-                                var formattedSource = MessageFormatter.FormatText(localisation.GetLocalisedString(TabletSettingsStrings.NoTabletDetectedDescription(
-                                    RuntimeInfo.OS == RuntimeInfo.Platform.Windows
-                                        ? @"https://opentabletdriver.net/Wiki/FAQ/Windows"
-                                        : @"https://opentabletdriver.net/Wiki/FAQ/Linux")));
-                                t.AddLinks(formattedSource.Text, formattedSource.Links);
-                            }
+                            t.NewLine();
+
+                            const string url = @"https://opentabletdriver.net/Wiki/FAQ/General";
+                            var formattedSource = MessageFormatter.FormatText(localisation.GetLocalisedString(TabletSettingsStrings.NoTabletDetectedDescription(url)));
+
+                            t.AddLinks(formattedSource.Text, formattedSource.Links);
                         }),
                     }
                 },
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index 84767c8619..eef8030121 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -175,9 +175,12 @@ namespace osu.Game.Overlays.Settings.Sections
                 base.LoadComplete();
 
                 currentSkin = skins.CurrentSkin.GetBoundCopy();
-                currentSkin.BindValueChanged(skin => Enabled.Value = skin.NewValue.SkinInfo.PerformRead(s => !s.Protected), true);
+                currentSkin.BindValueChanged(_ => updateState());
+                currentSkin.BindDisabledChanged(_ => updateState(), true);
             }
 
+            private void updateState() => Enabled.Value = !currentSkin.Disabled && currentSkin.Value.SkinInfo.PerformRead(s => !s.Protected);
+
             public Popover GetPopover()
             {
                 return new RenameSkinPopover();
@@ -203,9 +206,12 @@ namespace osu.Game.Overlays.Settings.Sections
                 base.LoadComplete();
 
                 currentSkin = skins.CurrentSkin.GetBoundCopy();
-                currentSkin.BindValueChanged(skin => Enabled.Value = skin.NewValue.SkinInfo.PerformRead(s => !s.Protected), true);
+                currentSkin.BindValueChanged(_ => updateState());
+                currentSkin.BindDisabledChanged(_ => updateState(), true);
             }
 
+            private void updateState() => Enabled.Value = !currentSkin.Disabled && currentSkin.Value.SkinInfo.PerformRead(s => !s.Protected);
+
             private void export()
             {
                 try
@@ -241,9 +247,12 @@ namespace osu.Game.Overlays.Settings.Sections
                 base.LoadComplete();
 
                 currentSkin = skins.CurrentSkin.GetBoundCopy();
-                currentSkin.BindValueChanged(skin => Enabled.Value = skin.NewValue.SkinInfo.PerformRead(s => !s.Protected), true);
+                currentSkin.BindValueChanged(_ => updateState());
+                currentSkin.BindDisabledChanged(_ => updateState(), true);
             }
 
+            private void updateState() => Enabled.Value = !currentSkin.Disabled && currentSkin.Value.SkinInfo.PerformRead(s => !s.Protected);
+
             private void delete()
             {
                 dialogOverlay?.Push(new SkinDeleteDialog(currentSkin.Value));
diff --git a/osu.Game/Overlays/Settings/SettingsFooter.cs b/osu.Game/Overlays/Settings/SettingsFooter.cs
index 307d88e712..f50fca418d 100644
--- a/osu.Game/Overlays/Settings/SettingsFooter.cs
+++ b/osu.Game/Overlays/Settings/SettingsFooter.cs
@@ -100,7 +100,7 @@ namespace osu.Game.Overlays.Settings
             [BackgroundDependencyLoader]
             private void load(ChangelogOverlay? changelog)
             {
-                Action = () => changelog?.ShowBuild(OsuGameBase.CLIENT_STREAM_NAME, version);
+                Action = () => changelog?.ShowBuild(version);
 
                 Add(new OsuSpriteText
                 {
diff --git a/osu.Game/Overlays/Settings/SettingsItem.cs b/osu.Game/Overlays/Settings/SettingsItem.cs
index 9c6bb5ae60..9186734641 100644
--- a/osu.Game/Overlays/Settings/SettingsItem.cs
+++ b/osu.Game/Overlays/Settings/SettingsItem.cs
@@ -45,7 +45,18 @@ namespace osu.Game.Overlays.Settings
 
         private OsuTextFlowContainer noticeText;
 
-        public bool ShowsDefaultIndicator = true;
+        private bool showsDefaultIndicator = true;
+
+        public bool ShowsDefaultIndicator
+        {
+            get => showsDefaultIndicator;
+            set
+            {
+                showsDefaultIndicator = value;
+                defaultValueIndicatorContainer.Alpha = value ? 1 : 0;
+            }
+        }
+
         private readonly Container defaultValueIndicatorContainer;
 
         public LocalisableString TooltipText { get; set; }
@@ -214,17 +225,14 @@ namespace osu.Game.Overlays.Settings
         [BackgroundDependencyLoader]
         private void load()
         {
-            // intentionally done before LoadComplete to avoid overhead.
-            if (ShowsDefaultIndicator)
+            defaultValueIndicatorContainer.Child = new RevertToDefaultButton<T>
             {
-                defaultValueIndicatorContainer.Add(new RevertToDefaultButton<T>
-                {
-                    Current = controlWithCurrent.Current,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre
-                });
-                updateLayout();
-            }
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Current = controlWithCurrent.Current,
+            };
+
+            updateLayout();
         }
 
         private void updateLayout()
diff --git a/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs b/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs
new file mode 100644
index 0000000000..e4ac157936
--- /dev/null
+++ b/osu.Game/Overlays/SkinEditor/ExternalEditOverlay.cs
@@ -0,0 +1,284 @@
+// 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.IO;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays.SkinEditor
+{
+    public partial class ExternalEditOverlay : OsuFocusedOverlayContainer
+    {
+        private const double transition_duration = 300;
+        private FillFlowContainer flow = null!;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        [Resolved]
+        private GameHost gameHost { get; set; } = null!;
+
+        [Resolved]
+        private SkinManager skinManager { get; set; } = null!;
+
+        private ExternalEditOperation<SkinInfo>? editOperation;
+        private TaskCompletionSource? taskCompletionSource;
+
+        protected override bool DimMainContent => false;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+            InternalChild = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    // Since we're drawing this overlay on top of another overlay (SkinEditor), the dimming effect isn't applied. So we need to add a dimming effect manually.
+                    new Box
+                    {
+                        Colour = Color4.Black.Opacity(0.5f),
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new Container
+                    {
+                        Masking = true,
+                        CornerRadius = 20,
+                        AutoSizeAxes = Axes.Both,
+                        AutoSizeDuration = 500,
+                        AutoSizeEasing = Easing.OutQuint,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Colour = colourProvider.Background5,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            flow = new FillFlowContainer
+                            {
+                                Margin = new MarginPadding(20),
+                                AutoSizeAxes = Axes.Both,
+                                Direction = FillDirection.Vertical,
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                                Spacing = new Vector2(15),
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        public async Task<Task> Begin(SkinInfo skinInfo)
+        {
+            if (taskCompletionSource != null)
+                throw new InvalidOperationException("Cannot start multiple concurrent external edits!");
+
+            Show();
+            showSpinner("Mounting external skin...");
+            setGlobalSkinDisabled(true);
+
+            await Task.Delay(500).ConfigureAwait(true);
+
+            try
+            {
+                editOperation = await skinManager.BeginExternalEditing(skinInfo).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Failed to initialize external edit operation: {ex}", LoggingTarget.Database, LogLevel.Error);
+                setGlobalSkinDisabled(false);
+                Schedule(() => showSpinner("Export failed!"));
+                Scheduler.AddDelayed(Hide, 1000);
+                return Task.FromException(ex);
+            }
+
+            Schedule(() =>
+            {
+                flow.Children = new Drawable[]
+                {
+                    new OsuSpriteText
+                    {
+                        Text = "Skin is mounted externally",
+                        Font = OsuFont.Default.With(size: 30),
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                    },
+                    new OsuTextFlowContainer
+                    {
+                        Padding = new MarginPadding(5),
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Width = 350,
+                        AutoSizeAxes = Axes.Y,
+                        Text = "Any changes made to the exported folder will be imported to the game, including file additions, modifications and deletions.",
+                    },
+                    new PurpleRoundedButton
+                    {
+                        Text = "Open folder",
+                        Width = 350,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Action = openDirectory,
+                        Enabled = { Value = false }
+                    },
+                    new DangerousRoundedButton
+                    {
+                        Text = EditorStrings.FinishEditingExternally,
+                        Width = 350,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Action = () => finish().FireAndForget(),
+                        Enabled = { Value = false }
+                    }
+                };
+            });
+
+            Scheduler.AddDelayed(() =>
+            {
+                foreach (var b in flow.ChildrenOfType<RoundedButton>())
+                    b.Enabled.Value = true;
+                openDirectory();
+            }, 1000);
+            return (taskCompletionSource = new TaskCompletionSource()).Task;
+        }
+
+        private void openDirectory()
+        {
+            if (editOperation == null)
+                return;
+
+            gameHost.OpenFileExternally(editOperation.MountedPath.TrimDirectorySeparator() + Path.DirectorySeparatorChar);
+        }
+
+        private async Task finish()
+        {
+            Debug.Assert(taskCompletionSource != null);
+
+            showSpinner("Cleaning up...");
+            await Task.Delay(500).ConfigureAwait(true);
+
+            try
+            {
+                await editOperation!.Finish().ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Failed to finish external edit operation: {ex}", LoggingTarget.Database, LogLevel.Error);
+                showSpinner("Import failed!");
+                Scheduler.AddDelayed(Hide, 1000);
+                setGlobalSkinDisabled(false);
+                taskCompletionSource.SetException(ex);
+                taskCompletionSource = null;
+                return;
+            }
+
+            Schedule(() =>
+            {
+                var oldSkin = skinManager.CurrentSkin!.Value;
+                var newSkinInfo = oldSkin.SkinInfo.PerformRead(s => s);
+
+                // Create a new skin instance to ensure the skin is reloaded
+                // If there's a better way to reload the skin, this should be replaced with it.
+                setGlobalSkinDisabled(false);
+                skinManager.CurrentSkin.Value = newSkinInfo.CreateInstance(skinManager);
+
+                oldSkin.Dispose();
+
+                Hide();
+            });
+            taskCompletionSource.SetResult();
+            taskCompletionSource = null;
+        }
+
+        private void setGlobalSkinDisabled(bool disabled)
+        {
+            skinManager.CurrentSkin.Disabled = disabled;
+            skinManager.CurrentSkinInfo.Disabled = disabled;
+        }
+
+        protected override void PopIn()
+        {
+            this.FadeIn(transition_duration, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            this.FadeOut(transition_duration, Easing.OutQuint).Finally(_ =>
+            {
+                // Set everything to a clean state
+                editOperation = null;
+                flow.Children = Array.Empty<Drawable>();
+            });
+        }
+
+        public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            if (e.Repeat)
+                return false;
+
+            switch (e.Action)
+            {
+                case GlobalAction.Back:
+                case GlobalAction.Select:
+                    if (editOperation == null) return base.OnPressed(e);
+
+                    finish().FireAndForget();
+                    return true;
+            }
+
+            return base.OnPressed(e);
+        }
+
+        private void showSpinner(string text)
+        {
+            foreach (var b in flow.ChildrenOfType<RoundedButton>())
+                b.Enabled.Value = false;
+
+            flow.Children = new Drawable[]
+            {
+                new OsuSpriteText
+                {
+                    Text = text,
+                    Font = OsuFont.Default.With(size: 30),
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                },
+                new LoadingSpinner
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    State = { Value = Visibility.Visible }
+                },
+            };
+        }
+    }
+}
diff --git a/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs b/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
index 85becc1a23..4a3ae99116 100644
--- a/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
@@ -219,7 +219,7 @@ namespace osu.Game.Overlays.SkinEditor
             }
         }
 
-        public partial class DependencyBorrowingContainer : Container
+        private partial class DependencyBorrowingContainer : Container
         {
             protected override bool ShouldBeConsideredForInput(Drawable child) => false;
 
@@ -232,8 +232,19 @@ namespace osu.Game.Overlays.SkinEditor
                 this.donor = donor;
             }
 
-            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
-                new DependencyContainer(donor?.Dependencies ?? base.CreateChildDependencies(parent));
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            {
+                var baseDependencies = base.CreateChildDependencies(parent);
+                if (donor == null)
+                    return baseDependencies;
+
+                var dependencies = new DependencyContainer(donor.Dependencies);
+                // inject `SkinEditor` again *on top* of the borrowed dependencies.
+                // this is designed to let components know when they are being displayed in the context of the skin editor
+                // via attempting to resolve `SkinEditor`.
+                dependencies.CacheAs(baseDependencies.Get<SkinEditor>());
+                return dependencies;
+            }
         }
     }
 }
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index c1c64cac1f..f4a1bb7562 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -48,6 +48,8 @@ namespace osu.Game.Overlays.SkinEditor
 
         public readonly BindableList<ISerialisableDrawable> SelectedComponents = new BindableList<ISerialisableDrawable>();
 
+        public bool ExternalEditInProgress => externalEditOperation != null && !externalEditOperation.IsCompleted;
+
         protected override bool StartHidden => true;
 
         private Drawable? targetScreen;
@@ -104,6 +106,11 @@ namespace osu.Game.Overlays.SkinEditor
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
+        [Resolved]
+        private ExternalEditOverlay? externalEditOverlay { get; set; }
+
+        private Task? externalEditOperation;
+
         public SkinEditor()
         {
         }
@@ -159,6 +166,7 @@ namespace osu.Game.Overlays.SkinEditor
                                                     {
                                                         new EditorMenuItem(Web.CommonStrings.ButtonsSave, MenuItemType.Standard, () => Save()) { Hotkey = new Hotkey(PlatformAction.Save) },
                                                         new EditorMenuItem(CommonStrings.Export, MenuItemType.Standard, () => skins.ExportCurrentSkin()) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
+                                                        new EditorMenuItem(EditorStrings.EditExternally, MenuItemType.Standard, () => _ = editExternally()) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
                                                         new OsuMenuItemSpacer(),
                                                         new EditorMenuItem(CommonStrings.RevertToDefault, MenuItemType.Destructive, () => dialogOverlay?.Push(new RevertConfirmDialog(revert))),
                                                         new OsuMenuItemSpacer(),
@@ -276,6 +284,15 @@ namespace osu.Game.Overlays.SkinEditor
             selectedTarget.BindValueChanged(targetChanged, true);
         }
 
+        private async Task editExternally()
+        {
+            Save();
+
+            var skin = currentSkin.Value.SkinInfo.PerformRead(s => s.Detach());
+
+            externalEditOperation = await externalEditOverlay!.Begin(skin).ConfigureAwait(false);
+        }
+
         public bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
         {
             switch (e.Action)
@@ -436,8 +453,8 @@ namespace osu.Game.Overlays.SkinEditor
 
             headerText.Clear();
 
-            headerText.AddParagraph(SkinEditorStrings.SkinEditor, cp => cp.Font = OsuFont.Default.With(size: 16));
-            headerText.NewParagraph();
+            headerText.AddText(SkinEditorStrings.SkinEditor, cp => cp.Font = OsuFont.Default.With(size: 16));
+            headerText.NewLine();
             headerText.AddText(SkinEditorStrings.CurrentlyEditing, cp =>
             {
                 cp.Font = OsuFont.Default.With(size: 12);
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs b/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
index 571f99bd08..5e71b6922c 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditorOverlay.cs
@@ -28,7 +28,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Users;
 using osu.Game.Utils;
 
@@ -49,9 +49,15 @@ namespace osu.Game.Overlays.SkinEditor
         [Resolved]
         private IPerformFromScreenRunner? performer { get; set; }
 
+        [Resolved]
+        private IOverlayManager? overlayManager { get; set; }
+
         [Cached]
         public readonly EditorClipboard Clipboard = new EditorClipboard();
 
+        [Cached]
+        private readonly ExternalEditOverlay externalEditOverlay = new ExternalEditOverlay();
+
         [Resolved]
         private OsuGame game { get; set; } = null!;
 
@@ -69,6 +75,7 @@ namespace osu.Game.Overlays.SkinEditor
 
         private OsuScreen? lastTargetScreen;
         private InvokeOnDisposal? nestedInputManagerDisable;
+        private IDisposable? externalEditOverlayRegistration;
 
         private readonly LayoutValue drawSizeLayout;
 
@@ -86,6 +93,13 @@ namespace osu.Game.Overlays.SkinEditor
             config.BindWith(OsuSetting.BeatmapSkins, beatmapSkins);
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            externalEditOverlayRegistration = overlayManager?.RegisterBlockingOverlay(externalEditOverlay);
+        }
+
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
             switch (e.Action)
@@ -180,7 +194,7 @@ namespace osu.Game.Overlays.SkinEditor
 
                 // the validity of the current game-wide beatmap + ruleset combination is enforced by song select.
                 // if we're anywhere else, the state is unknown and may not make sense, so forcibly set something that does.
-                if (screen is not PlaySongSelect)
+                if (screen is not SoloSongSelect)
                     ruleset.Value = beatmap.Value.BeatmapInfo.Ruleset;
                 var replayGeneratingMod = ruleset.Value.CreateInstance().GetAutoplayMod();
 
@@ -194,7 +208,7 @@ namespace osu.Game.Overlays.SkinEditor
 
                 if (replayGeneratingMod != null)
                     screen.Push(new EndlessPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods)));
-            }, new[] { typeof(Player), typeof(PlaySongSelect) });
+            }, new[] { typeof(Player), typeof(SoloSongSelect) });
         }
 
         protected override void Update()
@@ -334,6 +348,22 @@ namespace osu.Game.Overlays.SkinEditor
             leasedBeatmapSkins = null;
         }
 
+        public new void ToggleVisibility()
+        {
+            if (skinEditor?.ExternalEditInProgress == true)
+                return;
+
+            base.ToggleVisibility();
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            externalEditOverlayRegistration?.Dispose();
+            externalEditOverlayRegistration = null;
+        }
+
         private partial class EndlessPlayer : ReplayPlayer
         {
             protected override UserActivity? InitialActivity => null;
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditorSceneLibrary.cs b/osu.Game/Overlays/SkinEditor/SkinEditorSceneLibrary.cs
index 5a283c0e8d..f8d5213622 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditorSceneLibrary.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditorSceneLibrary.cs
@@ -12,8 +12,9 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Screens;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osuTK;
+using SongSelect = osu.Game.Screens.Select.SongSelect;
 
 namespace osu.Game.Overlays.SkinEditor
 {
@@ -78,7 +79,7 @@ namespace osu.Game.Overlays.SkinEditor
                                         if (screen is SongSelect)
                                             return;
 
-                                        screen.Push(new PlaySongSelect());
+                                        screen.Push(new SoloSongSelect());
                                     }, new[] { typeof(SongSelect) })
                                 },
                                 new SceneButton
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
index 9fd28a1cad..c8799ad5ba 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
@@ -59,7 +59,7 @@ namespace osu.Game.Overlays.SkinEditor
             objectsInRotation = selectedItems.Cast<Drawable>().ToArray();
             originalRotations = objectsInRotation.ToDictionary(d => d, d => d.Rotation);
             originalPositions = objectsInRotation.ToDictionary(d => d, d => d.ToScreenSpace(d.OriginPosition));
-            DefaultOrigin = GeometryUtils.GetSurroundingQuad(objectsInRotation.SelectMany(d => d.ScreenSpaceDrawQuad.GetVertices().ToArray())).Centre;
+            DefaultOrigin = GeometryUtils.GetSurroundingQuad(objectsInRotation.SelectMany(d => ToLocalSpace(d.ScreenSpaceDrawQuad).GetVertices().ToArray())).Centre;
 
             base.Begin();
         }
diff --git a/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs b/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
index d5891da936..85b7358d2d 100644
--- a/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
+++ b/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
@@ -83,7 +83,12 @@ namespace osu.Game.Overlays.Toolbar
                 }
 
                 if (update.After.PP != null)
-                    pp.Display((int)(update.Before.PP ?? update.After.PP.Value), (int)Math.Abs(((int?)update.After.PP - (int?)update.Before.PP) ?? 0M), (int)update.After.PP.Value);
+                {
+                    int before = (int)Math.Round(update.Before.PP ?? update.After.PP.Value);
+                    int after = (int)Math.Round(update.After.PP.Value);
+                    int delta = Math.Abs(after - before);
+                    pp.Display(before, delta, after);
+                }
 
                 this.Delay(5000).FadeOut(500, Easing.OutQuint);
             });
diff --git a/osu.Game/Overlays/UserProfileOverlay.cs b/osu.Game/Overlays/UserProfileOverlay.cs
index 076905819e..edaa1bdc89 100644
--- a/osu.Game/Overlays/UserProfileOverlay.cs
+++ b/osu.Game/Overlays/UserProfileOverlay.cs
@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
@@ -55,13 +56,17 @@ namespace osu.Game.Overlays
         public UserProfileOverlay()
             : base(OverlayColourScheme.Pink)
         {
-            base.Content.AddRange(new Drawable[]
+            base.Content.Add(new PopoverContainer
             {
-                onlineViewContainer = new OnlineViewContainer($"Sign in to view the {Header.Title.Title}")
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both
-                },
-                loadingLayer = new LoadingLayer(true)
+                    onlineViewContainer = new OnlineViewContainer($"Sign in to view the {Header.Title.Title}")
+                    {
+                        RelativeSizeAxes = Axes.Both
+                    },
+                    loadingLayer = new LoadingLayer(true)
+                }
             });
         }
 
diff --git a/osu.Game/Replays/Legacy/LegacyReplayFrame.cs b/osu.Game/Replays/Legacy/LegacyReplayFrame.cs
index b48fc44963..bfc8ad5df8 100644
--- a/osu.Game/Replays/Legacy/LegacyReplayFrame.cs
+++ b/osu.Game/Replays/Legacy/LegacyReplayFrame.cs
@@ -64,5 +64,12 @@ namespace osu.Game.Replays.Legacy
         {
             return $"{Time}\t({MouseX},{MouseY})\t{MouseLeft}\t{MouseRight}\t{MouseLeft1}\t{MouseRight1}\t{MouseLeft2}\t{MouseRight2}\t{ButtonState}";
         }
+
+        public override bool IsEquivalentTo(ReplayFrame other)
+            => other is LegacyReplayFrame legacyFrame
+               && Time == legacyFrame.Time
+               && MouseX == legacyFrame.MouseX
+               && MouseY == legacyFrame.MouseY
+               && ButtonState == legacyFrame.ButtonState;
     }
 }
diff --git a/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs b/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs
index 2a94ae6017..55449ff4d9 100644
--- a/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs
+++ b/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.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;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Edit;
@@ -21,6 +24,7 @@ namespace osu.Game.Rulesets.Edit
         private readonly Bindable<bool> contractSidebars = new Bindable<bool>();
 
         private bool expandOnHover;
+        private OffsetMaintainingScrollContainer scrollContainer = null!;
 
         [Resolved]
         private Editor? editor { get; set; }
@@ -42,6 +46,27 @@ namespace osu.Game.Rulesets.Edit
             config.BindWith(OsuSetting.EditorContractSidebars, contractSidebars);
         }
 
+        protected override OsuScrollContainer CreateScrollContainer() => scrollContainer = new OffsetMaintainingScrollContainer();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var inputManager = GetContainingInputManager();
+
+            if (inputManager != null)
+            {
+                Expanded.BindValueChanged(_ =>
+                {
+                    // When state changes from expanded -> collapsed the mouse is no longer within the toolbox so there would be no
+                    // hovered children if we used the mouse position directly
+                    var position = new Vector2(ScreenSpaceDrawQuad.Centre.X, inputManager.CurrentState.Mouse.Position.Y);
+
+                    scrollContainer.TargetDrawable = Children.FirstOrDefault(it => it.Contains(position));
+                });
+            }
+        }
+
         protected override void Update()
         {
             base.Update();
@@ -58,5 +83,49 @@ namespace osu.Game.Rulesets.Edit
         protected override bool OnMouseDown(MouseDownEvent e) => true;
 
         protected override bool OnClick(ClickEvent e) => true;
+
+        private partial class OffsetMaintainingScrollContainer : OsuScrollContainer
+        {
+            private Drawable? targetDrawable;
+            private float targetPosition;
+
+            public Drawable? TargetDrawable
+            {
+                get => targetDrawable;
+                set
+                {
+                    targetDrawable = value;
+
+                    if (value != null)
+                        targetPosition = ToLocalSpace(value.ScreenSpaceDrawQuad.TopLeft).Y;
+                }
+            }
+
+            protected override void UpdateAfterChildren()
+            {
+                if (targetDrawable != null)
+                {
+                    float currentPosition = ToLocalSpace(targetDrawable.ScreenSpaceDrawQuad.TopLeft).Y;
+
+                    if (!Precision.AlmostEquals(targetPosition, currentPosition))
+                    {
+                        double offset = currentPosition - targetPosition;
+
+                        double scrollTarget = Math.Clamp(Current + offset, 0, ScrollableExtent);
+
+                        ScrollTo(scrollTarget, false, double.PositiveInfinity);
+                    }
+                }
+
+                base.UpdateAfterChildren();
+            }
+
+            protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = null)
+            {
+                targetDrawable = null;
+
+                base.OnUserScroll(value, animated, distanceDecay);
+            }
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs b/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
index 83d5fb027e..db16e771d3 100644
--- a/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
+++ b/osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs
@@ -34,8 +34,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override bool Ranked => true;
 
-        public override bool ValidForFreestyleAsRequiredMod => true;
-
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get
diff --git a/osu.Game/Rulesets/Mods/ModClassic.cs b/osu.Game/Rulesets/Mods/ModClassic.cs
index e20ac5dfc7..66d6ea2e66 100644
--- a/osu.Game/Rulesets/Mods/ModClassic.cs
+++ b/osu.Game/Rulesets/Mods/ModClassic.cs
@@ -31,6 +31,6 @@ namespace osu.Game.Rulesets.Mods
         /// </summary>
         public sealed override bool Ranked => false;
 
-        public sealed override bool ValidForFreestyleAsRequiredMod => true;
+        public sealed override bool ValidForFreestyleAsRequiredMod => false;
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs b/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
index 15ce583413..dbc690bd15 100644
--- a/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
+++ b/osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs
@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Mods
         {
             get
             {
-                if (UserAdjustedSettingsCount != 1)
+                if (!IsExactlyOneSettingChanged(OverallDifficulty, DrainRate))
                     return string.Empty;
 
                 if (!OverallDifficulty.IsDefault) return format("OD", OverallDifficulty);
@@ -84,6 +84,24 @@ namespace osu.Game.Rulesets.Mods
             }
         }
 
+        protected bool IsExactlyOneSettingChanged(params DifficultyBindable[] difficultySettings)
+        {
+            DifficultyBindable? changedSetting = null;
+
+            foreach (var setting in difficultySettings)
+            {
+                if (setting.IsDefault)
+                    continue;
+
+                if (changedSetting != null)
+                    return false;
+
+                changedSetting = setting;
+            }
+
+            return changedSetting != null;
+        }
+
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {
             get
@@ -96,10 +114,6 @@ namespace osu.Game.Rulesets.Mods
             }
         }
 
-        public void ReadFromDifficulty(IBeatmapDifficultyInfo difficulty)
-        {
-        }
-
         public void ApplyToDifficulty(BeatmapDifficulty difficulty) => ApplySettings(difficulty);
 
         /// <summary>
@@ -111,26 +125,5 @@ namespace osu.Game.Rulesets.Mods
             if (DrainRate.Value != null) difficulty.DrainRate = DrainRate.Value.Value;
             if (OverallDifficulty.Value != null) difficulty.OverallDifficulty = OverallDifficulty.Value.Value;
         }
-
-        /// <summary>
-        /// The number of settings on this mod instance which have been adjusted by the user from their default values.
-        /// </summary>
-        protected int UserAdjustedSettingsCount
-        {
-            get
-            {
-                int count = 0;
-
-                foreach (var (_, property) in this.GetSettingsSourceProperties())
-                {
-                    var bindable = (IBindable)property.GetValue(this)!;
-
-                    if (!bindable.IsDefault)
-                        count++;
-                }
-
-                return count;
-            }
-        }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModEasy.cs b/osu.Game/Rulesets/Mods/ModEasy.cs
index b0ac0d5cce..3ee4d7846e 100644
--- a/osu.Game/Rulesets/Mods/ModEasy.cs
+++ b/osu.Game/Rulesets/Mods/ModEasy.cs
@@ -19,10 +19,6 @@ namespace osu.Game.Rulesets.Mods
         public override bool Ranked => UsesDefaultConfiguration;
         public override bool ValidForFreestyleAsRequiredMod => true;
 
-        public virtual void ReadFromDifficulty(BeatmapDifficulty difficulty)
-        {
-        }
-
         public virtual void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             const float ratio = 0.5f;
diff --git a/osu.Game/Rulesets/Mods/ModFlashlight.cs b/osu.Game/Rulesets/Mods/ModFlashlight.cs
index da45b7cc92..a88d714dce 100644
--- a/osu.Game/Rulesets/Mods/ModFlashlight.cs
+++ b/osu.Game/Rulesets/Mods/ModFlashlight.cs
@@ -37,7 +37,6 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => "Restricted view area.";
         public override bool Ranked => UsesDefaultConfiguration;
-        public override bool ValidForFreestyleAsRequiredMod => true;
 
         [SettingSource("Flashlight size", "Multiplier applied to the default flashlight size.")]
         public abstract BindableFloat SizeMultiplier { get; }
@@ -86,7 +85,7 @@ namespace osu.Game.Rulesets.Mods
             flashlight.Colour = Color4.Black;
 
             flashlight.Combo.BindTo(Combo);
-            flashlight.GetPlayfieldScale = () => drawableRuleset.Playfield.Scale;
+            flashlight.GetPlayfieldScale = () => drawableRuleset.PlayfieldAdjustmentContainer.Scale;
 
             drawableRuleset.Overlays.Add(new Container
             {
diff --git a/osu.Game/Rulesets/Mods/ModHardRock.cs b/osu.Game/Rulesets/Mods/ModHardRock.cs
index ce40e6e075..6149a9c712 100644
--- a/osu.Game/Rulesets/Mods/ModHardRock.cs
+++ b/osu.Game/Rulesets/Mods/ModHardRock.cs
@@ -22,10 +22,6 @@ namespace osu.Game.Rulesets.Mods
 
         protected const float ADJUST_RATIO = 1.4f;
 
-        public void ReadFromDifficulty(IBeatmapDifficultyInfo difficulty)
-        {
-        }
-
         public virtual void ApplyToDifficulty(BeatmapDifficulty difficulty)
         {
             difficulty.DrainRate = Math.Min(difficulty.DrainRate * ADJUST_RATIO, 10.0f);
diff --git a/osu.Game/Rulesets/Mods/ModHidden.cs b/osu.Game/Rulesets/Mods/ModHidden.cs
index f7a1336fd2..2915cb9bea 100644
--- a/osu.Game/Rulesets/Mods/ModHidden.cs
+++ b/osu.Game/Rulesets/Mods/ModHidden.cs
@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModHidden;
         public override ModType Type => ModType.DifficultyIncrease;
         public override bool Ranked => UsesDefaultConfiguration;
-        public override bool ValidForFreestyleAsRequiredMod => true;
 
         public virtual void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {
diff --git a/osu.Game/Rulesets/Objects/HitObject.cs b/osu.Game/Rulesets/Objects/HitObject.cs
index 07e07b25d3..61c6c9f46f 100644
--- a/osu.Game/Rulesets/Objects/HitObject.cs
+++ b/osu.Game/Rulesets/Objects/HitObject.cs
@@ -192,7 +192,7 @@ namespace osu.Game.Rulesets.Objects
         /// </para>
         /// </summary>
         [NotNull]
-        protected virtual HitWindows CreateHitWindows() => new HitWindows();
+        protected virtual HitWindows CreateHitWindows() => new DefaultHitWindows();
 
         /// <summary>
         /// The maximum offset from the end time of <see cref="HitObject"/> at which this <see cref="HitObject"/> can be judged.
diff --git a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
index 0162c8017b..c5a6c9e83d 100644
--- a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
@@ -335,11 +335,14 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 ArrayPool<(PathType, int)>.Shared.Return(segmentsBuffer);
             }
 
-            static Vector2 readPoint(string value, Vector2 startPos)
+            Vector2 readPoint(string value, Vector2 startPos)
             {
                 string[] vertexSplit = value.Split(':');
 
-                Vector2 pos = new Vector2((int)Parsing.ParseDouble(vertexSplit[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseDouble(vertexSplit[1], Parsing.MAX_COORDINATE_VALUE)) - startPos;
+                Vector2 pos = formatVersion >= LegacyBeatmapEncoder.FIRST_LAZER_VERSION
+                    ? new Vector2(Parsing.ParseFloat(vertexSplit[0], Parsing.MAX_COORDINATE_VALUE), Parsing.ParseFloat(vertexSplit[1], Parsing.MAX_COORDINATE_VALUE))
+                    : new Vector2((int)Parsing.ParseFloat(vertexSplit[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseFloat(vertexSplit[1], Parsing.MAX_COORDINATE_VALUE));
+                pos -= startPos;
                 return pos;
             }
         }
diff --git a/osu.Game/Rulesets/Replays/ReplayFrame.cs b/osu.Game/Rulesets/Replays/ReplayFrame.cs
index 433be6e4b7..269de228b1 100644
--- a/osu.Game/Rulesets/Replays/ReplayFrame.cs
+++ b/osu.Game/Rulesets/Replays/ReplayFrame.cs
@@ -30,5 +30,10 @@ namespace osu.Game.Rulesets.Replays
         {
             Time = time;
         }
+
+        /// <summary>
+        /// Whether this frame is equivalent to <paramref name="other"/> with respect to replay recording.
+        /// </summary>
+        public virtual bool IsEquivalentTo(ReplayFrame other) => Time == other.Time;
     }
 }
diff --git a/osu.Game/Rulesets/Scoring/DefaultHitWindows.cs b/osu.Game/Rulesets/Scoring/DefaultHitWindows.cs
new file mode 100644
index 0000000000..3048233335
--- /dev/null
+++ b/osu.Game/Rulesets/Scoring/DefaultHitWindows.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;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Rulesets.Scoring
+{
+    /// <summary>
+    /// An example implementation of <see cref="HitWindows"/>.
+    /// Not meaningfully used, provided mostly as a reference to ruleset implementors.
+    /// </summary>
+    public class DefaultHitWindows : HitWindows
+    {
+        private static readonly DifficultyRange perfect_window_range = new DifficultyRange(22.4D, 19.4D, 13.9D);
+        private static readonly DifficultyRange great_window_range = new DifficultyRange(64, 49, 34);
+        private static readonly DifficultyRange good_window_range = new DifficultyRange(97, 82, 67);
+        private static readonly DifficultyRange ok_window_range = new DifficultyRange(127, 112, 97);
+        private static readonly DifficultyRange meh_window_range = new DifficultyRange(151, 136, 121);
+        private static readonly DifficultyRange miss_window_range = new DifficultyRange(188, 173, 158);
+
+        private double perfect;
+        private double great;
+        private double good;
+        private double ok;
+        private double meh;
+        private double miss;
+
+        public override void SetDifficulty(double difficulty)
+        {
+            perfect = IBeatmapDifficultyInfo.DifficultyRange(difficulty, perfect_window_range);
+            great = IBeatmapDifficultyInfo.DifficultyRange(difficulty, great_window_range);
+            good = IBeatmapDifficultyInfo.DifficultyRange(difficulty, good_window_range);
+            ok = IBeatmapDifficultyInfo.DifficultyRange(difficulty, ok_window_range);
+            meh = IBeatmapDifficultyInfo.DifficultyRange(difficulty, meh_window_range);
+            miss = IBeatmapDifficultyInfo.DifficultyRange(difficulty, miss_window_range);
+        }
+
+        public override double WindowFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Perfect:
+                    return perfect;
+
+                case HitResult.Great:
+                    return great;
+
+                case HitResult.Good:
+                    return good;
+
+                case HitResult.Ok:
+                    return ok;
+
+                case HitResult.Meh:
+                    return meh;
+
+                case HitResult.Miss:
+                    return miss;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(result), result, null);
+            }
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/Scoring/HitWindows.cs b/osu.Game/Rulesets/Scoring/HitWindows.cs
index 94ea51c0b2..f4d1fe1e14 100644
--- a/osu.Game/Rulesets/Scoring/HitWindows.cs
+++ b/osu.Game/Rulesets/Scoring/HitWindows.cs
@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Scoring
@@ -13,35 +12,26 @@ namespace osu.Game.Rulesets.Scoring
     /// <summary>
     /// A structure containing timing data for hit window based gameplay.
     /// </summary>
-    public class HitWindows
+    public abstract class HitWindows
     {
-        private static readonly DifficultyRange[] base_ranges =
-        {
-            new DifficultyRange(HitResult.Perfect, 22.4D, 19.4D, 13.9D),
-            new DifficultyRange(HitResult.Great, 64, 49, 34),
-            new DifficultyRange(HitResult.Good, 97, 82, 67),
-            new DifficultyRange(HitResult.Ok, 127, 112, 97),
-            new DifficultyRange(HitResult.Meh, 151, 136, 121),
-            new DifficultyRange(HitResult.Miss, 188, 173, 158),
-        };
-
-        private double perfect;
-        private double great;
-        private double good;
-        private double ok;
-        private double meh;
-        private double miss;
-
         /// <summary>
         /// An empty <see cref="HitWindows"/> with only <see cref="HitResult.Miss"/> and <see cref="HitResult.Perfect"/>.
         /// No time values are provided (meaning instantaneous hit or miss).
         /// </summary>
         public static HitWindows Empty { get; } = new EmptyHitWindows();
 
-        public HitWindows()
+        protected HitWindows()
         {
-            Debug.Assert(GetRanges().Any(r => r.Result == HitResult.Miss), $"{nameof(GetRanges)} should always contain {nameof(HitResult.Miss)}");
-            Debug.Assert(GetRanges().Any(r => r.Result != HitResult.Miss), $"{nameof(GetRanges)} should always contain at least one result type other than {nameof(HitResult.Miss)}.");
+            ensureValidHitWindows();
+        }
+
+        [Conditional("DEBUG")]
+        private void ensureValidHitWindows()
+        {
+            var availableWindows = GetAllAvailableWindows().ToList();
+            Debug.Assert(availableWindows.Any(r => r.result == HitResult.Miss), $"{nameof(GetAllAvailableWindows)} should always contain {nameof(HitResult.Miss)}");
+            Debug.Assert(availableWindows.Any(r => r.result != HitResult.Miss),
+                $"{nameof(GetAllAvailableWindows)} should always contain at least one result type other than {nameof(HitResult.Miss)}.");
         }
 
         /// <summary>
@@ -64,7 +54,7 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         public IEnumerable<(HitResult result, double length)> GetAllAvailableWindows()
         {
-            for (var result = HitResult.Meh; result <= HitResult.Perfect; ++result)
+            for (var result = HitResult.Miss; result <= HitResult.Perfect; ++result)
             {
                 if (IsHitResultAllowed(result))
                     yield return (result, WindowFor(result));
@@ -82,40 +72,7 @@ namespace osu.Game.Rulesets.Scoring
         /// Sets hit windows with values that correspond to a difficulty parameter.
         /// </summary>
         /// <param name="difficulty">The parameter.</param>
-        public void SetDifficulty(double difficulty)
-        {
-            foreach (var range in GetRanges())
-            {
-                double value = IBeatmapDifficultyInfo.DifficultyRange(difficulty, (range.Min, range.Average, range.Max));
-
-                switch (range.Result)
-                {
-                    case HitResult.Miss:
-                        miss = value;
-                        break;
-
-                    case HitResult.Meh:
-                        meh = value;
-                        break;
-
-                    case HitResult.Ok:
-                        ok = value;
-                        break;
-
-                    case HitResult.Good:
-                        good = value;
-                        break;
-
-                    case HitResult.Great:
-                        great = value;
-                        break;
-
-                    case HitResult.Perfect:
-                        perfect = value;
-                        break;
-                }
-            }
-        }
+        public abstract void SetDifficulty(double difficulty);
 
         /// <summary>
         /// Retrieves the <see cref="HitResult"/> for a time offset.
@@ -141,35 +98,7 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         /// <param name="result">The expected <see cref="HitResult"/>.</param>
         /// <returns>One half of the hit window for <paramref name="result"/>.</returns>
-        public double WindowFor(HitResult result)
-        {
-            if (!IsHitResultAllowed(result))
-                throw new ArgumentOutOfRangeException(nameof(result), result, $@"{result} is not an allowed result.");
-
-            switch (result)
-            {
-                case HitResult.Perfect:
-                    return perfect;
-
-                case HitResult.Great:
-                    return great;
-
-                case HitResult.Good:
-                    return good;
-
-                case HitResult.Ok:
-                    return ok;
-
-                case HitResult.Meh:
-                    return meh;
-
-                case HitResult.Miss:
-                    return miss;
-
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(result), result, null);
-            }
-        }
+        public abstract double WindowFor(HitResult result);
 
         /// <summary>
         /// Given a time offset, whether the <see cref="HitObject"/> can ever be hit in the future with a non-<see cref="HitResult.Miss"/> result.
@@ -179,41 +108,13 @@ namespace osu.Game.Rulesets.Scoring
         /// <returns>Whether the <see cref="HitObject"/> can be hit at any point in the future from this time offset.</returns>
         public bool CanBeHit(double timeOffset) => timeOffset <= WindowFor(LowestSuccessfulHitResult());
 
-        /// <summary>
-        /// Retrieve a valid list of <see cref="DifficultyRange"/>s representing hit windows.
-        /// Defaults are provided but can be overridden to customise for a ruleset.
-        /// </summary>
-        protected virtual DifficultyRange[] GetRanges() => base_ranges;
-
         private class EmptyHitWindows : HitWindows
         {
-            private static readonly DifficultyRange[] ranges =
-            {
-                new DifficultyRange(HitResult.Perfect, 0, 0, 0),
-                new DifficultyRange(HitResult.Miss, 0, 0, 0),
-            };
-
             public override bool IsHitResultAllowed(HitResult result) => true;
 
-            protected override DifficultyRange[] GetRanges() => ranges;
-        }
-    }
+            public override void SetDifficulty(double difficulty) { }
 
-    public struct DifficultyRange
-    {
-        public readonly HitResult Result;
-
-        public double Min;
-        public double Average;
-        public double Max;
-
-        public DifficultyRange(HitResult result, double min, double average, double max)
-        {
-            Result = result;
-
-            Min = min;
-            Average = average;
-            Max = max;
+            public override double WindowFor(HitResult result) => 0;
         }
     }
 }
diff --git a/osu.Game/Rulesets/UI/ModIcon.cs b/osu.Game/Rulesets/UI/ModIcon.cs
index d3f04e7e74..9ed4f7135f 100644
--- a/osu.Game/Rulesets/UI/ModIcon.cs
+++ b/osu.Game/Rulesets/UI/ModIcon.cs
@@ -8,7 +8,6 @@ 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.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Utils;
@@ -84,7 +83,7 @@ namespace osu.Game.Rulesets.UI
 
         private Drawable adjustmentMarker = null!;
 
-        private Circle cogBackground = null!;
+        private SpriteIcon cogBackground = null!;
         private SpriteIcon cog = null!;
 
         private ModSettingChangeTracker? modSettingsChangeTracker;
@@ -178,11 +177,12 @@ namespace osu.Game.Rulesets.UI
                             Position = new Vector2(64, 14),
                             Children = new Drawable[]
                             {
-                                cogBackground = new Circle
+                                cogBackground = new SpriteIcon
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
                                     RelativeSizeAxes = Axes.Both,
+                                    Icon = FontAwesome.Solid.Circle,
                                 },
                                 cog = new SpriteIcon
                                 {
diff --git a/osu.Game/Rulesets/UI/ReplayRecorder.cs b/osu.Game/Rulesets/UI/ReplayRecorder.cs
index c2187b0634..8829c15a21 100644
--- a/osu.Game/Rulesets/UI/ReplayRecorder.cs
+++ b/osu.Game/Rulesets/UI/ReplayRecorder.cs
@@ -86,9 +86,8 @@ namespace osu.Game.Rulesets.UI
 
             if (frame != null)
             {
-                // only keep the last recorded frame for a given timestamp.
                 // this reduces redundancy of frames in the resulting replay.
-                if (last?.Time == frame.Time)
+                if (last?.IsEquivalentTo(frame) == true)
                     target.Replay.Frames[^1] = frame;
                 else
                     target.Replay.Frames.Add(frame);
diff --git a/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs b/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
index a32c05c4eb..ec2b567a7b 100644
--- a/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
+++ b/osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs
@@ -110,6 +110,9 @@ namespace osu.Game.Scoring.Legacy
                 else if (version >= 20121008)
                     scoreInfo.LegacyOnlineID = sr.ReadInt32();
 
+                if (scoreInfo.LegacyOnlineID == 0)
+                    scoreInfo.LegacyOnlineID = -1;
+
                 byte[] compressedScoreInfo = null;
 
                 if (version >= 30000001)
@@ -283,7 +286,23 @@ namespace osu.Game.Scoring.Legacy
                 // In mania, mouseX encodes the pressed keys in the lower 20 bits
                 int mouseXParseLimit = currentRuleset.RulesetInfo.OnlineID == 3 ? (1 << 20) - 1 : Parsing.MAX_COORDINATE_VALUE;
 
-                int diff = Parsing.ParseInt(split[0]);
+                // the legacy replay format as defined by stable expects frame delta times
+                // ('delta time' here meaning the amount of time between consecutive frames)
+                // to be integral and does not allow fractional values.
+                // one particular reason why this matters is that integral deltas
+                // avoid nasty floating point traps like accumulation error from summation or round-off error.
+                // however, there was a period in lazer's lifetime wherein lazer emitted replays
+                // with fractional (float) frame deltas, up until https://github.com/ppy/osu/pull/12583.
+                // despite the fact that gameplay mechanics changed multiple times since
+                // and the replay isn't going to play back anywhere near accurately anyway,
+                // no mistakes are ever forgiven, thus this attempts to parse the delta as an integer once,
+                // and if that fails, tries again as float.
+                // notably this cannot just be `(int)Parsing.ParseFloat(split[0])`, because that can lose information
+                // (`float` numbers have 24 bits of significand precision, which is not enough to accurately represent every possible value of `int`).
+                int diff;
+                if (!int.TryParse(split[0], out diff))
+                    diff = (int)Math.Round(Parsing.ParseFloat(split[0]));
+
                 float mouseX = Parsing.ParseFloat(split[1], mouseXParseLimit);
                 float mouseY = Parsing.ParseFloat(split[2], Parsing.MAX_COORDINATE_VALUE);
 
diff --git a/osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs b/osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs
index 23624401e2..664f1fd4ab 100644
--- a/osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs
+++ b/osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Scoring.Legacy
@@ -20,6 +21,9 @@ namespace osu.Game.Scoring.Legacy
         public static long GetDisplayScore(this SoloScoreInfo soloScoreInfo, ScoringMode mode)
             => getDisplayScore(soloScoreInfo.RulesetID, soloScoreInfo.TotalScore, mode, soloScoreInfo.MaximumStatistics);
 
+        public static long GetDisplayScore(this MultiplayerScore multiplayerScore, ScoringMode mode)
+            => getDisplayScore(multiplayerScore.RulesetId, multiplayerScore.TotalScore, mode, multiplayerScore.MaximumStatistics);
+
         private static long getDisplayScore(int rulesetId, long score, ScoringMode mode, IReadOnlyDictionary<HitResult, int> maximumStatistics)
         {
             if (mode == ScoringMode.Standardised)
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs
index ee44df8598..e856009817 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.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.Graphics;
 using osu.Framework.Graphics.Cursor;
@@ -91,7 +92,8 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
                     section = value;
 
                     X = (float)value.StartTime;
-                    Width = (float)value.Duration;
+                    // Minimum width ensures that very short kiai sections still show a slither of colour.
+                    Width = (float)Math.Max(200, value.Duration);
                 }
             }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
index 5386b39190..da145f0994 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
@@ -373,10 +373,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
+            private void load(OsuColour colours, OverlayColourProvider colourProvider)
             {
-                IconColour = Color4.Black;
-                HoverColour = colours.Gray7;
+                IconColour = colourProvider.Light3;
+                IconHoverColour = Color4.White;
+                HoverColour = colours.Gray6;
                 FlashColour = colours.Gray9;
             }
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
index b49dee279e..d4c70d53df 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
@@ -166,6 +166,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         protected override void OnMouseUp(MouseUpEvent e)
         {
+            // When an object is being dragged, ONLY a left MouseUpEvent should end the drag and finalize the changes caused by the drag.
+            // Otherwise, other mouse inputs while a drag is occurring will cause change transactions to lock up.
+            if (e.Button != MouseButton.Left)
+                return;
+
             // Special case for when a drag happened instead of a click
             Schedule(() =>
             {
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
index af3b3d6489..6cd2428b8a 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
@@ -30,6 +30,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Implementation-defined origin point to rotate around when no explicit origin is provided.
         /// This field is only assigned during a rotation operation.
+        ///
+        /// Coordinates are in local space for this container.
         /// </summary>
         public Vector2? DefaultOrigin { get; protected set; }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
index 66d0df9e18..faefdee096 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -31,9 +32,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         [Resolved]
         private BindableBeatDivisor beatDivisor { get; set; } = null!;
 
-        [Resolved]
-        private IEditorChangeHandler? changeHandler { get; set; }
-
         [Resolved]
         private OsuColour colours { get; set; } = null!;
 
@@ -51,9 +49,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             beatDivisor.BindValueChanged(_ => invalidateTicks());
 
-            if (changeHandler != null)
-                // currently this is the best way to handle any kind of timing changes.
-                changeHandler.OnStateChange += invalidateTicks;
+            beatmap.ControlPointInfo.ControlPointsChanged += invalidateTicks;
 
             configManager.BindWith(OsuSetting.EditorTimelineShowTimingChanges, showTimingChanges);
             showTimingChanges.BindValueChanged(_ => invalidateTicks());
@@ -194,8 +190,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             base.Dispose(isDisposing);
 
-            if (changeHandler != null)
-                changeHandler.OnStateChange -= invalidateTicks;
+            if (beatmap.IsNotNull())
+                beatmap.ControlPointInfo.ControlPointsChanged -= invalidateTicks;
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/ExternalEditScreen.cs b/osu.Game/Screens/Edit/ExternalEditScreen.cs
index 8a97e3dcb2..e906d74855 100644
--- a/osu.Game/Screens/Edit/ExternalEditScreen.cs
+++ b/osu.Game/Screens/Edit/ExternalEditScreen.cs
@@ -21,6 +21,7 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Match.Components;
@@ -156,7 +157,7 @@ namespace osu.Game.Screens.Edit
                 },
                 new DangerousRoundedButton
                 {
-                    Text = "Finish editing and import changes",
+                    Text = EditorStrings.FinishEditingExternally,
                     Width = 350,
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
diff --git a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
index 820b31c032..02eb38ffa6 100644
--- a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
+++ b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.Edit.GameplayTest
@@ -32,6 +33,9 @@ namespace osu.Game.Screens.Edit.GameplayTest
         [Resolved]
         private MusicController musicController { get; set; } = null!;
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private EmptyGameplayLeaderboardProvider leaderboardProvider = new EmptyGameplayLeaderboardProvider();
+
         public EditorPlayer(Editor editor)
             : base(new PlayerConfiguration { ShowResults = false })
         {
diff --git a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
index 3a9eb2c1b0..03ab23d8e4 100644
--- a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
+++ b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
@@ -191,6 +191,13 @@ namespace osu.Game.Screens.Edit.Submission
             });
 
             completedSample = audio.Samples.Get(@"UI/bss-complete");
+
+            if (Beatmap.Value.BeatmapSetInfo.OnlineID > 0)
+            {
+                var req = new GetBeatmapSetRequest(Beatmap.Value.BeatmapSetInfo.OnlineID);
+                api.Queue(req);
+                settings.LatestOnlineStateRequest = req;
+            }
         }
 
         private void createBeatmapSet()
diff --git a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionSettings.cs b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionSettings.cs
index 8cccc339a6..a1f3861d29 100644
--- a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionSettings.cs
+++ b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionSettings.cs
@@ -8,6 +8,8 @@ namespace osu.Game.Screens.Edit.Submission
 {
     public class BeatmapSubmissionSettings
     {
+        public GetBeatmapSetRequest? LatestOnlineStateRequest { get; set; }
+
         public Bindable<BeatmapSubmissionTarget> Target { get; } = new Bindable<BeatmapSubmissionTarget>();
 
         public Bindable<bool> NotifyOnDiscussionReplies { get; } = new Bindable<bool>();
diff --git a/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs b/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
index 969105b5c6..7b80fdee7d 100644
--- a/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
+++ b/osu.Game/Screens/Edit/Submission/ScreenSubmissionSettings.cs
@@ -1,16 +1,19 @@
 // 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.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
+using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Overlays;
 using osuTK;
@@ -25,8 +28,11 @@ namespace osu.Game.Screens.Edit.Submission
 
         public override LocalisableString? NextStepText => BeatmapSubmissionStrings.ConfirmSubmission;
 
+        [Resolved]
+        private BeatmapSubmissionSettings settings { get; set; } = null!;
+
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager configManager, OsuColour colours, BeatmapSubmissionSettings settings)
+        private void load(OsuConfigManager configManager, OsuColour colours)
         {
             configManager.BindWith(OsuSetting.EditorSubmissionNotifyOnDiscussionReplies, settings.NotifyOnDiscussionReplies);
             configManager.BindWith(OsuSetting.EditorSubmissionLoadInBrowserAfterSubmission, loadInBrowserAfterSubmission);
@@ -63,6 +69,25 @@ namespace osu.Game.Screens.Edit.Submission
                     },
                 }
             });
+
+            switch (settings.LatestOnlineStateRequest?.CompletionState)
+            {
+                case APIRequestCompletionState.Completed:
+                    setSubmissionTargetFromLatestOnlineState();
+                    break;
+
+                case APIRequestCompletionState.Waiting:
+                    settings.Target.Disabled = true;
+                    settings.LatestOnlineStateRequest.Success += _ => setSubmissionTargetFromLatestOnlineState();
+                    break;
+            }
+        }
+
+        private void setSubmissionTargetFromLatestOnlineState()
+        {
+            Debug.Assert(settings.LatestOnlineStateRequest != null);
+            settings.Target.Disabled = false;
+            settings.Target.Value = settings.LatestOnlineStateRequest.Response?.Status >= BeatmapOnlineStatus.Pending ? BeatmapSubmissionTarget.Pending : BeatmapSubmissionTarget.WIP;
         }
     }
 }
diff --git a/osu.Game/Screens/Footer/ScreenBackButton.cs b/osu.Game/Screens/Footer/ScreenBackButton.cs
index bf29186bb1..481192088c 100644
--- a/osu.Game/Screens/Footer/ScreenBackButton.cs
+++ b/osu.Game/Screens/Footer/ScreenBackButton.cs
@@ -19,6 +19,19 @@ namespace osu.Game.Screens.Footer
     {
         public const float BUTTON_WIDTH = 240;
 
+        public sealed override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
+        {
+            // Ensure clicks in the corner of the screen still trigger the back button.
+            // Need to apply more than 1x inflation due to shear.
+            var inputRectangle = DrawRectangle.Inflate(new MarginPadding
+            {
+                Left = OsuGame.SCREEN_EDGE_MARGIN * 2,
+                Bottom = OsuGame.SCREEN_EDGE_MARGIN * 2,
+            });
+
+            return inputRectangle.Contains(ToLocalSpace(screenSpacePos));
+        }
+
         public ScreenBackButton()
             : base(BUTTON_WIDTH)
         {
diff --git a/osu.Game/Screens/Footer/ScreenFooter.cs b/osu.Game/Screens/Footer/ScreenFooter.cs
index 1baa4ae0ef..6d7a32d57a 100644
--- a/osu.Game/Screens/Footer/ScreenFooter.cs
+++ b/osu.Game/Screens/Footer/ScreenFooter.cs
@@ -40,7 +40,11 @@ namespace osu.Game.Screens.Footer
 
         private const int padding = 60;
         private const float delay_per_button = 30;
-        private const double transition_duration = 400;
+        private const double transition_duration = 500;
+
+        // Disable masking because it breaks due to the height of this container being less than the displayed content.
+        // The height being set as it is is required for transition purposes.
+        public override bool UpdateSubTreeMasking() => false;
 
         private readonly List<OverlayContainer> overlays = new List<OverlayContainer>();
 
@@ -48,7 +52,9 @@ namespace osu.Game.Screens.Footer
         private FillFlowContainer<ScreenFooterButton> buttonsFlow = null!;
         private Container footerContentContainer = null!;
         private Container<ScreenFooterButton> hiddenButtonsContainer = null!;
+
         private LogoTrackingContainer logoTrackingContainer = null!;
+        private IDisposable? logoTracking;
 
         // TODO: This has some weird update logic local in this class, but it only works for overlay containers.
         // This is not what we want. The footer is to be displayed on *screens* with different colour schemes.
@@ -98,7 +104,7 @@ namespace osu.Game.Screens.Footer
                             {
                                 Anchor = Anchor.BottomLeft,
                                 Origin = Anchor.BottomLeft,
-                                Y = ScreenFooterButton.Y_OFFSET,
+                                Y = ScreenFooterButton.CORNER_RADIUS,
                                 Direction = FillDirection.Horizontal,
                                 Spacing = new Vector2(7, 0),
                                 AutoSizeAxes = Axes.Both,
@@ -121,7 +127,7 @@ namespace osu.Game.Screens.Footer
                 hiddenButtonsContainer = new Container<ScreenFooterButton>
                 {
                     Margin = new MarginPadding { Left = OsuGame.SCREEN_EDGE_MARGIN + ScreenBackButton.BUTTON_WIDTH + padding },
-                    Y = ScreenFooterButton.Y_OFFSET,
+                    Y = ScreenFooterButton.CORNER_RADIUS,
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
                     AutoSizeAxes = Axes.Both,
@@ -145,13 +151,14 @@ namespace osu.Game.Screens.Footer
             changeLogoDepthDelegate?.Cancel();
             changeLogoDepthDelegate = null;
 
-            logoTrackingContainer.StartTracking(logo, duration, easing);
+            logoTracking = logoTrackingContainer.StartTracking(logo, duration, easing);
             RequestLogoInFront?.Invoke(true);
         }
 
         public void StopTrackingLogo()
         {
-            logoTrackingContainer.StopTracking();
+            logoTracking?.Dispose();
+            logoTracking = null;
 
             changeLogoDepthDelegate = Scheduler.AddDelayed(() => RequestLogoInFront?.Invoke(false), transition_duration);
         }
@@ -159,13 +166,14 @@ namespace osu.Game.Screens.Footer
         protected override void PopIn()
         {
             this.MoveToY(0, transition_duration, Easing.OutQuint)
-                .FadeIn(transition_duration, Easing.OutQuint);
+                .FadeIn();
         }
 
         protected override void PopOut()
         {
-            this.MoveToY(HEIGHT, transition_duration, Easing.OutQuint)
-                .FadeOut(transition_duration, Easing.OutQuint);
+            this.MoveToY(ScreenFooterButton.HEIGHT, transition_duration, Easing.OutQuint)
+                .Then()
+                .FadeOut();
         }
 
         public void SetButtons(IReadOnlyList<ScreenFooterButton> buttons)
@@ -218,20 +226,21 @@ namespace osu.Game.Screens.Footer
             }
         }
 
-        private ShearedOverlayContainer? activeOverlay;
+        public ShearedOverlayContainer? ActiveOverlay { get; private set; }
+
         private VisibilityContainer? activeFooterContent;
 
         private readonly List<ScreenFooterButton> temporarilyHiddenButtons = new List<ScreenFooterButton>();
 
         public IDisposable RegisterActiveOverlayContainer(ShearedOverlayContainer overlay, out VisibilityContainer? footerContent)
         {
-            if (activeOverlay != null)
+            if (ActiveOverlay != null)
             {
                 throw new InvalidOperationException(@"Cannot set overlay content while one is already present. " +
-                                                    $@"The previous overlay ({activeOverlay.GetType().Name}) should be hidden first.");
+                                                    $@"The previous overlay ({ActiveOverlay.GetType().Name}) should be hidden first.");
             }
 
-            activeOverlay = overlay;
+            ActiveOverlay = overlay;
 
             Debug.Assert(temporarilyHiddenButtons.Count == 0);
 
@@ -269,7 +278,7 @@ namespace osu.Game.Screens.Footer
 
         private void clearActiveOverlayContainer()
         {
-            if (activeOverlay == null)
+            if (ActiveOverlay == null)
                 return;
 
             Debug.Assert(activeFooterContent != null);
@@ -292,7 +301,7 @@ namespace osu.Game.Screens.Footer
 
             activeFooterContent.Delay(timeUntilRun).Expire();
             activeFooterContent = null;
-            activeOverlay = null;
+            ActiveOverlay = null;
         }
 
         private void updateColourScheme(int hue)
@@ -329,12 +338,12 @@ namespace osu.Game.Screens.Footer
 
         private void onBackPressed()
         {
-            if (activeOverlay != null)
+            if (ActiveOverlay != null)
             {
-                if (activeOverlay.OnBackButton())
+                if (ActiveOverlay.OnBackButton())
                     return;
 
-                activeOverlay.Hide();
+                ActiveOverlay.Hide();
                 return;
             }
 
diff --git a/osu.Game/Screens/Footer/ScreenFooterButton.cs b/osu.Game/Screens/Footer/ScreenFooterButton.cs
index d0532273bc..5d064670e7 100644
--- a/osu.Game/Screens/Footer/ScreenFooterButton.cs
+++ b/osu.Game/Screens/Footer/ScreenFooterButton.cs
@@ -25,9 +25,9 @@ namespace osu.Game.Screens.Footer
 {
     public partial class ScreenFooterButton : OsuClickableContainer, IKeyBindingHandler<GlobalAction>
     {
-        public const int Y_OFFSET = 10;
+        public const int CORNER_RADIUS = 10;
 
-        protected const int BUTTON_HEIGHT = 75;
+        public const int HEIGHT = 75;
         protected const int BUTTON_WIDTH = 116;
 
         public Bindable<Visibility> OverlayState = new Bindable<Visibility>();
@@ -58,6 +58,8 @@ namespace osu.Game.Screens.Footer
             set => text.Text = value;
         }
 
+        private readonly Container shearedContent;
+
         private readonly SpriteText text;
         private readonly SpriteIcon icon;
 
@@ -73,11 +75,11 @@ namespace osu.Game.Screens.Footer
         {
             Overlay = overlay;
 
-            Size = new Vector2(BUTTON_WIDTH, BUTTON_HEIGHT);
+            Size = new Vector2(BUTTON_WIDTH, HEIGHT);
 
             Children = new Drawable[]
             {
-                new Container
+                shearedContent = new Container
                 {
                     EdgeEffect = new EdgeEffectParameters
                     {
@@ -89,7 +91,7 @@ namespace osu.Game.Screens.Footer
                     },
                     Shear = OsuGame.SHEAR,
                     Masking = true,
-                    CornerRadius = 10,
+                    CornerRadius = CORNER_RADIUS,
                     RelativeSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
@@ -136,7 +138,7 @@ namespace osu.Game.Screens.Footer
                             Shear = -OsuGame.SHEAR,
                             Anchor = Anchor.BottomCentre,
                             Origin = Anchor.Centre,
-                            Y = -Y_OFFSET,
+                            Y = -CORNER_RADIUS,
                             Size = new Vector2(100, 5),
                             Masking = true,
                             CornerRadius = 3,
@@ -170,8 +172,8 @@ namespace osu.Game.Screens.Footer
             FinishTransforms(true);
         }
 
-        // use Content for tracking input as some buttons might be temporarily hidden with DisappearToBottom, and they become hidden by moving Content away from screen.
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Content.ReceivePositionalInputAt(screenSpacePos);
+        // account for shear and buttons temporarily hidden with DisappearToBottom.
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => shearedContent.ReceivePositionalInputAt(screenSpacePos);
 
         public GlobalAction? Hotkey;
 
diff --git a/osu.Game/Screens/Menu/ButtonSystem.cs b/osu.Game/Screens/Menu/ButtonSystem.cs
index 25fa689d4c..073a0d4021 100644
--- a/osu.Game/Screens/Menu/ButtonSystem.cs
+++ b/osu.Game/Screens/Menu/ButtonSystem.cs
@@ -73,7 +73,8 @@ namespace osu.Game.Screens.Menu
             else
             {
                 // We should stop tracking as the facade is now out of scope.
-                logoTrackingContainer.StopTracking();
+                logoTracking?.Dispose();
+                logoTracking = null;
             }
         }
 
@@ -390,6 +391,7 @@ namespace osu.Game.Screens.Menu
         }
 
         private ScheduledDelegate? logoDelayedAction;
+        private IDisposable? logoTracking;
 
         private void updateLogoState(ButtonSystemState lastState = ButtonSystemState.Initial)
         {
@@ -402,7 +404,8 @@ namespace osu.Game.Screens.Menu
                     logoDelayedAction?.Cancel();
                     logoDelayedAction = Scheduler.AddDelayed(() =>
                     {
-                        logoTrackingContainer.StopTracking();
+                        logoTracking?.Dispose();
+                        logoTracking = null;
 
                         game?.Toolbar.Hide();
 
@@ -429,7 +432,8 @@ namespace osu.Game.Screens.Menu
 
                             logo.ScaleTo(0.5f, 200, Easing.In);
 
-                            logoTrackingContainer.StartTracking(logo, 200, Easing.In);
+                            logoTracking?.Dispose();
+                            logoTracking = logoTrackingContainer.StartTracking(logo, 200, Easing.In);
 
                             logoDelayedAction?.Cancel();
                             logoDelayedAction = Scheduler.AddDelayed(() =>
@@ -443,7 +447,10 @@ namespace osu.Game.Screens.Menu
 
                         default:
                             logo.ClearTransforms(targetMember: nameof(Position));
-                            logoTrackingContainer.StartTracking(logo, 0, Easing.In);
+
+                            logoTracking?.Dispose();
+                            logoTracking = logoTrackingContainer.StartTracking(logo, 0, Easing.In);
+
                             logo.ScaleTo(0.5f, 200, Easing.OutQuint);
                             break;
                     }
@@ -451,7 +458,8 @@ namespace osu.Game.Screens.Menu
                     break;
 
                 case ButtonSystemState.EnteringMode:
-                    logoTrackingContainer.StartTracking(logo, lastState == ButtonSystemState.Initial ? MainMenu.FADE_OUT_DURATION : 0, Easing.InSine);
+                    logoTracking?.Dispose();
+                    logoTracking = logoTrackingContainer.StartTracking(logo, lastState == ButtonSystemState.Initial ? MainMenu.FADE_OUT_DURATION : 0, Easing.InSine);
                     break;
             }
         }
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index 2d7981113b..bc3bcbd800 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -27,6 +27,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using osu.Game.IO;
+using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
@@ -38,12 +39,10 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.OnlinePlay.DailyChallenge;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Playlists;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Seasonal;
 using osuTK;
 using osuTK.Graphics;
-using osu.Game.Localisation;
-using osu.Game.Screens.SelectV2;
 
 namespace osu.Game.Screens.Menu
 {
@@ -116,6 +115,9 @@ namespace osu.Game.Screens.Menu
         [Resolved(canBeNull: true)]
         private SkinEditorOverlay skinEditor { get; set; }
 
+        [CanBeNull]
+        private IDisposable logoProxy;
+
         [BackgroundDependencyLoader(true)]
         private void load(BeatmapListingOverlay beatmapListing, SettingsOverlay settings, OsuConfigManager config, SessionStatics statics, AudioManager audio)
         {
@@ -155,7 +157,7 @@ namespace osu.Game.Screens.Menu
                             {
                                 skinEditor?.Show();
                             },
-                            OnSolo = loadSoloSongSelect,
+                            OnSolo = loadSongSelect,
                             OnMultiplayer = () => this.Push(new Multiplayer()),
                             OnPlaylists = () => this.Push(new Playlists()),
                             OnDailyChallenge = room =>
@@ -238,16 +240,14 @@ namespace osu.Game.Screens.Menu
             reappearSampleSwoosh = audio.Samples.Get(@"Menu/reappear-swoosh");
         }
 
-        public void ReturnToOsuLogo() => Buttons.State = ButtonSystemState.Initial;
-
-        private void loadSoloSongSelect()
+        protected override void LoadComplete()
         {
-            if (GetContainingInputManager()!.CurrentState.Keyboard.ControlPressed)
-                this.Push(new SoloSongSelect());
-            else
-                this.Push(new PlaySongSelect());
+            base.LoadComplete();
+            GetContainingInputManager();
         }
 
+        public void ReturnToOsuLogo() => Buttons.State = ButtonSystemState.Initial;
+
         public override void OnEntering(ScreenTransitionEvent e)
         {
             base.OnEntering(e);
@@ -281,7 +281,7 @@ namespace osu.Game.Screens.Menu
             logo.FadeColour(Color4.White, 100, Easing.OutQuint);
             logo.FadeIn(100, Easing.OutQuint);
 
-            logo.ProxyToContainer(logoTarget);
+            logoProxy = logo.ProxyToContainer(logoTarget);
 
             if (resuming)
             {
@@ -340,7 +340,8 @@ namespace osu.Game.Screens.Menu
             var seq = logo.FadeOut(300, Easing.InSine)
                           .ScaleTo(0.2f, 300, Easing.InSine);
 
-            logo.ReturnProxy();
+            logoProxy?.Dispose();
+            logoProxy = null;
 
             seq.OnComplete(_ => Buttons.SetOsuLogo(null));
             seq.OnAbort(_ => Buttons.SetOsuLogo(null));
@@ -350,7 +351,8 @@ namespace osu.Game.Screens.Menu
         {
             base.LogoExiting(logo);
 
-            logo.ReturnProxy();
+            logoProxy?.Dispose();
+            logoProxy = null;
         }
 
         public override void OnSuspending(ScreenTransitionEvent e)
@@ -453,7 +455,7 @@ namespace osu.Game.Screens.Menu
             Beatmap.Value = beatmap;
             Ruleset.Value = ruleset;
 
-            Schedule(loadSoloSongSelect);
+            Schedule(loadSongSelect);
         }
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
@@ -477,6 +479,8 @@ namespace osu.Game.Screens.Menu
         {
         }
 
+        private void loadSongSelect() => this.Push(new SoloSongSelect());
+
         private partial class MobileDisclaimerDialog : PopupDialog
         {
             public MobileDisclaimerDialog(Action confirmed)
diff --git a/osu.Game/Screens/Menu/MainMenuButton.cs b/osu.Game/Screens/Menu/MainMenuButton.cs
index f8824795d8..235babeed2 100644
--- a/osu.Game/Screens/Menu/MainMenuButton.cs
+++ b/osu.Game/Screens/Menu/MainMenuButton.cs
@@ -20,6 +20,7 @@ using osu.Game.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
+using osu.Framework.Input.StateChanges;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps.ControlPoints;
 
@@ -257,6 +258,15 @@ namespace osu.Game.Screens.Menu
 
         protected override void OnMouseUp(MouseUpEvent e)
         {
+            // HORRIBLE HACK
+            // This is here so that on mobile, the main menu button that progresses to song select can correctly progress to song select v2 when held.
+            // Once the temporary solution of holding the button to access song select v2 is removed, this should be too.
+            // Without this, the long-press-to-right-click flow intercepts the hold and converts it to a right click which would not trigger the button
+            // and therefore not progress to song select.
+            if (e.Button == MouseButton.Right && e.CurrentState.Mouse.LastSource is ISourcedFromTouch)
+                trigger(e);
+            // END OF HORRIBLE HACK
+
             boxHoverLayer.FadeTo(0, 1000, Easing.OutQuint);
             base.OnMouseUp(e);
         }
diff --git a/osu.Game/Screens/Menu/MenuTipDisplay.cs b/osu.Game/Screens/Menu/MenuTipDisplay.cs
index 283528d22a..9430d65433 100644
--- a/osu.Game/Screens/Menu/MenuTipDisplay.cs
+++ b/osu.Game/Screens/Menu/MenuTipDisplay.cs
@@ -128,7 +128,8 @@ namespace osu.Game.Screens.Menu
                 MenuTipStrings.ToggleReplaySettingsShortcut,
                 MenuTipStrings.CopyModsFromScore,
                 MenuTipStrings.AutoplayBeatmapShortcut,
-                MenuTipStrings.LazerIsNotAWord
+                MenuTipStrings.LazerIsNotAWord,
+                MenuTipStrings.RightMouseAbsoluteScroll,
             };
 
             return tips[RNG.Next(0, tips.Length)];
diff --git a/osu.Game/Screens/Menu/OsuLogo.cs b/osu.Game/Screens/Menu/OsuLogo.cs
index 31f47c1349..1b3317b12d 100644
--- a/osu.Game/Screens/Menu/OsuLogo.cs
+++ b/osu.Game/Screens/Menu/OsuLogo.cs
@@ -4,6 +4,7 @@
 #nullable disable
 
 using System;
+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -16,6 +17,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Events;
+using osu.Framework.Input.StateChanges;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.Backgrounds;
@@ -391,12 +393,27 @@ namespace osu.Game.Screens.Menu
 
         protected override void OnMouseUp(MouseUpEvent e)
         {
+            // HORRIBLE HACK
+            // This is here so that on mobile, the logo can correctly progress from main menu to song select v2 when held.
+            // Once the temporary solution of holding the logo to access song select v2 is removed, this should be too.
+            // Without this, the long-press-to-right-click flow intercepts the hold and converts it to a right click which would not trigger the logo
+            // and therefore not progress to song select.
+            if (e.Button == MouseButton.Right && e.CurrentState.Mouse.LastSource is ISourcedFromTouch)
+                triggerClick();
+            // END OF HORRIBLE HACK
+
             if (e.Button != MouseButton.Left) return;
 
             logoBounceContainer.ScaleTo(1f, 500, Easing.OutElastic);
         }
 
         protected override bool OnClick(ClickEvent e)
+        {
+            triggerClick();
+            return true;
+        }
+
+        private void triggerClick()
         {
             flashLayer.ClearTransforms();
             flashLayer.Alpha = 0.4f;
@@ -408,8 +425,6 @@ namespace osu.Game.Screens.Menu
                 sampleClickChannel = sampleClick.GetChannel();
                 sampleClickChannel.Play();
             }
-
-            return true;
         }
 
         protected override bool OnHover(HoverEvent e)
@@ -458,7 +473,7 @@ namespace osu.Game.Screens.Menu
 
         public void StopSamplePlayback() => sampleClickChannel?.Stop();
 
-        public Drawable ProxyToContainer(Container c)
+        public IDisposable ProxyToContainer(Container c)
         {
             if (currentProxyTarget != null)
                 throw new InvalidOperationException("Previous proxy usage was not returned");
@@ -470,21 +485,19 @@ namespace osu.Game.Screens.Menu
 
             defaultProxyTarget.Remove(proxy, false);
             currentProxyTarget.Add(proxy);
-            return proxy;
-        }
 
-        public void ReturnProxy()
-        {
-            if (currentProxyTarget == null)
-                throw new InvalidOperationException("No usage to return");
+            return new InvokeOnDisposal(returnProxy);
 
-            if (defaultProxyTarget == null)
-                throw new InvalidOperationException($"{nameof(SetupDefaultContainer)} must be called first");
+            void returnProxy()
+            {
+                Debug.Assert(currentProxyTarget != null);
+                Debug.Assert(defaultProxyTarget != null);
 
-            currentProxyTarget.Remove(proxy, false);
-            currentProxyTarget = null;
+                currentProxyTarget.Remove(proxy, false);
+                currentProxyTarget = null;
 
-            defaultProxyTarget.Add(proxy);
+                defaultProxyTarget.Add(proxy);
+            }
         }
 
         public void SetupDefaultContainer(Container container)
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
index 401053599e..8fcb09723e 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
@@ -158,13 +158,23 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                 }
                 else
                 {
-                    LoadComponentsAsync(best.Select((s, index) => new BeatmapLeaderboardScore(s, sheared: false)
+                    LoadComponentsAsync(best.Select((s, index) =>
                     {
-                        Rank = index + 1,
-                        IsPersonalBest = s.UserID == api.LocalUser.Value.Id,
-                        Action = () => PresentScore?.Invoke(s.OnlineID),
-                        SelectedMods = { BindTarget = SelectedMods },
-                        IsValidMod = IsValidMod,
+                        BeatmapLeaderboardScore.HighlightType? highlightType = null;
+
+                        if (s.UserID == api.LocalUser.Value.Id)
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Own;
+                        else if (api.Friends.Any(r => r.TargetID == s.UserID))
+                            highlightType = BeatmapLeaderboardScore.HighlightType.Friend;
+
+                        return new BeatmapLeaderboardScore(s, sheared: false)
+                        {
+                            Rank = index + 1,
+                            Highlight = highlightType,
+                            Action = () => PresentScore?.Invoke(s.OnlineID),
+                            SelectedMods = { BindTarget = SelectedMods },
+                            IsValidMod = IsValidMod,
+                        };
                     }), loaded =>
                     {
                         scoreFlow.Clear();
@@ -181,7 +191,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                     userBestContainer.Add(new BeatmapLeaderboardScore(userBest, sheared: false)
                     {
                         Rank = userBest.Position,
-                        IsPersonalBest = true,
+                        Highlight = BeatmapLeaderboardScore.HighlightType.Own,
                         Action = () => PresentScore?.Invoke(userBest.OnlineID),
                         SelectedMods = { BindTarget = SelectedMods },
                         IsValidMod = IsValidMod,
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengePlayer.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengePlayer.cs
index a5c61b8386..8097ce8b65 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengePlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengePlayer.cs
@@ -3,7 +3,6 @@
 
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay.Playlists;
-using osu.Game.Screens.Play;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.OnlinePlay.DailyChallenge
@@ -12,8 +11,8 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
     {
         protected override UserActivity InitialActivity => new UserActivity.PlayingDailyChallenge(Beatmap.Value.BeatmapInfo, Ruleset.Value);
 
-        public DailyChallengePlayer(Room room, PlaylistItem playlistItem, PlayerConfiguration? configuration = null)
-            : base(room, playlistItem, configuration)
+        public DailyChallengePlayer(Room room, PlaylistItem playlistItem)
+            : base(room, playlistItem)
         {
         }
     }
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
index acbf5d8462..3610995b2c 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
@@ -17,6 +17,7 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Database;
@@ -54,11 +55,13 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         protected readonly Bindable<PlaylistItem?> SelectedItem = new Bindable<PlaylistItem?>();
         protected Container ButtonsContainer { get; private set; } = null!;
 
+        protected bool ShowExternalLink { get; init; } = true;
+
         private DrawableRoomParticipantsList? drawableRoomParticipantsList;
         private RoomSpecialCategoryPill? specialCategoryPill;
         private PasswordProtectedIcon? passwordIcon;
         private EndDateInfo? endDateInfo;
-        private SpriteText? roomName;
+        private RoomNameLine? roomName;
         private DelayedLoadWrapper wrapper = null!;
         private CancellationTokenSource? beatmapLookupCancellation;
 
@@ -204,11 +207,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                                                 Direction = FillDirection.Vertical,
                                                                 Children = new Drawable[]
                                                                 {
-                                                                    roomName = new TruncatingSpriteText
-                                                                    {
-                                                                        RelativeSizeAxes = Axes.X,
-                                                                        Font = OsuFont.GetFont(size: 28)
-                                                                    },
+                                                                    roomName = new RoomNameLine(),
                                                                     new RoomStatusText(Room)
                                                                     {
                                                                         Beatmap = { BindTarget = currentBeatmap }
@@ -279,6 +278,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
                 wrapper.FadeInFromZero(200);
 
+                updateRoomID();
                 updateRoomName();
                 updateRoomCategory();
                 updateRoomType();
@@ -292,6 +292,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         {
             switch (e.PropertyName)
             {
+                case nameof(Room.RoomID):
+                    updateRoomID();
+                    break;
+
                 case nameof(Room.Name):
                     updateRoomName();
                     break;
@@ -335,6 +339,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                               }), cancellationSource.Token);
         }
 
+        private void updateRoomID()
+        {
+            if (roomName != null && ShowExternalLink)
+                roomName.Link = Room.GetOnlineURL(api);
+        }
+
         private void updateRoomName()
         {
             if (roomName != null)
@@ -381,17 +391,17 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             {
                 var items = new List<MenuItem>();
 
-                if (Room.RoomID.HasValue)
+                string? url = Room.GetOnlineURL(api);
+
+                if (url != null)
                 {
                     items.AddRange([
-                        new OsuMenuItem("View in browser", MenuItemType.Standard, () => game?.OpenUrlExternally(formatRoomUrl(Room.RoomID.Value))),
-                        new OsuMenuItem("Copy link", MenuItemType.Standard, () => game?.CopyToClipboard(formatRoomUrl(Room.RoomID.Value)))
+                        new OsuMenuItem("View in browser", MenuItemType.Standard, () => game?.OpenUrlExternally(url)),
+                        new OsuMenuItem("Copy link", MenuItemType.Standard, () => game?.CopyToClipboard(url))
                     ]);
                 }
 
                 return items.ToArray();
-
-                string formatRoomUrl(long id) => $@"{api.Endpoints.WebsiteUrl}/multiplayer/rooms/{id}";
             }
         }
 
@@ -556,5 +566,70 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 };
             }
         }
+
+        public partial class RoomNameLine : FillFlowContainer
+        {
+            private readonly TruncatingSpriteText spriteText;
+            private readonly ExternalLinkButton linkButton;
+
+            public LocalisableString Text
+            {
+                get => spriteText.Text;
+                set => spriteText.Text = value;
+            }
+
+            private string? link;
+
+            public string? Link
+            {
+                get => link;
+                set
+                {
+                    link = value;
+                    updateLink();
+                }
+            }
+
+            public RoomNameLine()
+            {
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+                Direction = FillDirection.Horizontal;
+
+                Children = new Drawable[]
+                {
+                    spriteText = new TruncatingSpriteText
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        Font = OsuFont.GetFont(size: 28),
+                    },
+                    linkButton = new ExternalLinkButton
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        Margin = new MarginPadding { Horizontal = 6, Bottom = 4 },
+                        Alpha = 0f,
+                    },
+                };
+            }
+
+            private void updateLink()
+            {
+                if (link == null)
+                    linkButton.Hide();
+                else
+                {
+                    linkButton.Show();
+                    linkButton.Link = link;
+                }
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+                spriteText.MaxWidth = DrawWidth - linkButton.LayoutSize.X;
+            }
+        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
index 3ff27a14bb..12b38a9677 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
@@ -67,6 +67,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         public LoungeRoomPanel(Room room)
             : base(room)
         {
+            ShowExternalLink = false;
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
index 13abe7bb14..3f207f6fa1 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
@@ -111,10 +111,10 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 
         private CancellationTokenSource? downloadCheckCancellation;
 
+        private int? lastDownloadCheckedBeatmapId;
+
         private void checkForAutomaticDownload()
         {
-            downloadCheckCancellation?.Cancel();
-
             if (client.Room == null)
                 return;
 
@@ -132,6 +132,17 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 
             MultiplayerPlaylistItem item = client.Room.CurrentPlaylistItem;
 
+            // This method is called every time anything changes in the room.
+            // This could result in download requests firing far too often, when we only expect them to fire once per beatmap.
+            //
+            // Without this check, we would see especially egregious behaviour when a user has hit the download rate limit.
+            if (lastDownloadCheckedBeatmapId == item.BeatmapID)
+                return;
+
+            lastDownloadCheckedBeatmapId = item.BeatmapID;
+
+            downloadCheckCancellation?.Cancel();
+
             // In a perfect world we'd use BeatmapAvailability, but there's no event-driven flow for when a selection changes.
             // ie. if selection changes from "not downloaded" to another "not downloaded" we wouldn't get a value changed raised.
             beatmapLookupCache
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantPanel.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantPanel.cs
index e55f8de61b..19868082fa 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantPanel.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantPanel.cs
@@ -62,6 +62,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
 
         private UserCoverBackground userCover = null!;
         private UpdateableAvatar userAvatar = null!;
+        private UpdateableFlag userFlag = null!;
         private OsuSpriteText username = null!;
         private Container teamFlagContainer = null!;
         private OsuSpriteText userRankText = null!;
@@ -140,7 +141,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
                                             RelativeSizeAxes = Axes.Both,
                                             FillMode = FillMode.Fit,
                                         },
-                                        new UpdateableFlag
+                                        userFlag = new UpdateableFlag
                                         {
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
@@ -241,6 +242,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
 
             userCover.User = user;
             userAvatar.User = user;
+            userFlag.CountryCode = user?.CountryCode ?? default;
             teamFlagContainer.Child = new UpdateableTeamFlag(user?.Team)
             {
                 Size = new Vector2(40, 20)
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
index 06efffbf6e..7ad8bdf454 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
@@ -154,7 +154,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             });
             leaderboardFlow.Insert(0, Leaderboard = new DrawableGameplayLeaderboard
             {
-                ForceExpand = { Value = true }
+                CollapseDuringGameplay = { Value = false }
             });
 
             LoadComponentAsync(new GameplayChatDisplay(room)
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
index dc4078cb1f..69a1e3b763 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
@@ -13,6 +13,7 @@ using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.OnlinePlay.Playlists
@@ -21,11 +22,18 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
     {
         public Action? Exited;
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private readonly PlaylistsGameplayLeaderboardProvider leaderboardProvider;
+
         protected override UserActivity InitialActivity => new UserActivity.InPlaylistGame(Beatmap.Value.BeatmapInfo, Ruleset.Value);
 
-        public PlaylistsPlayer(Room room, PlaylistItem playlistItem, PlayerConfiguration? configuration = null)
-            : base(room, playlistItem, configuration)
+        public PlaylistsPlayer(Room room, PlaylistItem playlistItem)
+            : base(room, playlistItem, new PlayerConfiguration
+            {
+                ShowLeaderboard = true,
+            })
         {
+            leaderboardProvider = new PlaylistsGameplayLeaderboardProvider(room, playlistItem);
         }
 
         [BackgroundDependencyLoader]
@@ -41,6 +49,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             var requiredLocalMods = PlaylistItem.RequiredMods.Select(m => m.ToMod(GameplayState.Ruleset));
             if (!requiredLocalMods.All(m => Mods.Value.Any(m.Equals)))
                 throw new InvalidOperationException("Current Mods do not match PlaylistItem's RequiredMods");
+
+            LoadComponentAsync(leaderboardProvider, AddInternal);
         }
 
         public override bool OnExiting(ScreenExitEvent e)
diff --git a/osu.Game/Screens/Play/HUD/ArgonAccuracyCounter.cs b/osu.Game/Screens/Play/HUD/ArgonAccuracyCounter.cs
index d7fe1f52ff..c4cf52c254 100644
--- a/osu.Game/Screens/Play/HUD/ArgonAccuracyCounter.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonAccuracyCounter.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Screens.Play.HUD
             MaxValue = 1,
         };
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel), nameof(SkinnableComponentStrings.ShowLabelDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
         public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
 
         public bool UsesFixedAnchor { get; set; }
diff --git a/osu.Game/Screens/Play/HUD/ArgonComboCounter.cs b/osu.Game/Screens/Play/HUD/ArgonComboCounter.cs
index e82e8f4b6f..22d65601cd 100644
--- a/osu.Game/Screens/Play/HUD/ArgonComboCounter.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonComboCounter.cs
@@ -33,7 +33,7 @@ namespace osu.Game.Screens.Play.HUD
             MaxValue = 1,
         };
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel), nameof(SkinnableComponentStrings.ShowLabelDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
         public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Screens/Play/HUD/ArgonPerformancePointsCounter.cs b/osu.Game/Screens/Play/HUD/ArgonPerformancePointsCounter.cs
index 1620da2f2e..8e9360920c 100644
--- a/osu.Game/Screens/Play/HUD/ArgonPerformancePointsCounter.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonPerformancePointsCounter.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Screens.Play.HUD
             MaxValue = 1,
         };
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel), nameof(SkinnableComponentStrings.ShowLabelDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
         public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
 
         public override bool IsValid
diff --git a/osu.Game/Screens/Play/HUD/ArgonScoreCounter.cs b/osu.Game/Screens/Play/HUD/ArgonScoreCounter.cs
index 8658651407..f000a5977c 100644
--- a/osu.Game/Screens/Play/HUD/ArgonScoreCounter.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonScoreCounter.cs
@@ -28,7 +28,7 @@ namespace osu.Game.Screens.Play.HUD
             MaxValue = 1,
         };
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel), nameof(SkinnableComponentStrings.ShowLabelDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
         public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
 
         public bool UsesFixedAnchor { get; set; }
diff --git a/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs b/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
index 8dc5d60352..5b2efb447b 100644
--- a/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
@@ -33,7 +33,7 @@ namespace osu.Game.Screens.Play.HUD
         [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.UseRelativeSize))]
         public BindableBool UseRelativeSize { get; } = new BindableBool(true);
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour))]
         public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
 
         [Resolved]
diff --git a/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs b/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
index 46a658cd1c..810100532b 100644
--- a/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Screens.Play.HUD
         [SettingSource("Inverted shear")]
         public BindableBool InvertShear { get; } = new BindableBool();
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour))]
         public BindableColour4 AccentColour { get; } = new BindableColour4(Color4Extensions.FromHex("#66CCFF"));
 
         public ArgonWedgePiece()
diff --git a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
index 0f8f74f7fa..f184ad6a03 100644
--- a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
@@ -6,11 +6,14 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Audio;
+using osu.Game.Configuration;
 using osu.Game.Online.Leaderboards;
+using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Skinning;
 using osuTK;
+using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -19,6 +22,9 @@ namespace osu.Game.Screens.Play.HUD
         [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!;
@@ -26,6 +32,8 @@ namespace osu.Game.Screens.Play.HUD
         private SkinnableSound rankDownSample = null!;
         private SkinnableSound rankUpSample = null!;
 
+        private Bindable<double?> lastSamplePlaybackTime = null!;
+
         private IBindable<ScoreRank> rank = null!;
 
         public DefaultRankDisplay()
@@ -34,7 +42,7 @@ namespace osu.Game.Screens.Play.HUD
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(SkinEditor? skinEditor, SessionStatics statics)
         {
             InternalChildren = new Drawable[]
             {
@@ -45,6 +53,11 @@ namespace osu.Game.Screens.Play.HUD
                     RelativeSizeAxes = Axes.Both
                 },
             };
+
+            if (skinEditor != null)
+                PlaySamples.Value = false;
+
+            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
         }
 
         protected override void LoadComplete()
@@ -54,13 +67,17 @@ namespace osu.Game.Screens.Play.HUD
             rank = scoreProcessor.Rank.GetBoundCopy();
             rank.BindValueChanged(r =>
             {
+                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+
                 // Don't play rank-down sfx on quit/retry
-                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F)
+                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F && PlaySamples.Value && enoughTimeElapsed)
                 {
                     if (r.NewValue > rankDisplay.Rank)
                         rankUpSample.Play();
                     else
                         rankDownSample.Play();
+
+                    lastSamplePlaybackTime.Value = Time.Current;
                 }
 
                 rankDisplay.Rank = r.NewValue;
diff --git a/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs b/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
index 672017750d..06d541d838 100644
--- a/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
@@ -40,7 +40,7 @@ namespace osu.Game.Screens.Play.HUD
         [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.UseRelativeSize))]
         public BindableBool UseRelativeSize { get; } = new BindableBool(true);
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour))]
         public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
 
         [Resolved]
diff --git a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
index e04d91b5b7..dd55e5f926 100644
--- a/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
+using osu.Game.Localisation.SkinComponents;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Skinning;
 using osuTK;
@@ -20,8 +21,6 @@ namespace osu.Game.Screens.Play.HUD
 {
     public partial class DrawableGameplayLeaderboard : CompositeDrawable, ISerialisableDrawable
     {
-        public readonly Bindable<bool> ForceExpand = new Bindable<bool>();
-
         protected readonly FillFlowContainer<DrawableGameplayLeaderboardScore> Flow;
 
         private bool requiresScroll;
@@ -29,11 +28,14 @@ namespace osu.Game.Screens.Play.HUD
 
         public DrawableGameplayLeaderboardScore? TrackedScore { get; private set; }
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.CollapseDuringGameplay), nameof(SkinnableComponentStrings.CollapseDuringGameplayDescription))]
+        public Bindable<bool> CollapseDuringGameplay { get; } = new BindableBool(true);
+
         [Resolved]
         private Player? player { get; set; }
 
         [Resolved]
-        private IGameplayLeaderboardProvider? leaderboardProvider { get; set; }
+        private IGameplayLeaderboardProvider leaderboardProvider { get; set; } = null!;
 
         private readonly IBindableList<GameplayLeaderboardScore> scores = new BindableList<GameplayLeaderboardScore>();
         private readonly Bindable<bool> configVisibility = new Bindable<bool>();
@@ -86,21 +88,18 @@ namespace osu.Game.Screens.Play.HUD
         {
             base.LoadComplete();
 
-            if (leaderboardProvider != null)
+            scores.BindTo(leaderboardProvider.Scores);
+            scores.BindCollectionChanged((_, _) =>
             {
-                scores.BindTo(leaderboardProvider.Scores);
-                scores.BindCollectionChanged((_, _) =>
-                {
-                    Clear();
-                    foreach (var score in scores)
-                        Add(score);
-                }, true);
-            }
+                Clear();
+                foreach (var score in scores)
+                    Add(score);
+            }, true);
 
             configVisibility.BindValueChanged(_ => Scheduler.AddOnce(updateState));
             userPlayingState.BindValueChanged(_ => Scheduler.AddOnce(updateState));
             holdingForHUD.BindValueChanged(_ => Scheduler.AddOnce(updateState));
-            ForceExpand.BindValueChanged(_ => Scheduler.AddOnce(updateState));
+            CollapseDuringGameplay.BindValueChanged(_ => Scheduler.AddOnce(updateState));
             updateState();
         }
 
@@ -111,7 +110,7 @@ namespace osu.Game.Screens.Play.HUD
                 scroll.ScrollToStart(false);
 
             Flow.FadeTo(player?.Configuration.ShowLeaderboard != false && configVisibility.Value ? 1 : 0, 100, Easing.OutQuint);
-            expanded.Value = ForceExpand.Value || userPlayingState.Value != LocalUserPlayingState.Playing || holdingForHUD.Value;
+            expanded.Value = !CollapseDuringGameplay.Value || userPlayingState.Value != LocalUserPlayingState.Playing || holdingForHUD.Value;
         }
 
         /// <summary>
diff --git a/osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs b/osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs
index a71a46ec2a..e27a7544c9 100644
--- a/osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs
+++ b/osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs
@@ -87,7 +87,7 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
             const int bar_width = 2;
             const float chevron_size = 8;
 
-            hitWindows = HitWindows.GetAllAvailableWindows().ToArray();
+            hitWindows = HitWindows.GetAllAvailableWindows().Where(w => w.result.IsHit()).ToArray();
 
             InternalChild = new Container
             {
diff --git a/osu.Game/Screens/Play/HUD/PlayerSettingsOverlay.cs b/osu.Game/Screens/Play/HUD/PlayerSettingsOverlay.cs
index b285b1b799..635d140a4a 100644
--- a/osu.Game/Screens/Play/HUD/PlayerSettingsOverlay.cs
+++ b/osu.Game/Screens/Play/HUD/PlayerSettingsOverlay.cs
@@ -6,6 +6,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
@@ -47,6 +48,12 @@ namespace osu.Game.Screens.Play.HUD
         [Resolved]
         private HUDOverlay? hudOverlay { get; set; }
 
+        // Player settings are kept off the edge of the screen.
+        //
+        // In edge cases, floating point error could result in the whole control getting masked away
+        // while collapsed down, so let's avoid that.
+        protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
+
         public PlayerSettingsOverlay()
             : base(0, EXPANDED_WIDTH)
         {
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index d22717abd4..848b8292d4 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -26,12 +26,14 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input;
 using osu.Game.Localisation;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Overlays.Volume;
 using osu.Game.Performance;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play.PlayerSettings;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Skinning;
 using osu.Game.Users;
 using osu.Game.Utils;
@@ -57,7 +59,7 @@ namespace osu.Game.Screens.Play
         // this makes the game stay in portrait mode when restarting gameplay rather than switching back to landscape.
         public override bool RequiresPortraitOrientation => CurrentPlayer?.RequiresPortraitOrientation == true;
 
-        public override float BackgroundParallaxAmount => quickRestart ? 0 : 1;
+        public override float BackgroundParallaxAmount => QuickRestart ? 0 : 1;
 
         // Here because IsHovered will not update unless we do so.
         public override bool HandlePositionalInput => true;
@@ -96,6 +98,8 @@ namespace osu.Game.Screens.Play
 
         private Box? quickRestartBlackLayer;
 
+        private ScheduledDelegate? quickRestartBackButtonRestore;
+
         [Cached]
         private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
 
@@ -144,6 +148,7 @@ namespace osu.Game.Screens.Play
         private bool playerConsumed;
 
         private LogoTrackingContainer content = null!;
+        private IDisposable? logoTracking;
 
         private bool hideOverlays;
 
@@ -155,7 +160,7 @@ namespace osu.Game.Screens.Play
 
         private PlayerLoaderDisclaimer? epilepsyWarning;
 
-        private bool quickRestart;
+        protected bool QuickRestart { get; private set; }
 
         private IDisposable? highPerformanceSession;
 
@@ -174,6 +179,9 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private IHighPerformanceSessionManager? highPerformanceSessionManager { get; set; }
 
+        [Resolved]
+        private LeaderboardManager? leaderboardManager { get; set; }
+
         public PlayerLoader(Func<Player> createPlayer)
         {
             this.createPlayer = createPlayer;
@@ -268,6 +276,12 @@ namespace osu.Game.Screens.Play
 
             showStoryboards.BindValueChanged(val => epilepsyWarning?.FadeTo(val.NewValue ? 1 : 0, 250, Easing.OutQuint), true);
             epilepsyWarning?.FinishTransforms(true);
+
+            leaderboardManager?.FetchWithCriteria(new LeaderboardCriteria(
+                Beatmap.Value.BeatmapInfo,
+                Ruleset.Value,
+                leaderboardManager?.CurrentCriteria?.Scope ?? BeatmapLeaderboardScope.Global,
+                leaderboardManager?.CurrentCriteria?.ExactMods));
         }
 
         #region Screen handling
@@ -368,7 +382,7 @@ namespace osu.Game.Screens.Play
 
             logo.ScaleTo(new Vector2(0.15f), duration, Easing.OutQuint);
 
-            if (quickRestart)
+            if (QuickRestart)
             {
                 logo.Delay(quick_restart_initial_delay)
                     .FadeIn(350);
@@ -379,21 +393,26 @@ namespace osu.Game.Screens.Play
             Scheduler.AddDelayed(() =>
             {
                 if (this.IsCurrentScreen())
-                    content.StartTracking(logo, resuming ? 0 : 500, Easing.InOutExpo);
+                    logoTracking = content.StartTracking(logo, resuming ? 0 : 500, Easing.InOutExpo);
             }, resuming ? 0 : 250);
         }
 
         protected override void LogoExiting(OsuLogo logo)
         {
             base.LogoExiting(logo);
-            content.StopTracking();
+
+            logoTracking?.Dispose();
+            logoTracking = null;
+
             osuLogo = null;
         }
 
         protected override void LogoSuspending(OsuLogo logo)
         {
             base.LogoSuspending(logo);
-            content.StopTracking();
+
+            logoTracking?.Dispose();
+            logoTracking = null;
 
             logo
                 .FadeOut(CONTENT_OUT_DURATION / 2, Easing.OutQuint)
@@ -413,7 +432,7 @@ namespace osu.Game.Screens.Play
 
             // We need to perform this check here rather than in OnHover as any number of children of VisualSettings
             // may also be handling the hover events.
-            if (inputManager.HoveredDrawables.Contains(VisualSettings) || quickRestart)
+            if (inputManager.HoveredDrawables.Contains(VisualSettings) || QuickRestart)
             {
                 // Preview user-defined background dim and blur when hovered on the visual settings panel.
                 ApplyToBackground(b =>
@@ -452,7 +471,7 @@ namespace osu.Game.Screens.Play
                 return;
 
             CurrentPlayer = createPlayer();
-            CurrentPlayer.Configuration.AutomaticallySkipIntro |= quickRestart;
+            CurrentPlayer.Configuration.AutomaticallySkipIntro |= QuickRestart;
             CurrentPlayer.RestartCount = restartCount++;
             CurrentPlayer.PrepareLoaderForRestart = prepareForRestart;
 
@@ -469,7 +488,7 @@ namespace osu.Game.Screens.Play
 
         private void prepareForRestart(bool quickRestartRequested)
         {
-            quickRestart = quickRestartRequested;
+            QuickRestart = quickRestartRequested;
             hideOverlays = true;
             ValidForResume = true;
         }
@@ -478,7 +497,7 @@ namespace osu.Game.Screens.Play
         {
             MetadataInfo.Loading = true;
 
-            if (quickRestart)
+            if (QuickRestart)
             {
                 BackButtonVisibility.Value = false;
 
@@ -501,7 +520,8 @@ namespace osu.Game.Screens.Play
                     .ScaleTo(1)
                     .FadeInFromZero(500, Easing.OutQuint);
 
-                this.Delay(quick_restart_initial_delay).Schedule(() => BackButtonVisibility.Value = true);
+                quickRestartBackButtonRestore?.Cancel();
+                quickRestartBackButtonRestore = Scheduler.AddDelayed(() => BackButtonVisibility.Value = true, quick_restart_initial_delay);
             }
             else
             {
@@ -538,7 +558,8 @@ namespace osu.Game.Screens.Play
         protected virtual void ContentOut()
         {
             // Ensure the logo is no longer tracking before we scale the content
-            content.StopTracking();
+            logoTracking?.Dispose();
+            logoTracking = null;
 
             content.ScaleTo(0.7f, CONTENT_OUT_DURATION * 2, Easing.OutQuint);
             content.FadeOut(CONTENT_OUT_DURATION, Easing.OutQuint)
@@ -617,7 +638,7 @@ namespace osu.Game.Screens.Play
                 },
                 // When a quick restart is activated, the metadata content will display some time later if it's taking too long.
                 // To avoid it appearing too briefly, if it begins to fade in let's induce a standard delay.
-                quickRestart && content.Alpha == 0 ? 0 : 500);
+                QuickRestart && content.Alpha == 0 ? 0 : 500);
         }
 
         private void cancelLoad()
@@ -708,6 +729,10 @@ namespace osu.Game.Screens.Play
 
         #region Low battery warning
 
+        /// <summary>
+        /// This is intentionally higher than 20%, which is usually when OS level notifications
+        /// interrupt the active application to warn the user.
+        /// </summary>
         private const double low_battery_threshold = 0.25;
 
         private Bindable<bool> batteryWarningShownOnce = null!;
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index b0b4f6cc5d..5efef16d08 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -69,6 +69,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
         private IDisposable? beatmapOffsetSubscription;
 
         private Task? realmWriteTask;
+        private ScoreInfo? lastValidScore;
 
         public BeatmapOffsetControl()
         {
@@ -177,8 +178,6 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
         private void scoreChanged(ValueChangedEvent<ScoreInfo?> score)
         {
-            referenceScoreContainer.Clear();
-
             if (score.NewValue == null)
                 return;
 
@@ -196,6 +195,15 @@ namespace osu.Game.Screens.Play.PlayerSettings
             if (!(hitEvents.CalculateMedianHitError() is double median))
                 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. one that it *makes sense to use* when doing anything with timing and offsets.
+            bool hasEnoughUsableEvents = hitEvents.Count(HitEventExtensions.AffectsUnstableRate) >= 50;
+
+            // If we already have an old score with enough hit events and the new score doesn't have enough, continue displaying the old one rather than showing the user "play too short" message.
+            if (lastValidScore != null && !hasEnoughUsableEvents)
+                return;
+
             referenceScoreContainer.Children = new Drawable[]
             {
                 new OsuSpriteText
@@ -204,10 +212,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                 },
             };
 
-            // 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. one that it *makes sense to use* when doing anything with timing and offsets.
-            if (hitEvents.Count(HitEventExtensions.AffectsUnstableRate) < 50)
+            if (!hasEnoughUsableEvents)
             {
                 referenceScoreContainer.AddRange(new Drawable[]
                 {
@@ -223,6 +228,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                 return;
             }
 
+            lastValidScore = score.NewValue!;
             lastPlayMedian = median;
             lastPlayBeatmapOffset = Current.Value;
 
@@ -245,7 +251,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                             return;
 
                         Current.Value = lastPlayBeatmapOffset - lastPlayMedian;
-                        lastAppliedScore.Value = ReferenceScore.Value;
+                        lastAppliedScore.Value = lastValidScore;
                     },
                 },
                 globalOffsetText = new LinkFlowContainer
diff --git a/osu.Game/Screens/Play/ReplayPlayer.cs b/osu.Game/Screens/Play/ReplayPlayer.cs
index 882e556965..c058238a0a 100644
--- a/osu.Game/Screens/Play/ReplayPlayer.cs
+++ b/osu.Game/Screens/Play/ReplayPlayer.cs
@@ -29,8 +29,6 @@ namespace osu.Game.Screens.Play
 
         private readonly Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore;
 
-        private readonly bool replayIsFailedScore;
-
         private PlaybackSettings playbackSettings;
 
         [Cached(typeof(IGameplayLeaderboardProvider))]
@@ -40,19 +38,28 @@ namespace osu.Game.Screens.Play
 
         private bool isAutoplayPlayback => GameplayState.Mods.OfType<ModAutoplay>().Any();
 
-        // Disallow replays from failing. (see https://github.com/ppy/osu/issues/6108)
+        private double? lastFrameTime;
+
         protected override bool CheckModsAllowFailure()
         {
-            if (!replayIsFailedScore && !isAutoplayPlayback)
-                return false;
+            // autoplay should be able to fail if the beatmap is not humanly beatable
+            if (isAutoplayPlayback)
+                return base.CheckModsAllowFailure();
 
-            return base.CheckModsAllowFailure();
+            // non-autoplay replays should be able to fail, but only after they've exhausted their frames.
+            // note that the rank isn't checked here - that's because it is generally unreliable.
+            // stable replays, as well as lazer replays recorded prior to https://github.com/ppy/osu/pull/28058,
+            // do not even *contain* the user's rank.
+            // not to mention possible gameplay mechanics changes that could make a replay fail sooner than it really should.
+            if (GameplayClockContainer.CurrentTime >= lastFrameTime)
+                return base.CheckModsAllowFailure();
+
+            return false;
         }
 
         public ReplayPlayer(Score score, PlayerConfiguration configuration = null)
             : this((_, _) => score, configuration)
         {
-            replayIsFailedScore = score.ScoreInfo.Rank == ScoreRank.F;
         }
 
         public ReplayPlayer(Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore, PlayerConfiguration configuration = null)
@@ -95,6 +102,7 @@ namespace osu.Game.Screens.Play
         protected override void PrepareReplay()
         {
             DrawableRuleset?.SetReplayScore(Score);
+            lastFrameTime = Score.Replay.Frames.LastOrDefault()?.Time;
         }
 
         protected override Score CreateScore(IBeatmap beatmap) => createScore(beatmap, Mods.Value);
diff --git a/osu.Game/Screens/Play/SpectatorPlayer.cs b/osu.Game/Screens/Play/SpectatorPlayer.cs
index b2ac946642..6bfb6e033a 100644
--- a/osu.Game/Screens/Play/SpectatorPlayer.cs
+++ b/osu.Game/Screens/Play/SpectatorPlayer.cs
@@ -13,11 +13,17 @@ using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Screens.Play
 {
     public abstract partial class SpectatorPlayer : Player
     {
+        // TODO: maybe consider giving this proper scores.
+        // `SoloGameplayLeaderboardProvider` doesn't immediately work because there's no guarantee that `LeaderboardManager` global state matches the currently spectated beatmap.
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private readonly EmptyGameplayLeaderboardProvider leaderboardProvider = new EmptyGameplayLeaderboardProvider();
+
         [Resolved]
         protected SpectatorClient SpectatorClient { get; private set; } = null!;
 
diff --git a/osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs b/osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs
index 7d155e32b0..8a84501a17 100644
--- a/osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs
+++ b/osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs
@@ -79,6 +79,11 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
                     Alpha = 0.5f;
                     TooltipText = ResultsScreenStrings.NoPPForUnrankedMods;
                 }
+                else if (scoreInfo.Rank == ScoreRank.F)
+                {
+                    Alpha = 0.5f;
+                    TooltipText = ResultsScreenStrings.NoPPForFailedScores;
+                }
                 else
                 {
                     Alpha = 1f;
diff --git a/osu.Game/Screens/Ranking/SoloResultsScreen.cs b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
index d11e7db178..56d175420f 100644
--- a/osu.Game/Screens/Ranking/SoloResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
@@ -8,7 +8,6 @@ using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Logging;
-using osu.Game.Beatmaps;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
@@ -42,9 +41,6 @@ namespace osu.Game.Screens.Ranking
         {
             Debug.Assert(Score != null);
 
-            if (Score.BeatmapInfo!.OnlineID <= 0 || Score.BeatmapInfo.Status <= BeatmapOnlineStatus.Pending)
-                return [];
-
             var criteria = new LeaderboardCriteria(
                 Score.BeatmapInfo!,
                 Score.Ruleset,
@@ -78,11 +74,26 @@ namespace osu.Game.Screens.Ranking
                 // this simplifies handling later.
                 if (clonedScore.Equals(Score) || clonedScore.MatchesOnlineID(Score))
                 {
+                    // this is a precautionary guard that prevents `Score` from appearing multiple times in the list.
+                    // that can occur in rare cases wherein two local scores have the same online ID but different replay contents
+                    // (this is possible e.g. in cases of client-side vs server-side recorded replays, see https://github.com/ppy/osu-server-spectator/issues/193)
+                    if (sortedScores.Contains(Score))
+                        continue;
+
                     Score.Position = clonedScore.Position;
                     sortedScores.Add(Score);
                 }
-                else if (criteria.Scope == BeatmapLeaderboardScope.Local || clonedScore.UserID != api.LocalUser.Value.OnlineID || clonedScore.TotalScore > Score.TotalScore)
+                else
+                {
+                    bool isOnlineLeaderboard = criteria.Scope != BeatmapLeaderboardScope.Local;
+                    bool presentingLocalUserScore = Score.UserID == api.LocalUser.Value.OnlineID;
+                    bool presentedLocalUserScoreIsBetter = presentingLocalUserScore && clonedScore.UserID == api.LocalUser.Value.OnlineID && clonedScore.TotalScore < Score.TotalScore;
+
+                    if (isOnlineLeaderboard && presentedLocalUserScoreIsBetter)
+                        continue;
+
                     sortedScores.Add(clonedScore);
+                }
             }
 
             // if we haven't encountered a match for the presented score, we still need to attach it.
diff --git a/osu.Game/Screens/Ranking/Statistics/User/PerformancePointsChangeRow.cs b/osu.Game/Screens/Ranking/Statistics/User/PerformancePointsChangeRow.cs
index c1faf1a3e3..3af1bdb860 100644
--- a/osu.Game/Screens/Ranking/Statistics/User/PerformancePointsChangeRow.cs
+++ b/osu.Game/Screens/Ranking/Statistics/User/PerformancePointsChangeRow.cs
@@ -1,25 +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;
 using System.Diagnostics;
 using osu.Framework.Localisation;
 using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Screens.Ranking.Statistics.User
 {
-    public partial class PerformancePointsChangeRow : RankingChangeRow<decimal?>
+    public partial class PerformancePointsChangeRow : RankingChangeRow<int?>
     {
         public PerformancePointsChangeRow()
-            : base(stats => stats.PP)
+            : base(stats => stats.PP != null ? (int)Math.Round(stats.PP.Value) : null)
         {
         }
 
         protected override LocalisableString Label => RankingsStrings.StatPerformance;
 
-        protected override LocalisableString FormatCurrentValue(decimal? current)
+        protected override LocalisableString FormatCurrentValue(int? current)
             => current == null ? string.Empty : LocalisableString.Interpolate($@"{current:N0}pp");
 
-        protected override int CalculateDifference(decimal? previous, decimal? current, out LocalisableString formattedDifference)
+        protected override int CalculateDifference(int? previous, int? current, out LocalisableString formattedDifference)
         {
             if (previous == null && current == null)
             {
diff --git a/osu.Game/Screens/Ranking/UserTagControl.cs b/osu.Game/Screens/Ranking/UserTagControl.cs
index e323107783..5618dd2490 100644
--- a/osu.Game/Screens/Ranking/UserTagControl.cs
+++ b/osu.Game/Screens/Ranking/UserTagControl.cs
@@ -13,6 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -44,6 +45,8 @@ namespace osu.Game.Screens.Ranking
 
         private AddNewTagUserTag addNewTagUserTag = null!;
 
+        private InputManager inputManager = null!;
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
@@ -124,6 +127,8 @@ namespace osu.Game.Screens.Ranking
             updateTags();
 
             displayedTags.BindCollectionChanged(displayTags, true);
+
+            inputManager = GetContainingInputManager()!;
         }
 
         private void updateTags()
@@ -251,7 +256,7 @@ namespace osu.Game.Screens.Ranking
         {
             base.Update();
 
-            if (!layout.IsValid && !IsHovered)
+            if (!layout.IsValid && !Contains(inputManager.CurrentState.Mouse.Position))
             {
                 var sortedTags = new Dictionary<UserTag, int>(
                     displayedTags.OrderByDescending(t => t.VoteCount.Value)
diff --git a/osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs b/osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs
index e54d88bca2..ff3c0711c0 100644
--- a/osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs
+++ b/osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs
@@ -18,7 +18,7 @@ namespace osu.Game.Screens.Ranking
 {
     public partial class UserTagControl
     {
-        private partial class DrawableUserTag : OsuAnimatedButton
+        public partial class DrawableUserTag : OsuAnimatedButton
         {
             public readonly UserTag UserTag;
 
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
index c474b36a89..9ccb8170f3 100644
--- a/osu.Game/Screens/Select/BeatmapCarousel.cs
+++ b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -701,13 +701,13 @@ namespace osu.Game.Screens.Select
             switch (e.Action)
             {
                 case GlobalAction.SelectNext:
-                case GlobalAction.SelectNextGroup:
-                    SelectNext(1, e.Action == GlobalAction.SelectNextGroup);
+                case GlobalAction.ActivateNextSet:
+                    SelectNext(1, e.Action == GlobalAction.ActivateNextSet);
                     return true;
 
                 case GlobalAction.SelectPrevious:
-                case GlobalAction.SelectPreviousGroup:
-                    SelectNext(-1, e.Action == GlobalAction.SelectPreviousGroup);
+                case GlobalAction.ActivatePreviousSet:
+                    SelectNext(-1, e.Action == GlobalAction.ActivatePreviousSet);
                     return true;
             }
 
diff --git a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
index dc77b0101e..02b5eb5b7a 100644
--- a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Select.Carousel
 {
@@ -59,7 +60,7 @@ namespace osu.Game.Screens.Select.Carousel
 
             if (!match) return false;
 
-            match &= !criteria.StarDifficulty.HasFilter || criteria.StarDifficulty.IsInRange(BeatmapInfo.StarRating);
+            match &= !criteria.StarDifficulty.HasFilter || criteria.StarDifficulty.IsInRange(BeatmapInfo.StarRating.FloorToDecimalDigits(2));
             match &= !criteria.ApproachRate.HasFilter || criteria.ApproachRate.IsInRange(BeatmapInfo.Difficulty.ApproachRate);
             match &= !criteria.DrainRate.HasFilter || criteria.DrainRate.IsInRange(BeatmapInfo.Difficulty.DrainRate);
             match &= !criteria.CircleSize.HasFilter || criteria.CircleSize.IsInRange(BeatmapInfo.Difficulty.CircleSize);
diff --git a/osu.Game/Screens/Select/Details/AdvancedStats.cs b/osu.Game/Screens/Select/Details/AdvancedStats.cs
index b7086d2416..152398dee3 100644
--- a/osu.Game/Screens/Select/Details/AdvancedStats.cs
+++ b/osu.Game/Screens/Select/Details/AdvancedStats.cs
@@ -251,7 +251,7 @@ namespace osu.Game.Screens.Select.Details
                 if (normalDifficulty == null || moddedDifficulty == null)
                     return;
 
-                starDifficulty.Value = ((float)normalDifficulty.Value.Stars, (float)moddedDifficulty.Value.Stars);
+                starDifficulty.Value = ((float)normalDifficulty.Value.Stars.FloorToDecimalDigits(2), (float)moddedDifficulty.Value.Stars.FloorToDecimalDigits(2));
             }), starDifficultyCancellationSource.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current);
         });
 
diff --git a/osu.Game/Screens/Select/FilterQueryParser.cs b/osu.Game/Screens/Select/FilterQueryParser.cs
index 1094d88730..02a6da146e 100644
--- a/osu.Game/Screens/Select/FilterQueryParser.cs
+++ b/osu.Game/Screens/Select/FilterQueryParser.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Screens.Select
                 case "star":
                 case "stars":
                 case "sr":
-                    return TryUpdateCriteriaRange(ref criteria.StarDifficulty, op, value, 0.01d / 2);
+                    return TryUpdateCriteriaRange(ref criteria.StarDifficulty, op, value, 0);
 
                 case "ar":
                     return TryUpdateCriteriaRange(ref criteria.ApproachRate, op, value);
@@ -309,6 +309,8 @@ namespace osu.Game.Screens.Select
                 case Operator.Equal:
                     range.Min = value - tolerance;
                     range.Max = value + tolerance;
+                    if (tolerance == 0)
+                        range.IsLowerInclusive = range.IsUpperInclusive = true;
                     break;
 
                 case Operator.Greater:
@@ -317,6 +319,8 @@ namespace osu.Game.Screens.Select
 
                 case Operator.GreaterOrEqual:
                     range.Min = value - tolerance;
+                    if (tolerance == 0)
+                        range.IsLowerInclusive = true;
                     break;
 
                 case Operator.Less:
@@ -325,6 +329,8 @@ namespace osu.Game.Screens.Select
 
                 case Operator.LessOrEqual:
                     range.Max = value + tolerance;
+                    if (tolerance == 0)
+                        range.IsUpperInclusive = true;
                     break;
             }
 
diff --git a/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs b/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs
index bf99472dd7..dfe95b8ccd 100644
--- a/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs
+++ b/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs
@@ -4,10 +4,12 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Online.Rooms;
 using osu.Game.Online.Spectator;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Scoring.Legacy;
+using osu.Game.Screens.Play;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.Select.Leaderboards
@@ -40,7 +42,8 @@ namespace osu.Game.Screens.Select.Leaderboards
         public BindableDouble Accuracy { get; } = new BindableDouble();
 
         /// <summary>
-        /// The current combo of the score.
+        /// The combo of the score to display.
+        /// Can be either highest combo or current combo, depending on constructor parameters.
         /// </summary>
         public BindableInt Combo { get; } = new BindableInt();
 
@@ -87,38 +90,52 @@ namespace osu.Game.Screens.Select.Leaderboards
         /// </summary>
         public Bindable<long> DisplayOrder { get; } = new BindableLong();
 
-        public GameplayLeaderboardScore(IUser user, ScoreProcessor scoreProcessor, bool tracked)
+        public GameplayLeaderboardScore(GameplayState gameplayState, bool tracked, ComboDisplayMode comboMode)
+        {
+            User = gameplayState.Score.ScoreInfo.User;
+            Tracked = tracked;
+
+            var scoreProcessor = gameplayState.ScoreProcessor;
+            TotalScore.BindTarget = scoreProcessor.TotalScore;
+            Accuracy.BindTarget = scoreProcessor.Accuracy;
+            Combo.BindTarget = comboMode == ComboDisplayMode.Current ? scoreProcessor.Combo : scoreProcessor.HighestCombo;
+            GetDisplayScore = scoreProcessor.GetDisplayScore;
+        }
+
+        public GameplayLeaderboardScore(IUser user, SpectatorScoreProcessor scoreProcessor, bool tracked, ComboDisplayMode comboMode)
         {
             User = user;
             Tracked = tracked;
             TotalScore.BindTarget = scoreProcessor.TotalScore;
             Accuracy.BindTarget = scoreProcessor.Accuracy;
-            Combo.BindTarget = scoreProcessor.Combo;
+            Combo.BindTarget = comboMode == ComboDisplayMode.Current ? scoreProcessor.Combo : scoreProcessor.HighestCombo;
             GetDisplayScore = scoreProcessor.GetDisplayScore;
         }
 
-        public GameplayLeaderboardScore(IUser user, SpectatorScoreProcessor scoreProcessor, bool tracked)
-        {
-            User = user;
-            Tracked = tracked;
-            TotalScore.BindTarget = scoreProcessor.TotalScore;
-            Accuracy.BindTarget = scoreProcessor.Accuracy;
-            Combo.BindTarget = scoreProcessor.Combo;
-            GetDisplayScore = scoreProcessor.GetDisplayScore;
-        }
-
-        public GameplayLeaderboardScore(ScoreInfo scoreInfo, bool tracked)
+        public GameplayLeaderboardScore(ScoreInfo scoreInfo, bool tracked, ComboDisplayMode comboMode)
         {
             User = scoreInfo.User;
             Tracked = tracked;
             TotalScore.Value = scoreInfo.TotalScore;
             Accuracy.Value = scoreInfo.Accuracy;
-            Combo.Value = scoreInfo.MaxCombo;
+            Combo.Value = comboMode == ComboDisplayMode.Current ? scoreInfo.Combo : scoreInfo.MaxCombo;
             TotalScoreTiebreaker = scoreInfo.OnlineID > 0 ? scoreInfo.OnlineID : scoreInfo.Date.ToUnixTimeSeconds();
             GetDisplayScore = scoreInfo.GetDisplayScore;
             InitialPosition = scoreInfo.Position;
         }
 
+        public GameplayLeaderboardScore(MultiplayerScore score, bool tracked, ComboDisplayMode comboMode)
+        {
+            User = score.User;
+            Tracked = tracked;
+            TotalScore.Value = score.TotalScore;
+            Accuracy.Value = score.Accuracy;
+            Combo.Value = comboMode == ComboDisplayMode.Highest ? score.MaxCombo : throw new NotSupportedException($"{comboMode} {nameof(comboMode)} is not supported.");
+            TotalScoreTiebreaker = score.ID;
+            GetDisplayScore = score.GetDisplayScore;
+            InitialPosition = score.Position;
+        }
+
         /// <remarks>
         /// Used for testing.
         /// </remarks>
@@ -129,5 +146,11 @@ namespace osu.Game.Screens.Select.Leaderboards
             TotalScore.BindTarget = displayScore;
             GetDisplayScore = _ => displayScore.Value;
         }
+
+        public enum ComboDisplayMode
+        {
+            Current,
+            Highest,
+        }
     }
 }
diff --git a/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
index b41329a489..6118529780 100644
--- a/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
+++ b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
@@ -15,4 +15,9 @@ namespace osu.Game.Screens.Select.Leaderboards
         /// </summary>
         IBindableList<GameplayLeaderboardScore> Scores { get; }
     }
+
+    public class EmptyGameplayLeaderboardProvider : IGameplayLeaderboardProvider
+    {
+        public IBindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
+    }
 }
diff --git a/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
index 80a5692841..08af8926df 100644
--- a/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
+++ b/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
@@ -37,8 +37,6 @@ namespace osu.Game.Screens.Select.Leaderboards
 
         public bool HasTeams => TeamScores.Count > 0;
 
-        public bool IsPartial => false;
-
         private readonly MultiplayerRoomUser[] users;
 
         private readonly Bindable<ScoringMode> scoringMode = new Bindable<ScoringMode>();
@@ -99,7 +97,11 @@ namespace osu.Game.Screens.Select.Leaderboards
 
                                        var trackedUser = UserScores[user.Id];
 
-                                       var leaderboardScore = new GameplayLeaderboardScore(user, trackedUser.ScoreProcessor, user.Id == api.LocalUser.Value.Id)
+                                       var leaderboardScore = new GameplayLeaderboardScore(
+                                           user,
+                                           trackedUser.ScoreProcessor,
+                                           user.Id == api.LocalUser.Value.Id,
+                                           GameplayLeaderboardScore.ComboDisplayMode.Current)
                                        {
                                            HasQuit = { BindTarget = trackedUser.UserQuit },
                                            TeamColour = UserScores[user.OnlineID].Team is int team ? getTeamColour(team) : null,
diff --git a/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs
new file mode 100644
index 0000000000..206b1375de
--- /dev/null
+++ b/osu.Game/Screens/Select/Leaderboards/PlaylistsGameplayLeaderboardProvider.cs
@@ -0,0 +1,126 @@
+// 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.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    [LongRunningLoad]
+    public partial class PlaylistsGameplayLeaderboardProvider : Component, IGameplayLeaderboardProvider
+    {
+        public IBindableList<GameplayLeaderboardScore> Scores => scores;
+        private readonly BindableList<GameplayLeaderboardScore> scores = new BindableList<GameplayLeaderboardScore>();
+
+        private readonly Room room;
+        private readonly PlaylistItem playlistItem;
+
+        private readonly Cached sorting = new Cached();
+        private bool isPartial;
+
+        public PlaylistsGameplayLeaderboardProvider(Room room, PlaylistItem playlistItem)
+        {
+            this.room = room;
+            this.playlistItem = playlistItem;
+        }
+
+        [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>();
+
+                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));
+                }
+
+                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);
+
+            if (gameplayState != null)
+            {
+                var localScore = new GameplayLeaderboardScore(gameplayState, tracked: true, GameplayLeaderboardScore.ComboDisplayMode.Highest);
+                localScore.TotalScore.BindValueChanged(_ => sorting.Invalidate());
+                scores.Add(localScore);
+            }
+
+            Scheduler.AddDelayed(sort, 1000, true);
+        }
+
+        // logic shared with SoloGameplayLeaderboardProvider
+        private void sort()
+        {
+            if (sorting.IsValid)
+                return;
+
+            var orderedByScore = scores
+                                 .OrderByDescending(i => i.TotalScore.Value)
+                                 .ThenBy(i => i.TotalScoreTiebreaker)
+                                 .ToList();
+
+            int delta = 0;
+
+            for (int i = 0; i < orderedByScore.Count; i++)
+            {
+                var score = orderedByScore[i];
+
+                // see `SoloResultsScreen.FetchScores()` for another place that does the same thing with slight deviations
+                // if this code is changed, that code should probably be changed as well
+
+                score.DisplayOrder.Value = i + 1;
+
+                // if we know we have all scores there can ever be, we can do the simple and obvious thing.
+                if (!isPartial)
+                    score.Position.Value = i + 1;
+                else
+                {
+                    // we have a partial leaderboard, with potential gaps.
+                    // we have initial score positions which were valid at the point of starting play.
+                    // the assumption here is that non-tracked scores here cannot move around, only tracked ones can.
+                    if (score.Tracked)
+                    {
+                        int? previousScorePosition = i > 0 ? orderedByScore[i - 1].InitialPosition : 0;
+                        int? nextScorePosition = i < orderedByScore.Count - 1 ? orderedByScore[i + 1].InitialPosition : null;
+
+                        // if the tracked score is perfectly between two scores which have known neighbouring initial positions,
+                        // we can assign it the position of the previous score plus one...
+                        if (previousScorePosition != null && nextScorePosition != null && previousScorePosition + 1 == nextScorePosition)
+                        {
+                            score.Position.Value = previousScorePosition + 1;
+                            // but we also need to ensure all subsequent scores get shifted down one position, too.
+                            delta++;
+                        }
+                        // conversely, if the tracked score is not between neighbouring two scores and the leaderboard is partial,
+                        // we can't really assign a valid position at all. it could be any number between the two neighbours.
+                        else
+                            score.Position.Value = null;
+                    }
+                    // for non-tracked scores, we just need to apply any delta that might have come from the tracked scores
+                    // which might have been encountered and assigned a position earlier.
+                    else
+                        score.Position.Value = score.InitialPosition + delta;
+                }
+            }
+
+            sorting.Validate();
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs
index d17d55e4dd..2ebef78a38 100644
--- a/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs
+++ b/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.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 System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -34,26 +35,33 @@ namespace osu.Game.Screens.Select.Leaderboards
 
             isPartial = leaderboardManager?.CurrentCriteria?.Scope != BeatmapLeaderboardScope.Local && globalScores?.TopScores.Count >= 50;
 
+            List<GameplayLeaderboardScore> newScores = new List<GameplayLeaderboardScore>();
+
             if (globalScores != null)
             {
                 foreach (var topScore in globalScores.AllScores.OrderByTotalScore())
-                    scores.Add(new GameplayLeaderboardScore(topScore, false));
+                {
+                    newScores.Add(new GameplayLeaderboardScore(topScore, false, GameplayLeaderboardScore.ComboDisplayMode.Highest));
+                }
             }
 
             if (gameplayState != null)
             {
-                var localScore = new GameplayLeaderboardScore(gameplayState.Score.ScoreInfo.User, gameplayState.ScoreProcessor, true)
+                var localScore = new GameplayLeaderboardScore(gameplayState, tracked: true, GameplayLeaderboardScore.ComboDisplayMode.Highest)
                 {
                     // Local score should always show lower than any existing scores in cases of ties.
                     TotalScoreTiebreaker = long.MaxValue
                 };
                 localScore.TotalScore.BindValueChanged(_ => sorting.Invalidate());
-                scores.Add(localScore);
+                newScores.Add(localScore);
             }
 
+            scores.AddRange(newScores);
+
             Scheduler.AddDelayed(sort, 1000, true);
         }
 
+        // logic shared with PlaylistsGameplayLeaderboardProvider
         private void sort()
         {
             if (sorting.IsValid)
diff --git a/osu.Game/Screens/Select/PlaySongSelect.cs b/osu.Game/Screens/Select/PlaySongSelect.cs
deleted file mode 100644
index c49b7c2ef2..0000000000
--- a/osu.Game/Screens/Select/PlaySongSelect.cs
+++ /dev/null
@@ -1,166 +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.Collections.Generic;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.LocalisationExtensions;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.Events;
-using osu.Framework.Screens;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Localisation;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Notifications;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play;
-using osu.Game.Screens.Ranking;
-using osu.Game.Users;
-using osu.Game.Utils;
-using osuTK.Input;
-
-namespace osu.Game.Screens.Select
-{
-    public partial class PlaySongSelect : SongSelect
-    {
-        private OsuScreen? playerLoader;
-
-        [Resolved]
-        private INotificationOverlay? notifications { get; set; }
-
-        public override bool AllowExternalScreenChange => true;
-
-        public override MenuItem[] CreateForwardNavigationMenuItemsForBeatmap(Func<BeatmapInfo> getBeatmap) => new MenuItem[]
-        {
-            new OsuMenuItem(ButtonSystemStrings.Play.ToSentence(), MenuItemType.Highlighted, () => FinaliseSelection(getBeatmap())),
-            new OsuMenuItem(ButtonSystemStrings.Edit.ToSentence(), MenuItemType.Standard, () => Edit(getBeatmap()))
-        };
-
-        protected override UserActivity InitialActivity => new UserActivity.ChoosingBeatmap();
-
-        private PlayBeatmapDetailArea playBeatmapDetailArea = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            BeatmapOptions.AddButton(ButtonSystemStrings.Edit.ToSentence(), @"beatmap", FontAwesome.Solid.PencilAlt, colours.Yellow, () => Edit());
-
-            AddInternal(new SongSelectTouchInputDetector());
-        }
-
-        protected void PresentScore(ScoreInfo score) =>
-            FinaliseSelection(score.BeatmapInfo, score.Ruleset, () => this.Push(new SoloResultsScreen(score)));
-
-        protected override BeatmapDetailArea CreateBeatmapDetailArea()
-        {
-            playBeatmapDetailArea = new PlayBeatmapDetailArea
-            {
-                Leaderboard =
-                {
-                    ScoreSelected = PresentScore
-                }
-            };
-
-            return playBeatmapDetailArea;
-        }
-
-        protected override bool OnKeyDown(KeyDownEvent e)
-        {
-            switch (e.Key)
-            {
-                case Key.Enter:
-                case Key.KeypadEnter:
-                    // this is a special hard-coded case; we can't rely on OnPressed (of SongSelect) as GlobalActionContainer is
-                    // matching with exact modifier consideration (so Ctrl+Enter would be ignored).
-                    FinaliseSelection();
-                    return true;
-            }
-
-            return base.OnKeyDown(e);
-        }
-
-        private IReadOnlyList<Mod>? modsAtGameplayStart;
-
-        private ModAutoplay? getAutoplayMod() => Ruleset.Value.CreateInstance().GetAutoplayMod();
-
-        protected override bool OnStart()
-        {
-            if (playerLoader != null) return false;
-
-            modsAtGameplayStart = Mods.Value;
-
-            // Ctrl+Enter should start map with autoplay enabled.
-            if (GetContainingInputManager()?.CurrentState?.Keyboard.ControlPressed == true)
-            {
-                var autoInstance = getAutoplayMod();
-
-                if (autoInstance == null)
-                {
-                    notifications?.Post(new SimpleNotification
-                    {
-                        Text = NotificationsStrings.NoAutoplayMod
-                    });
-                    return false;
-                }
-
-                var mods = Mods.Value.Append(autoInstance).ToArray();
-
-                if (!ModUtils.CheckCompatibleSet(mods, out var invalid))
-                    mods = mods.Except(invalid).Append(autoInstance).ToArray();
-
-                Mods.Value = mods;
-            }
-
-            SampleConfirm?.Play();
-
-            this.Push(playerLoader = new PlayerLoader(createPlayer));
-            return true;
-
-            Player createPlayer()
-            {
-                Player player;
-
-                var replayGeneratingMod = Mods.Value.OfType<ICreateReplayData>().FirstOrDefault();
-
-                if (replayGeneratingMod != null)
-                {
-                    player = new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods));
-                }
-                else
-                {
-                    player = new SoloPlayer();
-                }
-
-                return player;
-            }
-        }
-
-        public override void OnResuming(ScreenTransitionEvent e)
-        {
-            base.OnResuming(e);
-            revertMods();
-        }
-
-        public override bool OnExiting(ScreenExitEvent e)
-        {
-            if (base.OnExiting(e))
-                return true;
-
-            revertMods();
-            return false;
-        }
-
-        private void revertMods()
-        {
-            if (playerLoader == null) return;
-
-            Mods.Value = modsAtGameplayStart;
-            playerLoader = null;
-        }
-    }
-}
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index d14002181c..4119807692 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -13,6 +13,7 @@ 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.Graphics.Pooling;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
@@ -90,6 +91,9 @@ namespace osu.Game.Screens.SelectV2
             DebounceDelay = 100;
             DistanceOffscreenToPreload = 100;
 
+            // Account for the osu! logo being in the way.
+            Scroll.ScrollbarPaddingBottom = 70;
+
             Filters = new ICarouselFilter[]
             {
                 matching = new BeatmapCarouselFilterMatching(() => Criteria!),
@@ -118,8 +122,15 @@ namespace osu.Game.Screens.SelectV2
 
         #region Beatmap source hookup
 
-        private void beatmapSetsChanged(object? beatmaps, NotifyCollectionChangedEventArgs changed)
+        private void beatmapSetsChanged(object? beatmaps, NotifyCollectionChangedEventArgs changed) => Schedule(() =>
         {
+            // This callback is scheduled to ensure there's no added overhead during gameplay.
+            // If this ever becomes an issue, it's important to note that the actual carousel filtering is already
+            // implemented in a way it will only run when at song select.
+            //
+            // The overhead we are avoiding here is that of this method directly – things like Items.IndexOf calls
+            // that can be slow for very large beatmap libraries. There are definitely ways to optimise this further.
+
             // TODO: moving management of BeatmapInfo tracking to BeatmapStore might be something we want to consider.
             // right now we are managing this locally which is a bit of added overhead.
             IEnumerable<BeatmapSetInfo>? newItems = changed.NewItems?.Cast<BeatmapSetInfo>();
@@ -190,7 +201,7 @@ namespace osu.Game.Screens.SelectV2
                     Items.Clear();
                     break;
             }
-        }
+        });
 
         #endregion
 
@@ -200,6 +211,9 @@ namespace osu.Game.Screens.SelectV2
 
         protected BeatmapSetInfo? ExpandedBeatmapSet { get; private set; }
 
+        protected override bool ShouldActivateOnKeyboardSelection(CarouselItem item) =>
+            grouping.BeatmapSetsGroupedTogether && item.Model is BeatmapInfo;
+
         protected override void HandleItemActivated(CarouselItem item)
         {
             try
@@ -216,16 +230,15 @@ 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);
+
                         return;
 
                     case BeatmapSetInfo setInfo:
-                        // Selecting a set isn't valid – let's re-select the first visible difficulty.
-                        if (grouping.SetItems.TryGetValue(setInfo, out var items))
-                        {
-                            var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
-                            RequestRecommendedSelection(beatmaps);
-                        }
-
+                        selectRecommendedDifficultyForBeatmapSet(setInfo);
                         return;
 
                     case BeatmapInfo beatmapInfo:
@@ -259,9 +272,10 @@ namespace osu.Game.Screens.SelectV2
                     // 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;
 
-                    if (containingGroup != null)
-                        setExpandedGroup(containingGroup);
-                    setExpandedSet(beatmapInfo);
+                    setExpandedGroup(containingGroup);
+
+                    if (grouping.BeatmapSetsGroupedTogether)
+                        setExpandedSet(beatmapInfo);
                     break;
             }
         }
@@ -279,11 +293,22 @@ namespace osu.Game.Screens.SelectV2
             // This will update the visual state of the selected item.
             HandleItemSelected(CurrentSelection);
 
-            // If a group was selected that is not the one containing the selection, reselect it.
-            if (groupForReselection != null)
+            // 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.
+            if (groupForReselection != null && grouping.GroupItems.TryGetValue(groupForReselection, out _))
                 setExpandedGroup(groupForReselection);
         }
 
+        private void selectRecommendedDifficultyForBeatmapSet(BeatmapSetInfo beatmapSet)
+        {
+            // Selecting a set isn't valid – let's re-select the first visible difficulty.
+            if (grouping.SetItems.TryGetValue(beatmapSet, out var items))
+            {
+                var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+                RequestRecommendedSelection(beatmaps);
+            }
+        }
+
         /// <summary>
         /// If we don't have a selection and there's a single beatmap set returned, select it for the user.
         /// </summary>
@@ -311,10 +336,17 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            RequestRecommendedSelection(items.Select(i => i.Model).OfType<BeatmapInfo>());
+            var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+
+            if (beatmaps.Any(b => b.Equals(CurrentSelection as BeatmapInfo)))
+                return;
+
+            RequestRecommendedSelection(beatmaps);
         }
 
-        protected override bool CheckValidForGroupSelection(CarouselItem item)
+        protected override bool CheckValidForGroupSelection(CarouselItem item) => item.Model is GroupDefinition;
+
+        protected override bool CheckValidForSetSelection(CarouselItem item)
         {
             switch (item.Model)
             {
@@ -336,8 +368,11 @@ namespace osu.Game.Screens.SelectV2
         {
             if (ExpandedGroup != null)
                 setExpansionStateOfGroup(ExpandedGroup, false);
+
             ExpandedGroup = group;
-            setExpansionStateOfGroup(group, true);
+
+            if (ExpandedGroup != null)
+                setExpansionStateOfGroup(group, true);
         }
 
         private void setExpansionStateOfGroup(GroupDefinition group, bool expanded)
@@ -416,8 +451,7 @@ namespace osu.Game.Screens.SelectV2
 
         private Sample? sampleChangeDifficulty;
         private Sample? sampleChangeSet;
-        private Sample? sampleOpen;
-        private Sample? sampleClose;
+        private Sample? sampleToggleGroup;
 
         private double audioFeedbackLastPlaybackTime;
 
@@ -425,8 +459,7 @@ namespace osu.Game.Screens.SelectV2
         {
             sampleChangeDifficulty = audio.Samples.Get(@"SongSelect/select-difficulty");
             sampleChangeSet = audio.Samples.Get(@"SongSelect/select-expand");
-            sampleOpen = audio.Samples.Get(@"UI/menu-open");
-            sampleClose = audio.Samples.Get(@"UI/menu-close");
+            sampleToggleGroup = audio.Samples.Get(@"SongSelect/select-group");
 
             spinSample = audio.Samples.Get("SongSelect/random-spin");
             randomSelectSample = audio.Samples.Get(@"SongSelect/select-random");
@@ -439,10 +472,7 @@ namespace osu.Game.Screens.SelectV2
                 switch (item.Model)
                 {
                     case GroupDefinition:
-                        if (item.IsExpanded)
-                            sampleOpen?.Play();
-                        else
-                            sampleClose?.Play();
+                        sampleToggleGroup?.Play();
                         return;
 
                     case BeatmapSetInfo:
@@ -489,7 +519,7 @@ namespace osu.Game.Screens.SelectV2
 
         private ScheduledDelegate? loadingDebounce;
 
-        public void Filter(FilterCriteria criteria)
+        public void Filter(FilterCriteria criteria, bool showLoadingImmediately = false)
         {
             bool resetDisplay = grouping.BeatmapSetsGroupedTogether != BeatmapCarouselFilterGrouping.ShouldGroupBeatmapsTogether(criteria);
 
@@ -497,9 +527,12 @@ namespace osu.Game.Screens.SelectV2
 
             loadingDebounce ??= Scheduler.AddDelayed(() =>
             {
+                if (loading.State.Value == Visibility.Visible)
+                    return;
+
                 Scroll.FadeColour(OsuColour.Gray(0.5f), 1000, Easing.OutQuint);
                 loading.Show();
-            }, 250);
+            }, showLoadingImmediately ? 0 : 250);
 
             FilterAsync(resetDisplay).ContinueWith(_ => Schedule(() =>
             {
@@ -538,7 +571,7 @@ namespace osu.Game.Screens.SelectV2
             AddInternal(setPanelPool);
         }
 
-        protected override bool CheckModelEquality(object x, object y)
+        protected override bool CheckModelEquality(object? x, object? y)
         {
             // In the confines of the carousel logic, we assume that CurrentSelection (and all items) are using non-stale
             // BeatmapInfo reference, and that we can match based on beatmap / beatmapset (GU)IDs.
@@ -590,8 +623,8 @@ namespace osu.Game.Screens.SelectV2
         #region Random selection handling
 
         private readonly Bindable<RandomSelectAlgorithm> randomAlgorithm = new Bindable<RandomSelectAlgorithm>();
-        private readonly List<BeatmapSetInfo> previouslyVisitedRandomSets = new List<BeatmapSetInfo>();
-        private readonly List<BeatmapInfo> randomSelectedBeatmaps = new List<BeatmapInfo>();
+        private readonly List<BeatmapInfo> previouslyVisitedRandomBeatmaps = new List<BeatmapInfo>();
+        private readonly List<BeatmapInfo> randomHistory = new List<BeatmapInfo>();
 
         private Sample? spinSample;
         private Sample? randomSelectSample;
@@ -603,90 +636,180 @@ namespace osu.Game.Screens.SelectV2
             if (carouselItems?.Any() != true)
                 return false;
 
-            // If set grouping is available, this is the fastest way to retrieve sets for randomisation.
-            ICollection<BeatmapSetInfo> visibleSets = grouping.SetItems.Keys;
+            var selectionBefore = CurrentSelectionItem;
+            var beatmapBefore = selectionBefore?.Model as BeatmapInfo;
 
-            // If not, we need to do an expensive copy.
-            //
-            // There's probably a more efficient way to handle this. Maybe the grouping filter should always expose grouped sets regardless
-            // as that process is done asynchronously.
-            if (!visibleSets.Any())
-                visibleSets = carouselItems.Select(i => i.Model).OfType<BeatmapInfo>().Select(b => b.BeatmapSet!).Distinct().ToList();
+            bool success;
 
-            if (CurrentSelection is BeatmapInfo beatmapInfo)
+            if (beatmapBefore != null)
             {
-                randomSelectedBeatmaps.Add(beatmapInfo);
-
-                // when performing a random, we want to add the current set to the previously visited list
-                // else the user may be "randomised" to the existing selection.
-                if (previouslyVisitedRandomSets.LastOrDefault()?.Equals(beatmapInfo.BeatmapSet) != true)
-                    previouslyVisitedRandomSets.Add(beatmapInfo.BeatmapSet!);
+                // keep track of visited beatmaps and sets for rewind
+                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);
             }
 
-            BeatmapSetInfo set;
-
-            if (randomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
-            {
-                ICollection<BeatmapSetInfo> notYetVisitedSets = visibleSets.Except(previouslyVisitedRandomSets).ToList();
-
-                if (!notYetVisitedSets.Any())
-                {
-                    previouslyVisitedRandomSets.RemoveAll(s => visibleSets.Contains(s));
-                    notYetVisitedSets = visibleSets;
-                }
-
-                set = notYetVisitedSets.ElementAt(RNG.Next(notYetVisitedSets.Count));
-                previouslyVisitedRandomSets.Add(set);
-            }
+            if (grouping.BeatmapSetsGroupedTogether)
+                success = nextRandomSet();
             else
-                set = visibleSets.ElementAt(RNG.Next(visibleSets.Count));
+                success = nextRandomBeatmap();
 
-            if (CurrentSelectionItem != null)
-                playSpinSample(distanceBetween(carouselItems.First(i => !ReferenceEquals(i.Model, set)), CurrentSelectionItem), visibleSets.Count);
+            if (!success)
+            {
+                if (beatmapBefore != null)
+                    randomHistory.RemoveAt(randomHistory.Count - 1);
+                return false;
+            }
+
+            // CurrentSelectionItem won't be valid until UpdateAfterChildren.
+            // We probably want to fix this at some point since a few places are working-around this quirk.
+            ScheduleAfterChildren(() =>
+            {
+                if (selectionBefore != null && CurrentSelectionItem != null)
+                    playSpinSample(visiblePanelCountBetweenItems(selectionBefore, CurrentSelectionItem));
+            });
 
-            RequestRecommendedSelection(set.Beatmaps.Where(b => !b.Hidden));
             return true;
         }
 
-        public void PreviousRandom()
+        private bool nextRandomBeatmap()
+        {
+            ICollection<BeatmapInfo> 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();
+
+            BeatmapInfo beatmap;
+
+            switch (randomAlgorithm.Value)
+            {
+                case RandomSelectAlgorithm.RandomPermutation:
+                {
+                    ICollection<BeatmapInfo> notYetVisitedBeatmaps = visibleBeatmaps.Except(previouslyVisitedRandomBeatmaps).ToList();
+
+                    if (!notYetVisitedBeatmaps.Any())
+                    {
+                        previouslyVisitedRandomBeatmaps.RemoveAll(b => visibleBeatmaps.Contains(b));
+                        notYetVisitedBeatmaps = visibleBeatmaps;
+                        if (CurrentSelection is BeatmapInfo beatmapInfo)
+                            notYetVisitedBeatmaps = notYetVisitedBeatmaps.Except([beatmapInfo]).ToList();
+                    }
+
+                    if (notYetVisitedBeatmaps.Count == 0)
+                        return false;
+
+                    beatmap = notYetVisitedBeatmaps.ElementAt(RNG.Next(notYetVisitedBeatmaps.Count));
+                    break;
+                }
+
+                case RandomSelectAlgorithm.Random:
+                    beatmap = visibleBeatmaps.ElementAt(RNG.Next(visibleBeatmaps.Count));
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            RequestSelection(beatmap);
+            return true;
+        }
+
+        private bool nextRandomSet()
+        {
+            ICollection<BeatmapSetInfo> visibleSets = 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()
+                // This is the fastest way to retrieve sets for randomisation.
+                : grouping.SetItems.Keys;
+
+            BeatmapSetInfo set;
+
+            switch (randomAlgorithm.Value)
+            {
+                case RandomSelectAlgorithm.RandomPermutation:
+                {
+                    ICollection<BeatmapSetInfo> notYetVisitedSets = visibleSets.Except(previouslyVisitedRandomBeatmaps.Select(b => b.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();
+                    }
+
+                    if (notYetVisitedSets.Count == 0)
+                        return false;
+
+                    set = notYetVisitedSets.ElementAt(RNG.Next(notYetVisitedSets.Count));
+                    break;
+                }
+
+                case RandomSelectAlgorithm.Random:
+                    set = visibleSets.ElementAt(RNG.Next(visibleSets.Count));
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            selectRecommendedDifficultyForBeatmapSet(set);
+            return true;
+        }
+
+        public bool PreviousRandom()
         {
             var carouselItems = GetCarouselItems();
 
             if (carouselItems?.Any() != true)
-                return;
+                return false;
 
-            while (randomSelectedBeatmaps.Any())
+            while (randomHistory.Any())
             {
-                var previousBeatmap = randomSelectedBeatmaps[^1];
-                randomSelectedBeatmaps.RemoveAt(randomSelectedBeatmaps.Count - 1);
+                var previousBeatmap = randomHistory[^1];
+                randomHistory.RemoveAt(randomHistory.Count - 1);
 
                 var previousBeatmapItem = carouselItems.FirstOrDefault(i => i.Model is BeatmapInfo b && b.Equals(previousBeatmap));
 
                 if (previousBeatmapItem == null)
-                    return;
+                    return false;
 
                 if (CurrentSelection is BeatmapInfo beatmapInfo)
                 {
                     if (randomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
-                        previouslyVisitedRandomSets.Remove(beatmapInfo.BeatmapSet!);
+                        previouslyVisitedRandomBeatmaps.Remove(beatmapInfo);
 
-                    playSpinSample(distanceBetween(previousBeatmapItem, CurrentSelectionItem!), carouselItems.Count);
+                    if (CurrentSelectionItem == null)
+                        playSpinSample(0);
+                    else
+                        playSpinSample(visiblePanelCountBetweenItems(previousBeatmapItem, CurrentSelectionItem));
                 }
 
                 RequestSelection(previousBeatmap);
-                break;
+                return true;
             }
+
+            return false;
         }
 
-        private double distanceBetween(CarouselItem item1, CarouselItem item2) => Math.Ceiling(Math.Abs(item1.CarouselYPosition - item2.CarouselYPosition) / PanelBeatmapSet.HEIGHT);
+        private double visiblePanelCountBetweenItems(CarouselItem item1, CarouselItem item2) => Math.Ceiling(Math.Abs(item1.CarouselYPosition - item2.CarouselYPosition) / PanelBeatmapSet.HEIGHT);
 
-        private void playSpinSample(double distance, int count)
+        private void playSpinSample(double distance)
         {
             var chan = spinSample?.GetChannel();
 
             if (chan != null)
             {
-                chan.Frequency.Value = 1f + Math.Min(1f, distance / count);
+                chan.Frequency.Value = 1f + Math.Clamp(distance / 200, 0, 1);
                 chan.Play();
             }
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
index 8720378ad6..772d4123c2 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
@@ -76,15 +76,18 @@ namespace osu.Game.Screens.SelectV2
                     {
                         var beatmap = (BeatmapInfo)item.Model;
 
+                        bool newBeatmapSet = lastBeatmap?.BeatmapSet!.ID != beatmap.BeatmapSet!.ID;
+
+                        if (newBeatmapSet)
+                        {
+                            if (!setMap.TryGetValue(beatmap.BeatmapSet!, out currentSetItems))
+                                setMap[beatmap.BeatmapSet!] = currentSetItems = new HashSet<CarouselItem>();
+                        }
+
                         if (BeatmapSetsGroupedTogether)
                         {
-                            bool newBeatmapSet = lastBeatmap?.BeatmapSet!.ID != beatmap.BeatmapSet!.ID;
-
                             if (newBeatmapSet)
                             {
-                                if (!setMap.TryGetValue(beatmap.BeatmapSet!, out currentSetItems))
-                                    setMap[beatmap.BeatmapSet!] = currentSetItems = new HashSet<CarouselItem>();
-
                                 if (groupItem != null)
                                     groupItem.NestedItemCount++;
 
@@ -114,7 +117,7 @@ namespace osu.Game.Screens.SelectV2
                         currentGroupItems?.Add(i);
                         currentSetItems?.Add(i);
 
-                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is BeatmapSetInfo || currentSetItems == null));
+                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is BeatmapSetInfo || !BeatmapSetsGroupedTogether));
                     }
                 }
 
@@ -320,7 +323,8 @@ namespace osu.Game.Screens.SelectV2
 
         private GroupDefinition defineGroupByStars(double stars)
         {
-            int starInt = (int)Math.Round(stars, 2);
+            // truncation is intentional - compare `FormatUtils.FormatStarRating()`
+            int starInt = (int)stars;
             var starDifficulty = new StarDifficulty(starInt, 0);
 
             if (starInt == 0)
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
index 545fbbd5fd..f2f246093d 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterMatching.cs
@@ -9,6 +9,7 @@ using System.Threading.Tasks;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -56,9 +57,7 @@ namespace osu.Game.Screens.SelectV2
 
         private static bool checkCriteriaMatch(BeatmapInfo beatmap, FilterCriteria criteria)
         {
-            bool match = criteria.Ruleset == null ||
-                         beatmap.Ruleset.ShortName == criteria.Ruleset.ShortName ||
-                         (beatmap.Ruleset.OnlineID == 0 && criteria.Ruleset.OnlineID != 0 && criteria.AllowConvertedBeatmaps);
+            bool match = criteria.Ruleset == null || beatmap.AllowGameplayWithRuleset(criteria.Ruleset!, criteria.AllowConvertedBeatmaps);
 
             if (beatmap.BeatmapSet?.Equals(criteria.SelectedBeatmapSet) == true)
             {
@@ -83,7 +82,7 @@ namespace osu.Game.Screens.SelectV2
 
             if (!match) return false;
 
-            match &= !criteria.StarDifficulty.HasFilter || criteria.StarDifficulty.IsInRange(beatmap.StarRating);
+            match &= !criteria.StarDifficulty.HasFilter || criteria.StarDifficulty.IsInRange(beatmap.StarRating.FloorToDecimalDigits(2));
             match &= !criteria.ApproachRate.HasFilter || criteria.ApproachRate.IsInRange(beatmap.Difficulty.ApproachRate);
             match &= !criteria.DrainRate.HasFilter || criteria.DrainRate.IsInRange(beatmap.Difficulty.DrainRate);
             match &= !criteria.CircleSize.HasFilter || criteria.CircleSize.IsInRange(beatmap.Difficulty.CircleSize);
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
index 6a810a83b4..be507e7b36 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
@@ -46,6 +46,8 @@ namespace osu.Game.Screens.SelectV2
     {
         public const int HEIGHT = 50;
 
+        public readonly ScoreInfo Score;
+
         public Bindable<IReadOnlyList<Mod>> SelectedMods = new Bindable<IReadOnlyList<Mod>>();
 
         /// <summary>
@@ -56,11 +58,14 @@ namespace osu.Game.Screens.SelectV2
         public Func<Mod, bool> IsValidMod { get; set; } = _ => true;
 
         public int? Rank { get; init; }
-        public bool IsPersonalBest { get; init; }
+        public HighlightType? Highlight { get; init; }
 
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
@@ -93,8 +98,6 @@ namespace osu.Game.Screens.SelectV2
         private Colour4 backgroundColour;
         private ColourInfo totalScoreBackgroundGradient;
 
-        private ColourInfo personalBestGradient;
-
         private IBindable<ScoringMode> scoringMode { get; set; } = null!;
 
         private Box background = null!;
@@ -102,6 +105,7 @@ namespace osu.Game.Screens.SelectV2
 
         private ClickableAvatar innerAvatar = null!;
 
+        private Container centreContent = null!;
         private Container rightContent = null!;
 
         private FillFlowContainer<Drawable> modsContainer = null!;
@@ -109,12 +113,10 @@ namespace osu.Game.Screens.SelectV2
         private Box totalScoreBackground = null!;
 
         private FillFlowContainer statisticsContainer = null!;
-        private Container personalBestIndicator = null!;
+        private Container highlightGradient = null!;
         private Container rankLabelStandalone = null!;
         private Container rankLabelOverlay = null!;
 
-        private readonly ScoreInfo score;
-
         private readonly bool sheared;
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
@@ -128,7 +130,8 @@ namespace osu.Game.Screens.SelectV2
 
         public BeatmapLeaderboardScore(ScoreInfo score, bool sheared = true)
         {
-            this.score = score;
+            Score = score;
+
             this.sheared = sheared;
 
             Shear = sheared ? OsuGame.SHEAR : Vector2.Zero;
@@ -142,7 +145,6 @@ namespace osu.Game.Screens.SelectV2
             foregroundColour = colourProvider.Background5;
             backgroundColour = colourProvider.Background3;
             totalScoreBackgroundGradient = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), backgroundColour);
-            personalBestGradient = ColourInfo.GradientHorizontal(personal_best_gradient_left, personal_best_gradient_right);
 
             Child = new Container
             {
@@ -157,320 +159,327 @@ namespace osu.Game.Screens.SelectV2
                         RelativeSizeAxes = Axes.Both,
                         Colour = backgroundColour
                     },
-                    new GridContainer
+                    rankLabelStandalone = new Container
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        ColumnDimensions = new[]
+                        Width = rank_label_width,
+                        RelativeSizeAxes = Axes.Y,
+                        Children = new Drawable[]
                         {
-                            new Dimension(GridSizeMode.AutoSize),
-                            new Dimension(),
-                            new Dimension(GridSizeMode.AutoSize),
-                        },
-                        Content = new[]
-                        {
-                            new Drawable[]
+                            highlightGradient = new Container
                             {
-                                rankLabelStandalone = new Container
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Right = -10f },
+                                Alpha = Highlight != null ? 1 : 0,
+                                Colour = getHighlightColour(Highlight),
+                                Child = new Box { RelativeSizeAxes = Axes.Both },
+                            },
+                            new RankLabel(Rank, sheared, darkText: Highlight == HighlightType.Own)
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        },
+                    },
+                    centreContent = new Container
+                    {
+                        Name = @"Centre container",
+                        RelativeSizeAxes = Axes.Both,
+                        Child = new Container
+                        {
+                            Masking = true,
+                            CornerRadius = corner_radius,
+                            RelativeSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                foreground = new Box
                                 {
-                                    Width = rank_label_width,
-                                    RelativeSizeAxes = Axes.Y,
-                                    Children = new Drawable[]
+                                    Alpha = 0.4f,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = foregroundColour
+                                },
+                                new UserCoverBackground
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    User = Score.User,
+                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                    Anchor = Anchor.BottomLeft,
+                                    Origin = Anchor.BottomLeft,
+                                    Colour = ColourInfo.GradientHorizontal(Colour4.White.Opacity(0.5f), Colour4.FromHex(@"222A27").Opacity(1)),
+                                },
+                                new GridContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    ColumnDimensions = new[]
                                     {
-                                        personalBestIndicator = new Container
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(),
+                                        new Dimension(GridSizeMode.AutoSize),
+                                    },
+                                    Content = new[]
+                                    {
+                                        new Drawable[]
                                         {
-                                            RelativeSizeAxes = Axes.Both,
-                                            Padding = new MarginPadding { Right = -10f },
-                                            Alpha = IsPersonalBest ? 1 : 0,
-                                            Colour = personalBestGradient,
-                                            Child = new Box { RelativeSizeAxes = Axes.Both },
-                                        },
-                                        new RankLabel(Rank, sheared, darkText: IsPersonalBest)
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
+                                            new Container
+                                            {
+                                                AutoSizeAxes = Axes.Both,
+                                                CornerRadius = corner_radius,
+                                                Masking = true,
+                                                Children = new Drawable[]
+                                                {
+                                                    new DelayedLoadWrapper(innerAvatar = new ClickableAvatar(Score.User)
+                                                    {
+                                                        Anchor = Anchor.Centre,
+                                                        Origin = Anchor.Centre,
+                                                        Scale = new Vector2(1.1f),
+                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                        RelativeSizeAxes = Axes.Both,
+                                                    })
+                                                    {
+                                                        RelativeSizeAxes = Axes.None,
+                                                        Size = new Vector2(HEIGHT)
+                                                    },
+                                                    rankLabelOverlay = new Container
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Alpha = 0,
+                                                        Children = new Drawable[]
+                                                        {
+                                                            new Box
+                                                            {
+                                                                RelativeSizeAxes = Axes.Both,
+                                                                Colour = Colour4.Black.Opacity(0.5f),
+                                                            },
+                                                            new RankLabel(Rank, sheared, false)
+                                                            {
+                                                                AutoSizeAxes = Axes.Both,
+                                                                Anchor = Anchor.Centre,
+                                                                Origin = Anchor.Centre,
+                                                            },
+                                                        }
+                                                    }
+                                                },
+                                            },
+                                            new FillFlowContainer
+                                            {
+                                                Anchor = Anchor.CentreLeft,
+                                                Origin = Anchor.CentreLeft,
+                                                RelativeSizeAxes = Axes.X,
+                                                AutoSizeAxes = Axes.Y,
+                                                Direction = FillDirection.Vertical,
+                                                Padding = new MarginPadding { Horizontal = corner_radius },
+                                                Children = new Drawable[]
+                                                {
+                                                    new FillFlowContainer
+                                                    {
+                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                        Direction = FillDirection.Horizontal,
+                                                        Spacing = new Vector2(5),
+                                                        AutoSizeAxes = Axes.Both,
+                                                        Masking = true,
+                                                        Children = new Drawable[]
+                                                        {
+                                                            new UpdateableFlag(Score.User.CountryCode)
+                                                            {
+                                                                Anchor = Anchor.CentreLeft,
+                                                                Origin = Anchor.CentreLeft,
+                                                                Size = new Vector2(20, 14),
+                                                            },
+                                                            new UpdateableTeamFlag(Score.User.Team)
+                                                            {
+                                                                Anchor = Anchor.CentreLeft,
+                                                                Origin = Anchor.CentreLeft,
+                                                                Size = new Vector2(30, 15),
+                                                            },
+                                                            new DateLabel(Score.Date)
+                                                            {
+                                                                Anchor = Anchor.CentreLeft,
+                                                                Origin = Anchor.CentreLeft,
+                                                                Colour = colourProvider.Content2,
+                                                                UseFullGlyphHeight = false,
+                                                            }
+                                                        }
+                                                    },
+                                                    new TruncatingSpriteText
+                                                    {
+                                                        RelativeSizeAxes = Axes.X,
+                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                        Text = Score.User.Username,
+                                                        Font = OsuFont.Style.Heading2,
+                                                    }
+                                                }
+                                            },
+                                            new Container
+                                            {
+                                                AutoSizeAxes = Axes.Both,
+                                                Anchor = Anchor.CentreRight,
+                                                Origin = Anchor.CentreRight,
+                                                Child = statisticsContainer = new FillFlowContainer
+                                                {
+                                                    Name = @"Statistics container",
+                                                    Padding = new MarginPadding { Right = 10 },
+                                                    Spacing = new Vector2(20, 0),
+                                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                    Anchor = Anchor.CentreRight,
+                                                    Origin = Anchor.CentreRight,
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Direction = FillDirection.Horizontal,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new ScoreComponentLabel(BeatmapsetsStrings.ShowScoreboardHeadersCombo.ToUpper(), $"{Score.MaxCombo.ToString()}x",
+                                                            Score.MaxCombo == Score.GetMaximumAchievableCombo(), 60),
+                                                        new ScoreComponentLabel(BeatmapsetsStrings.ShowScoreboardHeadersAccuracy.ToUpper(), Score.DisplayAccuracy, Score.Accuracy == 1,
+                                                            55),
+                                                    },
+                                                    Alpha = 0,
+                                                }
+                                            }
                                         }
+                                    }
+                                },
+                            },
+                        },
+                    },
+                    rightContent = new Container
+                    {
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        Name = @"Right content",
+                        RelativeSizeAxes = Axes.Y,
+                        Child = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
+                            Children = new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding { Right = grade_width },
+                                    Child = new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(Score.Rank)),
+                                    },
+                                },
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Y,
+                                    Width = grade_width,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    Colour = OsuColour.ForRank(Score.Rank),
+                                },
+                                new TrianglesV2
+                                {
+                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    SpawnRatio = 2,
+                                    Velocity = 0.7f,
+                                    Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(Score.Rank).Darken(0.2f)),
+                                },
+                                new Container
+                                {
+                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                    RelativeSizeAxes = Axes.Y,
+                                    Width = grade_width,
+                                    Child = new OsuSpriteText
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Spacing = new Vector2(-2),
+                                        Colour = DrawableRank.GetRankNameColour(Score.Rank),
+                                        Font = OsuFont.Numeric.With(size: 14),
+                                        Text = DrawableRank.GetRankName(Score.Rank),
+                                        ShadowColour = Color4.Black.Opacity(0.3f),
+                                        ShadowOffset = new Vector2(0, 0.08f),
+                                        Shadow = true,
+                                        UseFullGlyphHeight = false,
                                     },
                                 },
                                 new Container
                                 {
-                                    Name = @"Centre container",
-                                    Masking = true,
-                                    CornerRadius = corner_radius,
                                     RelativeSizeAxes = Axes.Both,
-                                    Children = new Drawable[]
-                                    {
-                                        foreground = new Box
-                                        {
-                                            Alpha = 0.4f,
-                                            RelativeSizeAxes = Axes.Both,
-                                            Colour = foregroundColour
-                                        },
-                                        new UserCoverBackground
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            User = score.User,
-                                            Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                            Anchor = Anchor.BottomLeft,
-                                            Origin = Anchor.BottomLeft,
-                                            Colour = ColourInfo.GradientHorizontal(Colour4.White.Opacity(0.5f), Colour4.FromHex(@"222A27").Opacity(1)),
-                                        },
-                                        new GridContainer
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            ColumnDimensions = new[]
-                                            {
-                                                new Dimension(GridSizeMode.AutoSize),
-                                                new Dimension(),
-                                                new Dimension(GridSizeMode.AutoSize),
-                                            },
-                                            Content = new[]
-                                            {
-                                                new Drawable[]
-                                                {
-                                                    new Container
-                                                    {
-                                                        AutoSizeAxes = Axes.Both,
-                                                        CornerRadius = corner_radius,
-                                                        Masking = true,
-                                                        Children = new Drawable[]
-                                                        {
-                                                            new DelayedLoadWrapper(innerAvatar = new ClickableAvatar(score.User)
-                                                            {
-                                                                Anchor = Anchor.Centre,
-                                                                Origin = Anchor.Centre,
-                                                                Scale = new Vector2(1.1f),
-                                                                Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                                RelativeSizeAxes = Axes.Both,
-                                                            })
-                                                            {
-                                                                RelativeSizeAxes = Axes.None,
-                                                                Size = new Vector2(HEIGHT)
-                                                            },
-                                                            rankLabelOverlay = new Container
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                Alpha = 0,
-                                                                Children = new Drawable[]
-                                                                {
-                                                                    new Box
-                                                                    {
-                                                                        RelativeSizeAxes = Axes.Both,
-                                                                        Colour = Colour4.Black.Opacity(0.5f),
-                                                                    },
-                                                                    new RankLabel(Rank, sheared, false)
-                                                                    {
-                                                                        AutoSizeAxes = Axes.Both,
-                                                                        Anchor = Anchor.Centre,
-                                                                        Origin = Anchor.Centre,
-                                                                    },
-                                                                }
-                                                            }
-                                                        },
-                                                    },
-                                                    new FillFlowContainer
-                                                    {
-                                                        Anchor = Anchor.CentreLeft,
-                                                        Origin = Anchor.CentreLeft,
-                                                        RelativeSizeAxes = Axes.X,
-                                                        AutoSizeAxes = Axes.Y,
-                                                        Direction = FillDirection.Vertical,
-                                                        Padding = new MarginPadding { Horizontal = corner_radius },
-                                                        Children = new Drawable[]
-                                                        {
-                                                            new FillFlowContainer
-                                                            {
-                                                                Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                                Direction = FillDirection.Horizontal,
-                                                                Spacing = new Vector2(5),
-                                                                AutoSizeAxes = Axes.Both,
-                                                                Masking = true,
-                                                                Children = new Drawable[]
-                                                                {
-                                                                    new UpdateableFlag(score.User.CountryCode)
-                                                                    {
-                                                                        Anchor = Anchor.CentreLeft,
-                                                                        Origin = Anchor.CentreLeft,
-                                                                        Size = new Vector2(20, 14),
-                                                                    },
-                                                                    new UpdateableTeamFlag(score.User.Team)
-                                                                    {
-                                                                        Anchor = Anchor.CentreLeft,
-                                                                        Origin = Anchor.CentreLeft,
-                                                                        Size = new Vector2(30, 15),
-                                                                    },
-                                                                    new DateLabel(score.Date)
-                                                                    {
-                                                                        Anchor = Anchor.CentreLeft,
-                                                                        Origin = Anchor.CentreLeft,
-                                                                        Colour = colourProvider.Content2,
-                                                                        UseFullGlyphHeight = false,
-                                                                    }
-                                                                }
-                                                            },
-                                                            new TruncatingSpriteText
-                                                            {
-                                                                RelativeSizeAxes = Axes.X,
-                                                                Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                                Text = score.User.Username,
-                                                                Font = OsuFont.Style.Heading2,
-                                                            }
-                                                        }
-                                                    },
-                                                    new Container
-                                                    {
-                                                        AutoSizeAxes = Axes.Both,
-                                                        Anchor = Anchor.CentreRight,
-                                                        Origin = Anchor.CentreRight,
-                                                        Child = statisticsContainer = new FillFlowContainer
-                                                        {
-                                                            Name = @"Statistics container",
-                                                            Padding = new MarginPadding { Right = 10 },
-                                                            Spacing = new Vector2(20, 0),
-                                                            Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                            Anchor = Anchor.CentreRight,
-                                                            Origin = Anchor.CentreRight,
-                                                            AutoSizeAxes = Axes.Both,
-                                                            Direction = FillDirection.Horizontal,
-                                                            Children = getStatistics(score).Select(s => new ScoreComponentLabel(s, score)).ToList(),
-                                                            Alpha = 0,
-                                                        }
-                                                    }
-                                                }
-                                            },
-                                        },
-                                    },
-                                },
-                                rightContent = new Container
-                                {
-                                    Name = @"Right content",
-                                    RelativeSizeAxes = Axes.Y,
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Padding = new MarginPadding { Right = grade_width },
                                     Child = new Container
                                     {
                                         RelativeSizeAxes = Axes.Both,
-                                        Anchor = Anchor.TopRight,
-                                        Origin = Anchor.TopRight,
+                                        Masking = true,
+                                        CornerRadius = corner_radius,
                                         Children = new Drawable[]
                                         {
-                                            new Container
+                                            totalScoreBackground = new Box
                                             {
                                                 RelativeSizeAxes = Axes.Both,
-                                                Padding = new MarginPadding { Right = grade_width },
-                                                Child = new Box
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank)),
-                                                },
+                                                Colour = totalScoreBackgroundGradient,
                                             },
                                             new Box
-                                            {
-                                                RelativeSizeAxes = Axes.Y,
-                                                Width = grade_width,
-                                                Anchor = Anchor.TopRight,
-                                                Origin = Anchor.TopRight,
-                                                Colour = OsuColour.ForRank(score.Rank),
-                                            },
-                                            new TrianglesV2
                                             {
                                                 RelativeSizeAxes = Axes.Both,
-                                                Anchor = Anchor.TopRight,
-                                                Origin = Anchor.TopRight,
-                                                SpawnRatio = 2,
-                                                Velocity = 0.7f,
-                                                Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank).Darken(0.2f)),
+                                                Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(Score.Rank).Opacity(0.5f)),
                                             },
-                                            new Container
+                                            new FillFlowContainer
                                             {
-                                                Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                AutoSizeAxes = Axes.Both,
                                                 Anchor = Anchor.CentreRight,
                                                 Origin = Anchor.CentreRight,
-                                                RelativeSizeAxes = Axes.Y,
-                                                Width = grade_width,
-                                                Child = new OsuSpriteText
+                                                Direction = FillDirection.Vertical,
+                                                Padding = new MarginPadding { Horizontal = corner_radius },
+                                                Spacing = new Vector2(0f, -2f),
+                                                Children = new Drawable[]
                                                 {
-                                                    Anchor = Anchor.Centre,
-                                                    Origin = Anchor.Centre,
-                                                    Spacing = new Vector2(-2),
-                                                    Colour = DrawableRank.GetRankNameColour(score.Rank),
-                                                    Font = OsuFont.Numeric.With(size: 14),
-                                                    Text = DrawableRank.GetRankName(score.Rank),
-                                                    ShadowColour = Color4.Black.Opacity(0.3f),
-                                                    ShadowOffset = new Vector2(0, 0.08f),
-                                                    Shadow = true,
-                                                    UseFullGlyphHeight = false,
-                                                },
-                                            },
-                                            new Container
-                                            {
-                                                RelativeSizeAxes = Axes.Both,
-                                                Anchor = Anchor.CentreLeft,
-                                                Origin = Anchor.CentreLeft,
-                                                Padding = new MarginPadding { Right = grade_width },
-                                                Child = new Container
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Masking = true,
-                                                    CornerRadius = corner_radius,
-                                                    Children = new Drawable[]
+                                                    new OsuSpriteText
                                                     {
-                                                        totalScoreBackground = new Box
-                                                        {
-                                                            RelativeSizeAxes = Axes.Both,
-                                                            Colour = totalScoreBackgroundGradient,
-                                                        },
-                                                        new Box
-                                                        {
-                                                            RelativeSizeAxes = Axes.Both,
-                                                            Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank).Opacity(0.5f)),
-                                                        },
-                                                        new FillFlowContainer
-                                                        {
-                                                            AutoSizeAxes = Axes.Both,
-                                                            Anchor = Anchor.CentreRight,
-                                                            Origin = Anchor.CentreRight,
-                                                            Direction = FillDirection.Vertical,
-                                                            Padding = new MarginPadding { Horizontal = corner_radius },
-                                                            Spacing = new Vector2(0f, -2f),
-                                                            Children = new Drawable[]
-                                                            {
-                                                                new OsuSpriteText
-                                                                {
-                                                                    Anchor = Anchor.TopRight,
-                                                                    Origin = Anchor.TopRight,
-                                                                    UseFullGlyphHeight = false,
-                                                                    Current = scoreManager.GetBindableTotalScoreString(score),
-                                                                    Spacing = new Vector2(-1.5f),
-                                                                    Font = OsuFont.Style.Subtitle.With(weight: FontWeight.Light, fixedWidth: true),
-                                                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                                },
-                                                                new InputBlockingContainer
-                                                                {
-                                                                    Anchor = Anchor.TopRight,
-                                                                    Origin = Anchor.TopRight,
-                                                                    AutoSizeAxes = Axes.Both,
-                                                                    Child = modsContainer = new FillFlowContainer<Drawable>
-                                                                    {
-                                                                        AutoSizeAxes = Axes.Both,
-                                                                        Direction = FillDirection.Horizontal,
-                                                                        Spacing = new Vector2(-10, 0),
-                                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
-                                                                    },
-                                                                },
-                                                            }
-                                                        }
-                                                    }
+                                                        Anchor = Anchor.TopRight,
+                                                        Origin = Anchor.TopRight,
+                                                        UseFullGlyphHeight = false,
+                                                        Current = scoreManager.GetBindableTotalScoreString(Score),
+                                                        Spacing = new Vector2(-1.5f),
+                                                        Font = OsuFont.Style.Subtitle.With(weight: FontWeight.Light, fixedWidth: true),
+                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                    },
+                                                    modsContainer = new FillFlowContainer<Drawable>
+                                                    {
+                                                        Anchor = Anchor.TopRight,
+                                                        Origin = Anchor.TopRight,
+                                                        AutoSizeAxes = Axes.Both,
+                                                        Direction = FillDirection.Horizontal,
+                                                        Spacing = new Vector2(-10, 0),
+                                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
+                                                    },
                                                 }
                                             }
                                         }
-                                    },
+                                    }
                                 }
                             }
-                        }
+                        },
                     }
                 }
             };
-
             innerAvatar.OnLoadComplete += d => d.FadeInFromZero(200);
         }
 
+        private ColourInfo getHighlightColour(HighlightType? highlightType, float lightenAmount = 0)
+        {
+            switch (highlightType)
+            {
+                case HighlightType.Own:
+                    return ColourInfo.GradientHorizontal(personal_best_gradient_left.Lighten(lightenAmount), personal_best_gradient_right.Lighten(lightenAmount));
+
+                case HighlightType.Friend:
+                    return ColourInfo.GradientHorizontal(colours.Pink1.Lighten(lightenAmount), colours.Pink3.Lighten(lightenAmount));
+
+                default:
+                    return Colour4.White;
+            }
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -495,10 +504,10 @@ namespace osu.Game.Screens.SelectV2
 
         private void updateModDisplay()
         {
-            if (score.Mods.Length > 0)
+            if (Score.Mods.Length > 0)
             {
                 modsContainer.Padding = new MarginPadding { Top = 4f };
-                modsContainer.ChildrenEnumerable = score.Mods.AsOrdered().Select(mod => new ModIcon(mod)
+                modsContainer.ChildrenEnumerable = Score.Mods.AsOrdered().Select(mod => new ModIcon(mod)
                 {
                     Scale = new Vector2(0.3f),
                     // trim mod icon height down to its true height for alignment purposes.
@@ -528,12 +537,11 @@ namespace osu.Game.Screens.SelectV2
         private void updateState()
         {
             var lightenedGradient = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0).Lighten(0.2f), backgroundColour.Lighten(0.2f));
-            var personalBestLightenedGradient = ColourInfo.GradientHorizontal(personal_best_gradient_left.Lighten(0.2f), personal_best_gradient_right.Lighten(0.2f));
 
             foreground.FadeColour(IsHovered ? foregroundColour.Lighten(0.2f) : foregroundColour, transition_duration, Easing.OutQuint);
             background.FadeColour(IsHovered ? backgroundColour.Lighten(0.2f) : backgroundColour, transition_duration, Easing.OutQuint);
             totalScoreBackground.FadeColour(IsHovered ? lightenedGradient : totalScoreBackgroundGradient, transition_duration, Easing.OutQuint);
-            personalBestIndicator.FadeColour(IsHovered ? personalBestLightenedGradient : personalBestGradient, transition_duration, Easing.OutQuint);
+            highlightGradient.FadeColour(getHighlightColour(Highlight, IsHovered ? 0.2f : 0), transition_duration, Easing.OutQuint);
 
             if (IsHovered && currentMode != DisplayMode.Full)
                 rankLabelOverlay.FadeIn(transition_duration, Easing.OutQuint);
@@ -550,30 +558,39 @@ namespace osu.Game.Screens.SelectV2
             DisplayMode mode = getCurrentDisplayMode();
 
             if (currentMode != mode)
+                updateDisplayMode(mode);
+
+            centreContent.Padding = new MarginPadding
             {
-                double duration = currentMode == null ? 0 : transition_duration;
-                if (mode >= DisplayMode.Full)
-                    rankLabelStandalone.FadeIn(duration, Easing.OutQuint).ResizeWidthTo(rank_label_width, duration, Easing.OutQuint);
-                else
-                    rankLabelStandalone.FadeOut(duration, Easing.OutQuint).ResizeWidthTo(0, duration, Easing.OutQuint);
+                Left = rankLabelStandalone.DrawWidth,
+                Right = rightContent.DrawWidth,
+            };
+        }
 
-                if (mode >= DisplayMode.Regular)
-                {
-                    statisticsContainer.FadeIn(duration, Easing.OutQuint).MoveToX(0, duration, Easing.OutQuint);
-                    statisticsContainer.Direction = FillDirection.Horizontal;
-                    statisticsContainer.ScaleTo(1, duration, Easing.OutQuint);
-                }
-                else if (mode >= DisplayMode.Compact)
-                {
-                    statisticsContainer.FadeIn(duration, Easing.OutQuint).MoveToX(0, duration, Easing.OutQuint);
-                    statisticsContainer.Direction = FillDirection.Vertical;
-                    statisticsContainer.ScaleTo(0.8f, duration, Easing.OutQuint);
-                }
-                else
-                    statisticsContainer.FadeOut(duration, Easing.OutQuint).MoveToX(statisticsContainer.DrawWidth, duration, Easing.OutQuint);
+        private void updateDisplayMode(DisplayMode mode)
+        {
+            double duration = currentMode == null ? 0 : transition_duration;
+            if (mode >= DisplayMode.Full)
+                rankLabelStandalone.FadeIn(duration, Easing.OutQuint).ResizeWidthTo(rank_label_width, duration, Easing.OutQuint);
+            else
+                rankLabelStandalone.FadeOut(duration, Easing.OutQuint).ResizeWidthTo(0, duration, Easing.OutQuint);
 
-                currentMode = mode;
+            if (mode >= DisplayMode.Regular)
+            {
+                statisticsContainer.FadeIn(duration, Easing.OutQuint).MoveToX(0, duration, Easing.OutQuint);
+                statisticsContainer.Direction = FillDirection.Horizontal;
+                statisticsContainer.ScaleTo(1, duration, Easing.OutQuint);
             }
+            else if (mode >= DisplayMode.Compact)
+            {
+                statisticsContainer.FadeIn(duration, Easing.OutQuint).MoveToX(0, duration, Easing.OutQuint);
+                statisticsContainer.Direction = FillDirection.Vertical;
+                statisticsContainer.ScaleTo(0.8f, duration, Easing.OutQuint);
+            }
+            else
+                statisticsContainer.FadeOut(duration, Easing.OutQuint).MoveToX(statisticsContainer.DrawWidth, duration, Easing.OutQuint);
+
+            currentMode = mode;
         }
 
         private DisplayMode getCurrentDisplayMode()
@@ -592,7 +609,7 @@ namespace osu.Game.Screens.SelectV2
 
         ITooltip<ScoreInfo> IHasCustomTooltip<ScoreInfo>.GetCustomTooltip() => new LeaderboardScoreTooltip(colourProvider);
 
-        ScoreInfo IHasCustomTooltip<ScoreInfo>.TooltipContent => score;
+        ScoreInfo IHasCustomTooltip<ScoreInfo>.TooltipContent => Score;
 
         MenuItem[] IHasContextMenu.ContextMenuItems
         {
@@ -601,18 +618,18 @@ namespace osu.Game.Screens.SelectV2
                 List<MenuItem> items = new List<MenuItem>();
 
                 // system mods should never be copied across regardless of anything.
-                var copyableMods = score.Mods.Where(m => IsValidMod.Invoke(m) && m.Type != ModType.System).ToArray();
+                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));
 
-                if (score.OnlineID > 0)
-                    items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => clipboard?.SetText($@"{api.Endpoints.WebsiteUrl}/scores/{score.OnlineID}")));
+                if (Score.OnlineID > 0)
+                    items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => clipboard?.SetText($@"{api.Endpoints.WebsiteUrl}/scores/{Score.OnlineID}")));
 
-                if (score.Files.Count <= 0) return items.ToArray();
+                if (Score.Files.Count <= 0) return items.ToArray();
 
-                items.Add(new OsuMenuItem(CommonStrings.Export, MenuItemType.Standard, () => scoreManager.Export(score)));
-                items.Add(new OsuMenuItem(Resources.Localisation.Web.CommonStrings.ButtonsDelete, MenuItemType.Destructive, () => dialogOverlay?.Push(new LocalScoreDeleteDialog(score))));
+                items.Add(new OsuMenuItem(CommonStrings.Export, MenuItemType.Standard, () => scoreManager.Export(Score)));
+                items.Add(new OsuMenuItem(Resources.Localisation.Web.CommonStrings.ButtonsDelete, MenuItemType.Destructive, () => dialogOverlay?.Push(new LocalScoreDeleteDialog(Score))));
 
                 return items.ToArray();
             }
@@ -639,48 +656,50 @@ namespace osu.Game.Screens.SelectV2
 
         private partial class ScoreComponentLabel : Container
         {
-            private readonly (LocalisableString Name, LocalisableString Value) statisticInfo;
-            private readonly ScoreInfo score;
+            private readonly LocalisableString name;
+            private readonly LocalisableString value;
+            private readonly bool perfect;
+            private readonly float minWidth;
 
             private FillFlowContainer content = null!;
             public override bool Contains(Vector2 screenSpacePos) => content.Contains(screenSpacePos);
 
-            public ScoreComponentLabel((LocalisableString Name, LocalisableString Value) statisticInfo, ScoreInfo score)
+            public ScoreComponentLabel(LocalisableString name, LocalisableString value, bool perfect, float minWidth)
             {
-                this.statisticInfo = statisticInfo;
-                this.score = score;
+                this.name = name;
+                this.value = value;
+                this.perfect = perfect;
+                this.minWidth = minWidth;
             }
 
             [BackgroundDependencyLoader]
             private void load(OsuColour colours, OverlayColourProvider colourProvider)
             {
                 AutoSizeAxes = Axes.Both;
-                OsuSpriteText value;
                 Child = content = new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Vertical,
-                    Children = new Drawable[]
+                    Children = new[]
                     {
                         new OsuSpriteText
                         {
                             Colour = colourProvider.Content2,
-                            Text = statisticInfo.Name,
+                            Text = name,
                             Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold),
                         },
-                        value = new OsuSpriteText
+                        new OsuSpriteText
                         {
                             // We don't want the value setting the horizontal size, since it leads to wonky accuracy container length,
                             // since the accuracy is sometimes longer than its name.
                             BypassAutoSizeAxes = Axes.X,
-                            Text = statisticInfo.Value,
+                            Text = value,
                             Font = OsuFont.Style.Body,
-                        }
+                            Colour = perfect ? colours.Lime1 : Color4.White,
+                        },
+                        Empty().With(d => d.Width = minWidth),
                     }
                 };
-
-                if (score.Combo != score.MaxCombo && statisticInfo.Name == BeatmapsetsStrings.ShowScoreboardHeadersCombo)
-                    value.Colour = colours.Lime1;
             }
         }
 
@@ -714,5 +733,11 @@ namespace osu.Game.Screens.SelectV2
 
             public LocalisableString TooltipText { get; }
         }
+
+        public enum HighlightType
+        {
+            Own,
+            Friend,
+        }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs
index c6fe1e5f25..1f92699887 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs
@@ -1,8 +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;
+using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
@@ -12,9 +17,13 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Localisation;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Localisation;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Resources.Localisation.Web;
@@ -88,21 +97,28 @@ namespace osu.Game.Screens.SelectV2
                 private DrawableDate relativeDate = null!;
                 private FillFlowContainer statistics = null!;
 
+                private readonly Bindable<bool> prefer24HourTime = new Bindable<bool>();
+
                 [Resolved]
                 private OsuColour colours { get; set; } = null!;
 
                 [Resolved]
                 private OverlayColourProvider colourProvider { get; set; } = null!;
 
+                private ScoreInfo score = null!;
+
                 public ScoreInfo Score
                 {
+                    get => score;
                     set
                     {
-                        absoluteDate.Text = value.Date.ToLocalisableString(@"dd MMMM yyyy h:mm tt");
+                        score = value;
+
+                        updateAbsoluteDate();
                         relativeDate.Date = value.Date;
 
                         var judgementsStatistics = value.GetStatisticsForDisplay().Select(s =>
-                            new StatisticRow(s.DisplayName.ToUpper(), colours.ForHitResult(s.Result), s.Count.ToLocalisableString("N0")));
+                            new StatisticRow(s.DisplayName.ToUpper(), s.Count.ToLocalisableString("N0"), colours.ForHitResult(s.Result)));
 
                         double multiplier = 1.0;
 
@@ -111,19 +127,13 @@ namespace osu.Game.Screens.SelectV2
 
                         var generalStatistics = new[]
                         {
-                            new StatisticRow("Score Multiplier", colourProvider.Content2, ModUtils.FormatScoreMultiplier(multiplier)),
-                            new StatisticRow(BeatmapsetsStrings.ShowScoreboardHeadersCombo, colourProvider.Content2, value.MaxCombo.ToLocalisableString(@"0\x")),
-                            new StatisticRow(BeatmapsetsStrings.ShowScoreboardHeadersAccuracy, colourProvider.Content2, value.Accuracy.FormatAccuracy()),
+                            new StatisticRow(BeatmapsetsStrings.ShowScoreboardHeadersCombo, value.MaxCombo.ToLocalisableString(@"0\x")),
+                            new StatisticRow(BeatmapsetsStrings.ShowScoreboardHeadersAccuracy, value.Accuracy.FormatAccuracy()),
+                            new PerformanceStatisticRow(BeatmapsetsStrings.ShowScoreboardHeaderspp.ToUpper(), score),
+                            Empty().With(d => d.Height = 20),
+                            new StatisticRow(ModSelectOverlayStrings.ScoreMultiplier, ModUtils.FormatScoreMultiplier(multiplier)),
                         };
 
-                        if (value.PP != null)
-                        {
-                            generalStatistics = new[]
-                            {
-                                new StatisticRow(BeatmapsetsStrings.ShowScoreboardHeaderspp.ToUpper(), colourProvider.Content2, value.PP.ToLocalisableString("N0"))
-                            }.Concat(generalStatistics).ToArray();
-                        }
-
                         statistics.ChildrenEnumerable = judgementsStatistics
                                                         .Append(Empty().With(d => d.Height = 20))
                                                         .Concat(generalStatistics);
@@ -131,7 +141,7 @@ namespace osu.Game.Screens.SelectV2
                 }
 
                 [BackgroundDependencyLoader]
-                private void load()
+                private void load(OsuConfigManager configManager)
                 {
                     RelativeSizeAxes = Axes.X;
                     AutoSizeAxes = Axes.Y;
@@ -197,7 +207,7 @@ namespace osu.Game.Screens.SelectV2
                                         {
                                             RelativeSizeAxes = Axes.X,
                                             AutoSizeAxes = Axes.Y,
-                                            Spacing = new Vector2(0f, 4f),
+                                            Spacing = new Vector2(0f, 2f),
                                             Padding = new MarginPadding(8f),
                                         },
                                     },
@@ -205,25 +215,43 @@ namespace osu.Game.Screens.SelectV2
                             },
                         },
                     };
+
+                    configManager.BindWith(OsuSetting.Prefer24HourTime, prefer24HourTime);
                 }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+
+                    prefer24HourTime.BindValueChanged(_ => updateAbsoluteDate(), true);
+                }
+
+                private void updateAbsoluteDate()
+                    => absoluteDate.Text = score.Date.ToLocalTime().ToLocalisableString(prefer24HourTime.Value ? @"d MMMM yyyy HH:mm" : @"d MMMM yyyy h:mm tt");
             }
 
-            private partial class StatisticRow : CompositeDrawable
+            public partial class StatisticRow : CompositeDrawable
             {
-                public StatisticRow(LocalisableString label, Color4 labelColour, LocalisableString value)
+                private readonly OsuSpriteText labelText;
+                protected readonly OsuSpriteText ValueText;
+
+                private readonly Color4? colour;
+
+                public StatisticRow(LocalisableString label, LocalisableString value, Color4? colour = null)
                 {
+                    this.colour = colour;
+
                     RelativeSizeAxes = Axes.X;
                     AutoSizeAxes = Axes.Y;
 
                     InternalChildren = new[]
                     {
-                        new OsuSpriteText
+                        labelText = new OsuSpriteText
                         {
                             Text = label,
-                            Colour = labelColour,
                             Font = OsuFont.Style.Caption2.With(weight: FontWeight.SemiBold),
                         },
-                        new OsuSpriteText
+                        ValueText = new OsuSpriteText
                         {
                             Anchor = Anchor.TopRight,
                             Origin = Anchor.TopRight,
@@ -233,6 +261,69 @@ namespace osu.Game.Screens.SelectV2
                         },
                     };
                 }
+
+                [BackgroundDependencyLoader]
+                private void load(OverlayColourProvider colourProvider)
+                {
+                    labelText.Colour = colour ?? colourProvider.Content2;
+                    ValueText.Colour = Interpolation.ValueAt(0.85f, colourProvider.Content1, colour ?? colourProvider.Content1, 0, 1);
+                }
+            }
+
+            public partial class PerformanceStatisticRow : StatisticRow
+            {
+                private readonly ScoreInfo score;
+
+                public PerformanceStatisticRow(LocalisableString label, ScoreInfo score)
+                    : base(label, @"0pp")
+                {
+                    this.score = score;
+                }
+
+                [BackgroundDependencyLoader]
+                private void load(BeatmapDifficultyCache difficultyCache, CancellationToken? cancellationToken)
+                {
+                    if (score.PP.HasValue)
+                    {
+                        setPerformanceValue(score, score.PP.Value);
+                        return;
+                    }
+
+                    Task.Run(async () =>
+                    {
+                        var attributes = await difficultyCache.GetDifficultyAsync(score.BeatmapInfo!, score.Ruleset, score.Mods, cancellationToken ?? default).ConfigureAwait(false);
+                        var performanceCalculator = score.Ruleset.CreateInstance().CreatePerformanceCalculator();
+
+                        // Performance calculation requires the beatmap and ruleset to be locally available. If not, return a default value.
+                        if (attributes?.DifficultyAttributes == null || performanceCalculator == null)
+                            return;
+
+                        var result = await performanceCalculator.CalculateAsync(score, attributes.Value.DifficultyAttributes, cancellationToken ?? CancellationToken.None).ConfigureAwait(false);
+
+                        Schedule(() => setPerformanceValue(score, result.Total));
+                    }, cancellationToken ?? default);
+                }
+
+                private void setPerformanceValue(ScoreInfo scoreInfo, double pp)
+                {
+                    int ppValue = (int)Math.Round(pp, MidpointRounding.AwayFromZero);
+                    ValueText.Text = LocalisableString.Interpolate(@$"{ppValue:N0}pp");
+
+                    if (!scoreInfo.BeatmapInfo!.Status.GrantsPerformancePoints() || hasUnrankedMods(scoreInfo))
+                        Alpha = 0.5f;
+                    else
+                        Alpha = 1f;
+                }
+
+                private static bool hasUnrankedMods(ScoreInfo scoreInfo)
+                {
+                    IEnumerable<Mod> modsToCheck = scoreInfo.Mods;
+
+                    if (scoreInfo.IsLegacyScore)
+                        modsToCheck = modsToCheck.Where(m => m is not ModClassic);
+
+                    return modsToCheck.Any(m => !m.Ranked);
+                }
             }
 
             private partial class ModsPanel : CompositeDrawable
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
index e3d52adef5..11e1f281e5 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardWedge.cs
@@ -14,6 +14,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
@@ -21,6 +23,7 @@ using osu.Game.Graphics.Cursor;
 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.Online.Placeholders;
 using osu.Game.Overlays;
@@ -59,6 +62,9 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private ISongSelect? songSelect { get; set; }
 
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
         private Container<Placeholder> placeholderContainer = null!;
         private Placeholder? placeholder;
 
@@ -75,7 +81,14 @@ namespace osu.Game.Screens.SelectV2
 
         private readonly IBindable<LeaderboardScores?> fetchedScores = new Bindable<LeaderboardScores?>();
 
-        private const float personal_best_height = 100;
+        private const float personal_best_height = 112;
+
+        // Blocking mouse down is required to avoid song select's background reveal logic happening while hovering scores.
+        // Our horizontal alignment doesn't really align with the rest of the sheared components (protrudes a touch to the right) which makes
+        // it complicated to handle this at a higher level.
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => scoresScroll.ReceivePositionalInputAt(screenSpacePos);
+
+        protected override bool OnMouseDown(MouseDownEvent e) => true;
 
         [BackgroundDependencyLoader]
         private void load()
@@ -192,6 +205,8 @@ namespace osu.Game.Screens.SelectV2
 
         private bool initialFetchComplete;
 
+        private ScheduledDelegate? refetchOperation;
+
         private void refetchScores()
         {
             SetScores(Array.Empty<ScoreInfo>());
@@ -204,21 +219,26 @@ namespace osu.Game.Screens.SelectV2
 
             SetState(LeaderboardState.Retrieving);
 
-            var fetchBeatmapInfo = beatmap.Value.BeatmapInfo;
-            var fetchRuleset = ruleset.Value ?? fetchBeatmapInfo.Ruleset;
-
-            // 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), forceRefresh: true);
-
-            if (!initialFetchComplete)
+            refetchOperation?.Cancel();
+            refetchOperation = Scheduler.AddDelayed(() =>
             {
-                // only bind this after the first fetch to avoid reading stale scores.
-                fetchedScores.BindTo(leaderboardManager.Scores);
-                fetchedScores.BindValueChanged(_ => updateScores(), true);
-                initialFetchComplete = true;
-            }
+                var fetchBeatmapInfo = beatmap.Value.BeatmapInfo;
+                var fetchRuleset = ruleset.Value ?? fetchBeatmapInfo.Ruleset;
+
+                // 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),
+                    forceRefresh: true);
+
+                if (!initialFetchComplete)
+                {
+                    // only bind this after the first fetch to avoid reading stale scores.
+                    fetchedScores.BindTo(leaderboardManager.Scores);
+                    fetchedScores.BindValueChanged(_ => updateScores(), true);
+                    initialFetchComplete = true;
+                }
+            }, initialFetchComplete ? 300 : 0);
         }
 
         private void updateScores()
@@ -247,12 +267,22 @@ namespace osu.Game.Screens.SelectV2
                 return;
             }
 
-            LoadComponentsAsync(scores.Select((s, i) => new BeatmapLeaderboardScore(s)
+            LoadComponentsAsync(scores.Select((s, i) =>
             {
-                Rank = i + 1,
-                IsPersonalBest = s.OnlineID == userScore?.OnlineID,
-                SelectedMods = { BindTarget = mods },
-                Action = () => onLeaderboardScoreClicked(s),
+                BeatmapLeaderboardScore.HighlightType? highlightType = null;
+
+                if (s.OnlineID == userScore?.OnlineID)
+                    highlightType = BeatmapLeaderboardScore.HighlightType.Own;
+                else if (api.Friends.Any(r => r.TargetID == s.UserID) && Scope.Value != BeatmapLeaderboardScope.Friend)
+                    highlightType = BeatmapLeaderboardScore.HighlightType.Friend;
+
+                return new BeatmapLeaderboardScore(s)
+                {
+                    Rank = i + 1,
+                    Highlight = highlightType,
+                    SelectedMods = { BindTarget = mods },
+                    Action = () => onLeaderboardScoreClicked(s),
+                };
             }), loadedScores =>
             {
                 int delay = 200;
@@ -285,7 +315,7 @@ namespace osu.Game.Screens.SelectV2
                 personalBestDisplay.FadeIn(600, Easing.OutQuint);
                 personalBestScoreContainer.Child = new BeatmapLeaderboardScore(userScore)
                 {
-                    IsPersonalBest = true,
+                    Highlight = BeatmapLeaderboardScore.HighlightType.Own,
                     Rank = userScore.Position,
                     SelectedMods = { BindTarget = mods },
                     Action = () => onLeaderboardScoreClicked(userScore),
@@ -367,8 +397,7 @@ namespace osu.Game.Screens.SelectV2
             float fadeBottom = (float)(scoresScroll.Current + scoresScroll.DrawHeight);
             float fadeTop = (float)(scoresScroll.Current);
 
-            if (!scoresScroll.IsScrolledToStart())
-                fadeTop += height;
+            fadeTop += (float)Math.Min(height, Math.Log10(Math.Max(fadeTop, 0) + 1) * height);
 
             foreach (var c in scoresContainer)
             {
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs
index ffd1418796..8d1dd105a3 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.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.Allocation;
@@ -9,11 +10,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 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;
 
 namespace osu.Game.Screens.SelectV2
@@ -54,7 +57,7 @@ namespace osu.Game.Screens.SelectV2
         private ILinkHandler? linkHandler { get; set; }
 
         [Resolved]
-        private SongSelect? songSelect { get; set; }
+        private ISongSelect? songSelect { get; set; }
 
         [BackgroundDependencyLoader]
         private void load()
@@ -124,8 +127,8 @@ namespace osu.Game.Screens.SelectV2
                                                             Spacing = new Vector2(0f, 10f),
                                                             Children = new[]
                                                             {
-                                                                creator = new MetadataDisplay("Creator"),
-                                                                genre = new MetadataDisplay("Genre"),
+                                                                creator = new MetadataDisplay(EditorSetupStrings.Creator),
+                                                                genre = new MetadataDisplay(BeatmapsetsStrings.ShowInfoGenre),
                                                             },
                                                         },
                                                         new FillFlowContainer
@@ -136,8 +139,8 @@ namespace osu.Game.Screens.SelectV2
                                                             Spacing = new Vector2(0f, 10f),
                                                             Children = new[]
                                                             {
-                                                                source = new MetadataDisplay("Source"),
-                                                                language = new MetadataDisplay("Language"),
+                                                                source = new MetadataDisplay(BeatmapsetsStrings.ShowInfoSource),
+                                                                language = new MetadataDisplay(BeatmapsetsStrings.ShowInfoLanguage),
                                                             },
                                                         },
                                                         new FillFlowContainer
@@ -148,18 +151,18 @@ namespace osu.Game.Screens.SelectV2
                                                             Spacing = new Vector2(0f, 10f),
                                                             Children = new[]
                                                             {
-                                                                submitted = new MetadataDisplay("Submitted"),
-                                                                ranked = new MetadataDisplay("Ranked"),
+                                                                submitted = new MetadataDisplay(SongSelectStrings.Submitted),
+                                                                ranked = new MetadataDisplay(SongSelectStrings.Ranked),
                                                             },
                                                         },
                                                     },
                                                 },
                                             },
-                                            userTags = new MetadataDisplay("User Tags")
+                                            userTags = new MetadataDisplay(BeatmapsetsStrings.ShowInfoUserTags)
                                             {
                                                 Alpha = 0,
                                             },
-                                            mapperTags = new MetadataDisplay("Mapper Tags"),
+                                            mapperTags = new MetadataDisplay(BeatmapsetsStrings.ShowInfoMapperTags),
                                         },
                                     },
                                 },
@@ -296,7 +299,11 @@ namespace osu.Game.Screens.SelectV2
             else
                 source.Data = ("-", null);
 
-            mapperTags.Tags = (metadata.Tags.Split(' '), t => songSelect?.Search(t));
+            if (!string.IsNullOrEmpty(metadata.Tags))
+                mapperTags.Tags = (metadata.Tags.Split(' '), t => songSelect?.Search(t));
+            else
+                mapperTags.Tags = (Array.Empty<string>(), _ => { });
+
             submitted.Date = beatmapSetInfo.DateSubmitted;
             ranked.Date = beatmapSetInfo.DateRanked;
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
index bd3bb4dabb..683cd428e9 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
@@ -133,7 +133,7 @@ namespace osu.Game.Screens.SelectV2
                 private OverlayColourProvider colourProvider { get; set; } = null!;
 
                 [Resolved]
-                private SongSelect? songSelect { get; set; }
+                private ISongSelect? songSelect { get; set; }
 
                 public float LineBaseHeight => text.LineBaseHeight;
 
@@ -194,9 +194,9 @@ namespace osu.Game.Screens.SelectV2
             public partial class TagsOverflowPopover : OsuPopover
             {
                 private readonly string[] tags;
-                private readonly SongSelect? songSelect;
+                private readonly ISongSelect? songSelect;
 
-                public TagsOverflowPopover(string[] tags, SongSelect? songSelect)
+                public TagsOverflowPopover(string[] tags, ISongSelect? songSelect)
                 {
                     this.tags = tags;
                     this.songSelect = songSelect;
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
index a73fc78771..6b80fc69c9 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.cs
@@ -64,7 +64,7 @@ namespace osu.Game.Screens.SelectV2
         private Statistic bpmStatistic = null!;
 
         [Resolved]
-        private SongSelect? songSelect { get; set; }
+        private ISongSelect? songSelect { get; set; }
 
         [Resolved]
         private LocalisationManager localisation { get; set; } = null!;
@@ -147,7 +147,8 @@ namespace osu.Game.Screens.SelectV2
                         new ShearAligningWrapper(statisticsFlow = new FillFlowContainer
                         {
                             Shear = -OsuGame.SHEAR,
-                            AutoSizeAxes = Axes.Both,
+                            AutoSizeAxes = Axes.X,
+                            Height = 30,
                             Direction = FillDirection.Horizontal,
                             Spacing = new Vector2(2f, 0f),
                             Children = new Drawable[]
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
index 734d768241..7c7c3872cd 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
@@ -24,7 +24,6 @@ using osu.Game.Online;
 using osu.Game.Online.Chat;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Utils;
@@ -96,7 +95,7 @@ namespace osu.Game.Screens.SelectV2
                                 Shear = -OsuGame.SHEAR,
                                 AlwaysPresent = true,
                                 RelativeSizeAxes = Axes.X,
-                                AutoSizeAxes = Axes.Y,
+                                Height = 20,
                                 Margin = new MarginPadding { Vertical = 5f },
                                 Padding = new MarginPadding { Left = SongSelect.WEDGE_CONTENT_MARGIN },
                                 RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
@@ -159,7 +158,7 @@ namespace osu.Game.Screens.SelectV2
                             {
                                 Shear = -OsuGame.SHEAR,
                                 RelativeSizeAxes = Axes.X,
-                                AutoSizeAxes = Axes.Y,
+                                Height = 53,
                                 Padding = new MarginPadding { Bottom = border_weight, Right = border_weight },
                                 Child = new Container
                                 {
@@ -322,20 +321,20 @@ namespace osu.Game.Screens.SelectV2
                         // - Using the difficulty adjustment mod to adjust OD doesn't have an effect on conversion.
                         int keyCount = legacyRuleset.GetKeyCount(beatmap.Value.BeatmapInfo, mods.Value);
 
-                        firstStatistic = new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsCsMania, keyCount, keyCount, 10);
+                        firstStatistic = new StatisticDifficulty.Data(SongSelectStrings.KeyCount, keyCount, keyCount, 10);
                         break;
 
                     default:
-                        firstStatistic = new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsCs, originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
+                        firstStatistic = new StatisticDifficulty.Data(SongSelectStrings.CircleSize, originalDifficulty.CircleSize, adjustedDifficulty.CircleSize, 10);
                         break;
                 }
 
                 difficultyStatisticsDisplay.Statistics = new[]
                 {
                     firstStatistic,
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsAr, originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate, 10),
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsAccuracy, originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10),
-                    new StatisticDifficulty.Data(BeatmapsetsStrings.ShowStatsDrain, originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.ApproachRate, originalDifficulty.ApproachRate, adjustedDifficulty.ApproachRate, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.Accuracy, originalDifficulty.OverallDifficulty, adjustedDifficulty.OverallDifficulty, 10),
+                    new StatisticDifficulty.Data(SongSelectStrings.HPDrain, originalDifficulty.DrainRate, adjustedDifficulty.DrainRate, 10),
                 };
             });
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
index a185448f36..365ed9977b 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
@@ -137,7 +137,7 @@ namespace osu.Game.Screens.SelectV2
                     return;
 
                 float flowWidth = statisticsFlow[0].Width * statisticsFlow.Count + statisticsFlow.Spacing.X * (statisticsFlow.Count - 1);
-                bool tiny = !autoSize && DrawWidth < flowWidth;
+                bool tiny = !autoSize && DrawWidth < flowWidth - 20;
 
                 if (displayedTinyStatistics != tiny)
                 {
@@ -179,7 +179,11 @@ namespace osu.Game.Screens.SelectV2
                 }
                 else
                 {
-                    statisticsFlow.ChildrenEnumerable = statistics.Select(d => new StatisticDifficulty { Value = d });
+                    statisticsFlow.ChildrenEnumerable = statistics.Select(d => new StatisticDifficulty
+                    {
+                        AccentColour = accentColour,
+                        Value = d
+                    });
                     updateStatisticsSizing();
                 }
             }
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
index b533d21c1e..d0b6acca88 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
@@ -98,10 +98,11 @@ namespace osu.Game.Screens.SelectV2
                                 },
                             },
                         },
-                        labelText = new OsuSpriteText
+                        labelText = new TruncatingSpriteText
                         {
                             Margin = new MarginPadding { Top = 2f },
                             Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
+                            MaxWidth = 85,
                         },
                         new FillFlowContainer
                         {
diff --git a/osu.Game/Screens/SelectV2/FilterControl.cs b/osu.Game/Screens/SelectV2/FilterControl.cs
index 05429c2c12..fdc61ad37e 100644
--- a/osu.Game/Screens/SelectV2/FilterControl.cs
+++ b/osu.Game/Screens/SelectV2/FilterControl.cs
@@ -31,7 +31,7 @@ namespace osu.Game.Screens.SelectV2
         // taken from draw visualiser. used for carousel alignment purposes.
         public const float HEIGHT_FROM_SCREEN_TOP = 141 - corner_radius;
 
-        private const float corner_radius = 8;
+        private const float corner_radius = 10;
 
         private SongSelectSearchTextBox searchTextBox = null!;
         private ShearedToggleButton showConvertedBeatmapsButton = null!;
@@ -269,7 +269,7 @@ namespace osu.Game.Screens.SelectV2
                 .FadeOut(SongSelect.ENTER_DURATION / 3, Easing.In);
         }
 
-        private partial class SongSelectSearchTextBox : ShearedFilterTextBox
+        internal partial class SongSelectSearchTextBox : ShearedFilterTextBox
         {
             protected override InnerSearchTextBox CreateInnerTextBox() => new InnerTextBox();
 
@@ -279,6 +279,10 @@ namespace osu.Game.Screens.SelectV2
 
                 public override bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
                 {
+                    // Conflicts with default group navigation keys (shift-left shift-right).
+                    if (e.Action == PlatformAction.SelectBackwardChar || e.Action == PlatformAction.SelectForwardChar)
+                        return false;
+
                     // the "cut" platform key binding (shift-delete) conflicts with the beatmap deletion action.
                     if (e.Action == PlatformAction.Cut && e.ShiftPressed && e.CurrentState.Keyboard.Keys.IsPressed(Key.Delete))
                         return false;
diff --git a/osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs b/osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs
index 58c9c60460..f65c17bddf 100644
--- a/osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs
+++ b/osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs
@@ -5,15 +5,18 @@ using System;
 using System.Linq;
 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;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Layout;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Overlays;
+using osu.Game.Resources.Localisation.Web;
 using osu.Game.Utils;
 using osuTK.Graphics;
 
@@ -32,13 +35,10 @@ namespace osu.Game.Screens.SelectV2
                                                                           .Prepend((0.0f, OsuColour.STAR_DIFFICULTY_SPECTRUM.ElementAt(1).Item2)).ToArray();
 
             public DifficultyRangeSlider()
-                : base("Star Rating")
+                : base(BeatmapsetsStrings.ShowStatsStars)
             {
                 NubWidth = ShearedNub.HEIGHT * 1.16f;
-                TooltipSuffix = "stars";
-                DefaultStringLowerBound = "0.0";
                 DefaultStringUpperBound = "∞";
-                DefaultTooltipUpperBound = UserInterfaceStrings.NoLimit;
 
                 AddLayout(drawSizeLayout);
             }
@@ -125,6 +125,17 @@ namespace osu.Game.Screens.SelectV2
 
                 protected override bool FocusIndicator => false;
 
+                public override LocalisableString TooltipText
+                {
+                    get
+                    {
+                        if (Current.IsDefault && isUpper)
+                            return UserInterfaceStrings.NoLimit;
+
+                        return SongSelectStrings.Stars(Current.Value.ToLocalisableString(@"0.##"));
+                    }
+                }
+
                 public DifficultyBoundSliderBar(ShearedRangeSlider slider, bool isUpper)
                     : base(slider, isUpper)
                 {
diff --git a/osu.Game/Screens/SelectV2/FooterButtonMods.cs b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
index 9e2b53012a..9de06988a5 100644
--- a/osu.Game/Screens/SelectV2/FooterButtonMods.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
@@ -52,10 +52,13 @@ namespace osu.Game.Screens.SelectV2
         private Drawable unrankedBadge = null!;
 
         private ModDisplay modDisplay = null!;
-        private OsuSpriteText modCountText = null!;
 
         private OsuSpriteText multiplierText { get; set; } = null!;
 
+        private Container modContainer = null!;
+
+        private ModCountText overflowModCountDisplay = null!;
+
         [Resolved]
         private OsuColour colours { get; set; } = null!;
 
@@ -83,7 +86,7 @@ namespace osu.Game.Screens.SelectV2
                     Depth = float.MaxValue,
                     Origin = Anchor.BottomLeft,
                     Shear = OsuGame.SHEAR,
-                    CornerRadius = Y_OFFSET,
+                    CornerRadius = CORNER_RADIUS,
                     Size = new Vector2(BUTTON_WIDTH, bar_height),
                     Masking = true,
                     EdgeEffect = new EdgeEffectParameters
@@ -117,9 +120,9 @@ namespace osu.Game.Screens.SelectV2
                                 Font = OsuFont.Torus.With(size: 14f, weight: FontWeight.Bold)
                             }
                         },
-                        new Container
+                        modContainer = new Container
                         {
-                            CornerRadius = Y_OFFSET,
+                            CornerRadius = CORNER_RADIUS,
                             RelativeSizeAxes = Axes.Both,
                             Width = mod_display_portion,
                             Masking = true,
@@ -130,7 +133,7 @@ namespace osu.Game.Screens.SelectV2
                                     Colour = colourProvider.Background3,
                                     RelativeSizeAxes = Axes.Both,
                                 },
-                                modDisplay = new ModDisplay(showExtendedInformation: false)
+                                modDisplay = new ModDisplay(showExtendedInformation: true)
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
@@ -139,14 +142,7 @@ namespace osu.Game.Screens.SelectV2
                                     Current = { BindTarget = Current },
                                     ExpansionMode = ExpansionMode.AlwaysContracted,
                                 },
-                                modCountText = new ModCountText
-                                {
-                                    Anchor = Anchor.Centre,
-                                    Origin = Anchor.Centre,
-                                    Shear = -OsuGame.SHEAR,
-                                    Font = OsuFont.Torus.With(size: 14f, weight: FontWeight.Bold),
-                                    Mods = { BindTarget = Current },
-                                }
+                                overflowModCountDisplay = new ModCountText { Mods = { BindTarget = Current }, },
                             }
                         },
                     }
@@ -198,7 +194,7 @@ namespace osu.Game.Screens.SelectV2
                 modDisplayBar.MoveToY(20, duration, easing);
                 modDisplayBar.FadeOut(duration, easing);
                 modDisplay.FadeOut(duration, easing);
-                modCountText.FadeOut(duration, easing);
+                overflowModCountDisplay.FadeOut(duration, easing);
 
                 unrankedBadge.MoveToY(20, duration, easing);
                 unrankedBadge.FadeOut(duration, easing);
@@ -208,14 +204,6 @@ namespace osu.Game.Screens.SelectV2
             }
             else
             {
-                modDisplay.Hide();
-                modCountText.Hide();
-
-                if (Current.Value.Count >= 5)
-                    modCountText.Show();
-                else
-                    modDisplay.Show();
-
                 if (Current.Value.Any(m => !m.Ranked))
                 {
                     unrankedBadge.MoveToX(0, duration, easing);
@@ -234,6 +222,7 @@ namespace osu.Game.Screens.SelectV2
                 modDisplayBar.MoveToY(-5, duration, Easing.OutQuint);
                 unrankedBadge.MoveToY(-5, duration, easing);
                 modDisplayBar.FadeIn(duration, easing);
+                modDisplay.FadeIn(duration, easing);
             }
 
             double multiplier = Current.Value?.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier) ?? 1;
@@ -247,17 +236,52 @@ namespace osu.Game.Screens.SelectV2
                 multiplierText.FadeColour(Color4.White, duration, easing);
         }
 
-        private partial class ModCountText : OsuSpriteText, IHasCustomTooltip<IReadOnlyList<Mod>>
+        protected override void Update()
+        {
+            base.Update();
+
+            if (Current.Value.Count == 0)
+                return;
+
+            if (modDisplay.DrawWidth * modDisplay.Scale.X > modContainer.DrawWidth)
+                overflowModCountDisplay.Show();
+            else
+                overflowModCountDisplay.Hide();
+        }
+
+        private partial class ModCountText : CompositeDrawable, IHasCustomTooltip<IReadOnlyList<Mod>>
         {
             public readonly Bindable<IReadOnlyList<Mod>> Mods = new Bindable<IReadOnlyList<Mod>>();
 
+            private OsuSpriteText text = null!;
+
             [Resolved]
             private OverlayColourProvider colourProvider { get; set; } = null!;
 
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                Mods.BindValueChanged(v => Text = ModSelectOverlayStrings.Mods(v.NewValue.Count).ToUpper(), true);
+
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = colourProvider.Background3,
+                        Alpha = 0.8f,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    text = new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = OsuFont.Torus.With(size: 14f, weight: FontWeight.Bold),
+                        Shear = -OsuGame.SHEAR,
+                    }
+                };
+
+                Mods.BindValueChanged(v => text.Text = ModSelectOverlayStrings.Mods(v.NewValue.Count).ToUpper(), true);
             }
 
             public ITooltip<IReadOnlyList<Mod>> GetCustomTooltip() => new ModOverflowTooltip(colourProvider);
@@ -280,7 +304,7 @@ namespace osu.Game.Screens.SelectV2
                 private void load()
                 {
                     AutoSizeAxes = Axes.Both;
-                    CornerRadius = Y_OFFSET;
+                    CornerRadius = CORNER_RADIUS;
                     Masking = true;
 
                     InternalChildren = new Drawable[]
@@ -322,7 +346,7 @@ namespace osu.Game.Screens.SelectV2
                 Depth = float.MaxValue;
                 Origin = Anchor.BottomLeft;
                 Shear = OsuGame.SHEAR;
-                CornerRadius = Y_OFFSET;
+                CornerRadius = CORNER_RADIUS;
                 AutoSizeAxes = Axes.X;
                 Height = bar_height;
                 Masking = true;
diff --git a/osu.Game/Screens/SelectV2/ISongSelect.cs b/osu.Game/Screens/SelectV2/ISongSelect.cs
index 1a80548380..e39f74c018 100644
--- a/osu.Game/Screens/SelectV2/ISongSelect.cs
+++ b/osu.Game/Screens/SelectV2/ISongSelect.cs
@@ -29,10 +29,16 @@ namespace osu.Game.Screens.SelectV2
         void ManageCollections();
 
         /// <summary>
-        /// Present the provided score at the results screen.
+        /// Opens results screen with the given score.
+        /// This assumes active beatmap and ruleset selection matches the score.
         /// </summary>
         void PresentScore(ScoreInfo score);
 
+        /// <summary>
+        /// Set the current filter text query to the provided string.
+        /// </summary>
+        void Search(string query);
+
         /// <summary>
         /// Gets relevant actionable items for beatmap context menus, based on the type of song select.
         /// </summary>
diff --git a/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs b/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
index 46f8859255..f3637f9949 100644
--- a/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
+++ b/osu.Game/Screens/SelectV2/NoResultsPlaceholder.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Screens.SelectV2
 
         private LinkFlowContainer textFlow = null!;
 
-        private SpriteIcon icon = null!;
+        private GhostIcon icon = null!;
 
         [Resolved]
         private BeatmapManager beatmaps { get; set; } = null!;
@@ -71,13 +71,16 @@ namespace osu.Game.Screens.SelectV2
                     AutoSizeAxes = Axes.Y,
                     Children = new Drawable[]
                     {
-                        icon = new SpriteIcon
+                        new Container
                         {
-                            Icon = FontAwesome.Solid.Ghost,
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
                             Margin = new MarginPadding(10),
                             Size = new Vector2(50),
+                            Child = icon = new GhostIcon
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
                         },
                         new OsuSpriteText
                         {
@@ -101,6 +104,17 @@ namespace osu.Game.Screens.SelectV2
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            icon.Loop(t =>
+                t.MoveToY(-10, 2000, Easing.InOutSine)
+                 .Then()
+                 .MoveToY(0, 2000, Easing.InOutSine)
+            );
+        }
+
         protected override void PopIn()
         {
             this.FadeIn(600, Easing.OutQuint);
@@ -121,9 +135,6 @@ namespace osu.Game.Screens.SelectV2
             this.ScaleTo(0.9f)
                 .ScaleTo(1f, 1000, Easing.OutQuint);
 
-            icon.ScaleTo(new Vector2(-1, 1))
-                .ScaleTo(new Vector2(1, 1), 500, Easing.InOutSine);
-
             textFlow.FadeInFromZero(800, Easing.OutQuint);
 
             textFlow.Clear();
diff --git a/osu.Game/Screens/SelectV2/Panel.cs b/osu.Game/Screens/SelectV2/Panel.cs
index f17567f9ba..6a1b5cc3a6 100644
--- a/osu.Game/Screens/SelectV2/Panel.cs
+++ b/osu.Game/Screens/SelectV2/Panel.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -13,8 +14,10 @@ using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Carousel;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
@@ -37,10 +40,13 @@ namespace osu.Game.Screens.SelectV2
         private Container backgroundLayerHorizontalPadding = null!;
         private Container backgroundContainer = null!;
         private Container iconContainer = null!;
-        private Box activationFlash = null!;
-        private Box hoverLayer = null!;
-        private Box keyboardSelectionLayer = null!;
-        private Box selectionLayer = null!;
+
+        private Drawable activationFlash = null!;
+        private Drawable hoverLayer = null!;
+
+        private Drawable keyboardSelectionLayer = null!;
+
+        private PulsatingBox selectionLayer = null!;
 
         public Container TopLevelContent { get; private set; } = null!;
 
@@ -63,15 +69,30 @@ namespace osu.Game.Screens.SelectV2
             get => accentColour;
             set
             {
+                if (value == accentColour)
+                    return;
+
                 accentColour = value;
                 updateAccentColour();
             }
         }
 
-        // content is offset by PanelXOffset, make sure we only handle input at the actual visible
-        // offset region.
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
-            TopLevelContent.ReceivePositionalInputAt(screenSpacePos);
+        public sealed override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
+        {
+            if (item == null)
+                return TopLevelContent.ReceivePositionalInputAt(screenSpacePos);
+
+            var inputRectangle = TopLevelContent.DrawRectangle;
+
+            // Cover the gaps introduced by the spacing between panels so that user mis-aims don't result in no-ops.
+            inputRectangle = inputRectangle.Inflate(new MarginPadding
+            {
+                Top = item.CarouselInputLenienceAbove,
+                Bottom = item.CarouselInputLenienceBelow,
+            });
+
+            return inputRectangle.Contains(TopLevelContent.ToLocalSpace(screenSpacePos));
+        }
 
         [Resolved]
         private BeatmapCarousel? carousel { get; set; }
@@ -97,37 +118,30 @@ namespace osu.Game.Screens.SelectV2
                     Hollow = true,
                     Radius = 2,
                 },
-                Children = new Drawable[]
+                Children = new[]
                 {
-                    new BufferedContainer
+                    backgroundBorder = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Children = new Drawable[]
+                        Colour = Color4.Black,
+                    },
+                    backgroundLayerHorizontalPadding = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = new Container
                         {
-                            backgroundBorder = new Box
+                            RelativeSizeAxes = Axes.Both,
+                            Masking = true,
+                            CornerRadius = corner_radius,
+                            Children = new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                Colour = Color4.Black,
-                            },
-                            backgroundLayerHorizontalPadding = new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Child = new Container
+                                backgroundGradient = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                backgroundContainer = 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,
-                                        },
-                                    }
                                 },
                             }
                         },
@@ -150,11 +164,11 @@ namespace osu.Game.Screens.SelectV2
                         Blending = BlendingParameters.Additive,
                         RelativeSizeAxes = Axes.Both,
                     },
-                    selectionLayer = new Box
+                    selectionLayer = new PulsatingBox
                     {
                         Alpha = 0,
                         RelativeSizeAxes = Axes.Both,
-                        Width = 0.6f,
+                        Width = 0.8f,
                         Blending = BlendingParameters.Additive,
                         Anchor = Anchor.TopRight,
                         Origin = Anchor.TopRight,
@@ -162,7 +176,7 @@ namespace osu.Game.Screens.SelectV2
                     keyboardSelectionLayer = new Box
                     {
                         Alpha = 0,
-                        Colour = colourProvider.Highlight1.Opacity(0.1f),
+                        Colour = ColourInfo.GradientHorizontal(colourProvider.Highlight1.Opacity(0.1f), colourProvider.Highlight1.Opacity(0.4f)),
                         Blending = BlendingParameters.Additive,
                         RelativeSizeAxes = Axes.Both,
                     },
@@ -180,6 +194,51 @@ namespace osu.Game.Screens.SelectV2
             backgroundGradient.Colour = ColourInfo.GradientHorizontal(colourProvider.Background3, colourProvider.Background4);
         }
 
+        public partial class PulsatingBox : BeatSyncedContainer
+        {
+            public double FlashOffset;
+
+            private readonly Box box;
+
+            public PulsatingBox()
+            {
+                EarlyActivationMilliseconds = 50;
+
+                InternalChildren = new Drawable[]
+                {
+                    box = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+            }
+
+            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)
+                    return;
+
+                double length = timingPoint.BeatLength;
+                separation = 1;
+
+                while (length < 500)
+                {
+                    length *= 2;
+                    separation *= 2;
+                }
+
+                box
+                    .Delay(FlashOffset)
+                    .FadeTo(0.8f, length / 6, Easing.Out)
+                    .Then()
+                    .FadeTo(0.4f, length, Easing.Out);
+            }
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -199,7 +258,11 @@ namespace osu.Game.Screens.SelectV2
             KeyboardSelected.BindValueChanged(selected =>
             {
                 if (selected.NewValue)
-                    keyboardSelectionLayer.FadeIn(100, Easing.OutQuint);
+                {
+                    keyboardSelectionLayer.FadeIn(80, Easing.Out)
+                                          .Then()
+                                          .FadeTo(0.5f, 2000, Easing.OutQuint);
+                }
                 else
                     keyboardSelectionLayer.FadeOut(1000, Easing.OutQuint);
 
@@ -211,8 +274,14 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
+            // Slightly offset the flash animation based on the panel depth.
+            // This assumes a minimum depth of -2 (groups).
+            selectionLayer.FlashOffset = (2 + Item!.DepthLayer) * 50;
+
             updateAccentColour();
-            updateXOffset();
+
+            updateXOffset(animated: false);
+            updateSelectedState(animated: false);
 
             this.FadeIn(DURATION, Easing.OutQuint);
         }
@@ -257,13 +326,13 @@ namespace osu.Game.Screens.SelectV2
                 selectionLayer.FadeOut(200, Easing.OutQuint);
         }
 
-        private void updateXOffset()
+        private void updateXOffset(bool animated = true)
         {
             float x = PanelXOffset + corner_radius;
 
             if (!Expanded.Value && !Selected.Value)
             {
-                if (this is PanelBeatmap)
+                if (this is PanelBeatmap || this is PanelBeatmapStandalone)
                     x += active_x_offset * 2;
                 else
                     x += active_x_offset * 4;
@@ -272,7 +341,7 @@ namespace osu.Game.Screens.SelectV2
             if (!KeyboardSelected.Value)
                 x += active_x_offset;
 
-            TopLevelContent.MoveToX(x, DURATION, Easing.OutQuint);
+            TopLevelContent.MoveToX(x, animated ? DURATION : 0, Easing.OutQuint);
         }
 
         protected override bool OnHover(HoverEvent e)
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmap.cs b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
index e785448c9a..a06c77448f 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmap.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
@@ -72,19 +72,6 @@ namespace osu.Game.Screens.SelectV2
             PanelXOffset = 60;
         }
 
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
-        {
-            var inputRectangle = TopLevelContent.DrawRectangle;
-
-            // Cover the gaps introduced by the spacing between BeatmapPanels so that clicks will not fall through the carousel.
-            //
-            // Caveat is that for simplicity, we are covering the full spacing, so panels with frontmost depth will have a slightly
-            // larger hit target.
-            inputRectangle = inputRectangle.Inflate(new MarginPadding { Vertical = BeatmapCarousel.SPACING });
-
-            return inputRectangle.Contains(TopLevelContent.ToLocalSpace(screenSpacePos));
-        }
-
         [BackgroundDependencyLoader]
         private void load(OverlayColourProvider colourProvider)
         {
@@ -121,8 +108,8 @@ namespace osu.Game.Screens.SelectV2
                 AutoSizeAxes = Axes.Both,
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreLeft,
-                Spacing = new Vector2(3),
-                Margin = new MarginPadding { Left = 5 },
+                Spacing = new Vector2(5),
+                Margin = new MarginPadding { Left = 6.5f },
                 Direction = FillDirection.Horizontal,
                 Children = new Drawable[]
                 {
@@ -138,6 +125,7 @@ namespace osu.Game.Screens.SelectV2
                         Origin = Anchor.CentreLeft,
                         Direction = FillDirection.Vertical,
                         AutoSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Bottom = 3.5f },
                         Children = new Drawable[]
                         {
                             new FillFlowContainer
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
index e34e822e2d..2864980fce 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
@@ -67,19 +67,6 @@ namespace osu.Game.Screens.SelectV2
             PanelXOffset = 20f;
         }
 
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
-        {
-            var inputRectangle = TopLevelContent.DrawRectangle;
-
-            // Cover the gaps introduced by the spacing between BeatmapPanels so that clicks will not fall through the carousel.
-            //
-            // Caveat is that for simplicity, we are covering the full spacing, so panels with frontmost depth will have a slightly
-            // larger hit target.
-            inputRectangle = inputRectangle.Inflate(new MarginPadding { Vertical = BeatmapCarousel.SPACING });
-
-            return inputRectangle.Contains(TopLevelContent.ToLocalSpace(screenSpacePos));
-        }
-
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -110,7 +97,9 @@ namespace osu.Game.Screens.SelectV2
                 {
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Vertical,
-                    Padding = new MarginPadding { Top = 7.5f, Left = 15, Bottom = 5 },
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Padding = new MarginPadding { Top = 7.5f, Left = 15, Bottom = 13 },
                     Children = new Drawable[]
                     {
                         titleText = new OsuSpriteText
@@ -245,7 +234,7 @@ namespace osu.Game.Screens.SelectV2
                 if (manageCollectionsDialog != null)
                     collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, manageCollectionsDialog.Show));
 
-                items.Add(new OsuMenuItem("Collections") { Items = collectionItems });
+                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)));
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
index d461653dcb..28a6bfc83a 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
@@ -71,22 +71,6 @@ namespace osu.Game.Screens.SelectV2
         private OsuSpriteText authorText = null!;
         private FillFlowContainer mainFill = null!;
 
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
-        {
-            var inputRectangle = TopLevelContent.DrawRectangle;
-
-            if (Selected.Value)
-            {
-                // Cover the gaps introduced by the spacing between BeatmapPanels so that clicks will not fall through the carousel.
-                //
-                // Caveat is that for simplicity, we are covering the full spacing, so panels with frontmost depth will have a slightly
-                // larger hit target.
-                inputRectangle = inputRectangle.Inflate(new MarginPadding { Vertical = BeatmapCarousel.SPACING * 2 });
-            }
-
-            return inputRectangle.Contains(TopLevelContent.ToLocalSpace(screenSpacePos));
-        }
-
         public PanelBeatmapStandalone()
         {
             PanelXOffset = 20;
@@ -114,8 +98,8 @@ namespace osu.Game.Screens.SelectV2
                 AutoSizeAxes = Axes.Both,
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreLeft,
-                Spacing = new Vector2(3),
-                Margin = new MarginPadding { Left = 5 },
+                Spacing = new Vector2(5),
+                Margin = new MarginPadding { Left = 6.5f },
                 Direction = FillDirection.Horizontal,
                 Children = new Drawable[]
                 {
@@ -130,7 +114,7 @@ namespace osu.Game.Screens.SelectV2
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
                         Direction = FillDirection.Vertical,
-                        Padding = new MarginPadding { Bottom = 2 },
+                        Padding = new MarginPadding { Bottom = 4.8f },
                         AutoSizeAxes = Axes.Both,
                         Children = new Drawable[]
                         {
diff --git a/osu.Game/Screens/SelectV2/PanelGroup.cs b/osu.Game/Screens/SelectV2/PanelGroup.cs
index c0c4676a30..b7288f1da4 100644
--- a/osu.Game/Screens/SelectV2/PanelGroup.cs
+++ b/osu.Game/Screens/SelectV2/PanelGroup.cs
@@ -150,9 +150,9 @@ namespace osu.Game.Screens.SelectV2
             countText.Text = Item.NestedItemCount.ToString("N0");
         }
 
-        protected override void Update()
+        protected override void UpdateAfterChildren()
         {
-            base.Update();
+            base.UpdateAfterChildren();
 
             // Move the count pill in the opposite direction to keep it pinned to the screen regardless of the X position of TopLevelContent.
             countPill.X = -TopLevelContent.X;
diff --git a/osu.Game/Screens/SelectV2/PanelSetBackground.cs b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
index dd07be0410..ea82755810 100644
--- a/osu.Game/Screens/SelectV2/PanelSetBackground.cs
+++ b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
@@ -1,101 +1,166 @@
 // 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.Extensions.Color4Extensions;
+using osu.Framework.Extensions.PolygonExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+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;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelSetBackground : ModelBackedDrawable<WorkingBeatmap>
+    public partial class PanelSetBackground : Container
     {
-        protected override double TransformDuration => 400;
+        [Resolved]
+        private BeatmapCarousel? beatmapCarousel { get; set; }
+
+        private Sprite? sprite;
+
+        private WorkingBeatmap? working;
+
+        private CancellationTokenSource? loadCancellation;
+
+        private double timeSinceUnpool;
 
         public WorkingBeatmap? Beatmap
         {
-            get => Model;
-            set => Model = value;
+            get => working;
+            set
+            {
+                if (value == working)
+                    return;
+
+                working = value;
+
+                loadCancellation?.Cancel();
+                loadCancellation = null;
+
+                sprite?.Expire();
+                sprite = null;
+
+                timeSinceUnpool = 0;
+            }
         }
 
-        protected override Drawable CreateDrawable(WorkingBeatmap? model) => new BackgroundSprite(model);
-
-        private partial class BackgroundSprite : CompositeDrawable
+        public PanelSetBackground()
         {
-            private readonly WorkingBeatmap? working;
+            RelativeSizeAxes = Axes.Both;
+        }
 
-            public BackgroundSprite(WorkingBeatmap? working)
+        protected override void Update()
+        {
+            base.Update();
+
+            loadContentIfRequired();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
             {
-                this.working = working;
+                new FillFlowContainer
+                {
+                    Depth = -1,
+                    RelativeSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    // This makes the gradient not be perfectly horizontal, but diagonal at a ~40° angle
+                    Shear = new Vector2(0.8f, 0),
+                    Children = new[]
+                    {
+                        // The left half with no gradient applied
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black.Opacity(0.5f),
+                            Width = 0.4f,
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.5f), Color4.Black.Opacity(0.3f)),
+                            Width = 0.2f,
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.3f), Color4.Black.Opacity(0.2f)),
+                            // Slightly more than 1.0 in total to account for shear.
+                            Width = 0.45f,
+                        },
+                    }
+                },
+            };
+        }
 
-                RelativeSizeAxes = Axes.Both;
+        private void loadContentIfRequired()
+        {
+            // A load is already in progress if the cancellation token is non-null.
+            if (loadCancellation != null || working == null)
+                return;
+
+            if (beatmapCarousel != null)
+            {
+                Quad containingSsdq = beatmapCarousel.ScreenSpaceDrawQuad;
+
+                // One may ask why we are not using `DelayedLoadWrapper` for this delayed load logic.
+                //
+                // - Using `DelayedLoadWrapper` would only allow us to load content when on screen, but we want to preload while panels are off-screen.
+                //   This allows a more seamless experience when a user is scrolling at a moderate speed, as we are loading in backgrounds before they
+                //   enter the visible viewport.
+                // - By using a slightly customised formula to decide when to start the load, we can coerce the loading of backgrounds into an order that
+                //   prioritises panels which are closest to the centre of the screen. Basically, we want to load backgrounds "outwards" from the visual
+                //   centre to give the user the best experience possible.
+                float timeUpdatingBeforeLoad = 50 + Math.Abs(containingSsdq.Centre.Y - ScreenSpaceDrawQuad.Centre.Y) / containingSsdq.Height * 100;
+
+                timeSinceUnpool += Time.Elapsed;
+
+                // We only trigger a load after this set has been in an updating state for a set amount of time.
+                if (timeSinceUnpool <= timeUpdatingBeforeLoad)
+                    return;
+            }
+
+            loadCancellation = new CancellationTokenSource();
+
+            LoadComponentAsync(new PanelBeatmapBackground(working)
+            {
+                Depth = float.MaxValue,
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                FillMode = FillMode.Fill,
+            }, s =>
+            {
+                AddInternal(sprite = s);
+                bool spriteOnScreen = beatmapCarousel?.ScreenSpaceDrawQuad.Intersects(sprite.ScreenSpaceDrawQuad) != false;
+                sprite.FadeInFromZero(spriteOnScreen ? 400 : 0, Easing.OutQuint);
+            }, loadCancellation.Token);
+        }
+
+        public partial class PanelBeatmapBackground : Sprite
+        {
+            private readonly IWorkingBeatmap working;
+
+            public PanelBeatmapBackground(IWorkingBeatmap working)
+            {
+                ArgumentNullException.ThrowIfNull(working);
+
+                this.working = working;
             }
 
             [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colourProvider)
+            private void load()
             {
-                var texture = working?.GetPanelBackground();
-
-                if (texture != null)
-                {
-                    InternalChildren = new Drawable[]
-                    {
-                        new Sprite
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            FillMode = FillMode.Fill,
-                            Texture = texture,
-                        },
-                        new FillFlowContainer
-                        {
-                            Depth = -1,
-                            RelativeSizeAxes = Axes.Both,
-                            Direction = FillDirection.Horizontal,
-                            // This makes the gradient not be perfectly horizontal, but diagonal at a ~40° angle
-                            Shear = new Vector2(0.8f, 0),
-                            Children = new[]
-                            {
-                                // The left half with no gradient applied
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Color4.Black.Opacity(0.5f),
-                                    Width = 0.4f,
-                                },
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.5f), Color4.Black.Opacity(0.3f)),
-                                    Width = 0.2f,
-                                },
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.3f), Color4.Black.Opacity(0.2f)),
-                                    // Slightly more than 1.0 in total to account for shear.
-                                    Width = 0.45f,
-                                },
-                            }
-                        },
-                    };
-                }
-                else
-                {
-                    InternalChild = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colourProvider.Background6,
-                    };
-                }
+                Texture = working.GetPanelBackground();
             }
         }
     }
diff --git a/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
index 4c767df9d8..b133da71f7 100644
--- a/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
+++ b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
@@ -69,7 +69,6 @@ namespace osu.Game.Screens.SelectV2
 
             Content.Anchor = Anchor.Centre;
             Content.Origin = Anchor.Centre;
-            Content.Shear = OsuGame.SHEAR;
 
             Content.AddRange(new Drawable[]
             {
@@ -87,7 +86,6 @@ namespace osu.Game.Screens.SelectV2
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(4),
-                    Shear = -OsuGame.SHEAR,
                     Children = new Drawable[]
                     {
                         new Container
diff --git a/osu.Game/Screens/SelectV2/SoloSongSelect.cs b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
index 2c1eabc5fb..4c4df7f389 100644
--- a/osu.Game/Screens/SelectV2/SoloSongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
@@ -54,12 +54,14 @@ namespace osu.Game.Screens.SelectV2
         private void load(AudioManager audio)
         {
             sampleConfirmSelection = audio.Samples.Get(@"SongSelect/confirm-selection");
+
+            AddInternal(new SongSelectTouchInputDetector());
         }
 
         public override IEnumerable<OsuMenuItem> GetForwardActions(BeatmapInfo beatmap)
         {
-            yield return new OsuMenuItem(ButtonSystemStrings.Play.ToSentence(), MenuItemType.Highlighted, () => SelectAndStart(beatmap)) { Icon = FontAwesome.Solid.Check };
-            yield return new OsuMenuItem(ButtonSystemStrings.Edit.ToSentence(), MenuItemType.Standard, () => edit(beatmap)) { Icon = FontAwesome.Solid.PencilAlt };
+            yield return new OsuMenuItem(ButtonSystemStrings.Play.ToSentence(), MenuItemType.Highlighted, () => SelectAndRun(beatmap, OnStart)) { Icon = FontAwesome.Solid.Check };
+            yield return new OsuMenuItem(ButtonSystemStrings.Edit.ToSentence(), MenuItemType.Standard, () => Edit(beatmap)) { Icon = FontAwesome.Solid.PencilAlt };
 
             yield return new OsuMenuItemSpacer();
 
@@ -85,15 +87,11 @@ namespace osu.Game.Screens.SelectV2
             yield return new OsuMenuItem(WebCommonStrings.ButtonsHide.ToSentence(), MenuItemType.Destructive, () => beatmaps.Hide(beatmap));
         }
 
-        protected override bool OnStart()
+        protected override void OnStart()
         {
-            if (playerLoader != null) return false;
-            if (!this.IsCurrentScreen()) return false;
-            if (Beatmap.IsDefault) return false;
+            if (playerLoader != null) return;
 
-            FinaliseSelection();
-
-            modsAtGameplayStart = Mods.Value;
+            modsAtGameplayStart = Mods.Value.Select(m => m.DeepClone()).ToArray();
 
             // Ctrl+Enter should start map with autoplay enabled.
             if (GetContainingInputManager()?.CurrentState?.Keyboard.ControlPressed == true)
@@ -106,7 +104,7 @@ namespace osu.Game.Screens.SelectV2
                     {
                         Text = NotificationsStrings.NoAutoplayMod
                     });
-                    return false;
+                    return;
                 }
 
                 var mods = Mods.Value.Append(autoInstance).ToArray();
@@ -120,7 +118,6 @@ namespace osu.Game.Screens.SelectV2
             sampleConfirmSelection?.Play();
 
             this.Push(playerLoader = new PlayerLoader(createPlayer));
-            return true;
 
             Player createPlayer()
             {
@@ -141,17 +138,12 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private void edit(BeatmapInfo beatmap)
+        public void Edit(BeatmapInfo beatmap)
         {
             if (!this.IsCurrentScreen())
                 return;
 
-            FinaliseSelection();
-
-            // Forced refetch is important here to guarantee correct invalidation across all difficulties.
-            Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, true);
-
-            this.Push(new EditorLoader());
+            SelectAndRun(beatmap, () => this.Push(new EditorLoader()));
         }
 
         public override void OnResuming(ScreenTransitionEvent e)
@@ -181,7 +173,7 @@ namespace osu.Game.Screens.SelectV2
 
         private partial class PlayerLoader : Play.PlayerLoader
         {
-            public override bool ShowFooter => true;
+            public override bool ShowFooter => !QuickRestart;
 
             public PlayerLoader(Func<Player> createPlayer)
                 : base(createPlayer)
diff --git a/osu.Game/Screens/SelectV2/SongSelect.cs b/osu.Game/Screens/SelectV2/SongSelect.cs
index c753dd77cf..8030290aab 100644
--- a/osu.Game/Screens/SelectV2/SongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -6,7 +6,10 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 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.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -16,11 +19,13 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Input.StateChanges;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Collections;
+using osu.Game.Configuration;
 using osu.Game.Database;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
@@ -92,6 +97,9 @@ namespace osu.Game.Screens.SelectV2
         private BeatmapTitleWedge titleWedge = null!;
         private BeatmapDetailsArea detailsArea = null!;
         private FillFlowContainer wedgesContainer = null!;
+        private Box rightGradientBackground = null!;
+        private Container mainContent = null!;
+        private SkinnableContainer skinnableContent = null!;
 
         private NoResultsPlaceholder noResultsPlaceholder = null!;
 
@@ -99,6 +107,8 @@ namespace osu.Game.Screens.SelectV2
 
         public override bool ShowFooter => true;
 
+        private Sample? errorSample;
+
         [Resolved]
         private OsuGameBase? game { get; set; }
 
@@ -123,20 +133,20 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
+        private Bindable<bool> configBackgroundBlur = null!;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio, OsuConfigManager config)
         {
+            errorSample = audio.Samples.Get(@"UI/generic-error");
+
             AddRangeInternal(new Drawable[]
             {
                 new GlobalScrollAdjustsVolume(),
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Width = 0.5f,
-                    Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.5f), Color4.Black.Opacity(0f)),
-                },
-                new Container
+                mainContent = new Container
                 {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Padding = new MarginPadding { Bottom = ScreenFooter.HEIGHT },
                     Child = new OsuContextMenuContainer
@@ -147,14 +157,20 @@ namespace osu.Game.Screens.SelectV2
                             RelativeSizeAxes = Axes.Both,
                             Children = new Drawable[]
                             {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.6f,
+                                    Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.3f), Color4.Black.Opacity(0f)),
+                                },
                                 new GridContainer // used for max width implementation
                                 {
                                     RelativeSizeAxes = Axes.Both,
                                     ColumnDimensions = new[]
                                     {
-                                        new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 660),
+                                        new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 700),
                                         new Dimension(),
-                                        new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 620),
+                                        new Dimension(GridSizeMode.Relative, 0.5f, minSize: 500, maxSize: 900),
                                     },
                                     Content = new[]
                                     {
@@ -204,8 +220,10 @@ namespace osu.Game.Screens.SelectV2
                                                 RelativeSizeAxes = Axes.Both,
                                                 Children = new Drawable[]
                                                 {
-                                                    new Box
+                                                    rightGradientBackground = new Box
                                                     {
+                                                        Anchor = Anchor.TopRight,
+                                                        Origin = Anchor.TopRight,
                                                         Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.0f), Color4.Black.Opacity(0.5f)),
                                                         RelativeSizeAxes = Axes.Both,
                                                     },
@@ -224,9 +242,9 @@ namespace osu.Game.Screens.SelectV2
                                                                 BleedTop = FilterControl.HEIGHT_FROM_SCREEN_TOP + 5,
                                                                 BleedBottom = ScreenFooter.HEIGHT + 5,
                                                                 RelativeSizeAxes = Axes.Both,
-                                                                RequestPresentBeatmap = _ => OnStart(),
-                                                                RequestSelection = selectBeatmap,
-                                                                RequestRecommendedSelection = selectRecommendedBeatmap,
+                                                                RequestPresentBeatmap = b => SelectAndRun(b, OnStart),
+                                                                RequestSelection = queueBeatmapSelection,
+                                                                RequestRecommendedSelection = b => queueBeatmapSelection(difficultyRecommender?.GetRecommendedBeatmap(b) ?? b.First()),
                                                                 NewItemsPresented = newItemsPresented,
                                                             },
                                                             noResultsPlaceholder = new NoResultsPlaceholder
@@ -250,20 +268,32 @@ namespace osu.Game.Screens.SelectV2
                         },
                     }
                 },
-                new SkinnableContainer(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.SongSelect))
+                skinnableContent = new SkinnableContainer(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.SongSelect))
                 {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                 },
                 modSpeedHotkeyHandler = new ModSpeedHotkeyHandler(),
                 modSelectOverlay,
             });
+
+            configBackgroundBlur = config.GetBindable<bool>(OsuSetting.SongSelectBackgroundBlur);
+            configBackgroundBlur.BindValueChanged(e =>
+            {
+                if (!this.IsCurrentScreen())
+                    return;
+
+                updateBackgroundDim();
+            });
         }
 
         /// <summary>
-        /// Called when a selection is made.
+        /// Called when a selection is made to progress away from the song select screen.
+        ///
+        /// This is the default action which should be provided to <see cref="SelectAndRun"/>.
         /// </summary>
-        /// <returns>If a resultant action occurred that takes the user away from SongSelect.</returns>
-        protected abstract bool OnStart();
+        protected abstract void OnStart();
 
         public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => new ScreenFooterButton[]
         {
@@ -275,8 +305,16 @@ namespace osu.Game.Screens.SelectV2
             },
             new FooterButtonRandom
             {
-                NextRandom = () => carousel.NextRandom(),
-                PreviousRandom = () => carousel.PreviousRandom()
+                NextRandom = () =>
+                {
+                    if (!carousel.NextRandom())
+                        errorSample?.Play();
+                },
+                PreviousRandom = () =>
+                {
+                    if (!carousel.PreviousRandom())
+                        errorSample?.Play();
+                }
             },
             new FooterButtonOptions
             {
@@ -295,11 +333,20 @@ namespace osu.Game.Screens.SelectV2
                 if (!this.IsCurrentScreen())
                     return;
 
-                logo?.ScaleTo(v.NewValue == Visibility.Visible ? 0f : logo_scale, 400, Easing.OutQuint)
-                    .FadeTo(v.NewValue == Visibility.Visible ? 0f : 1f, 200, Easing.OutQuint);
+                logo?.FadeTo(v.NewValue == Visibility.Visible ? 0f : 1f, 200, Easing.OutQuint);
             });
 
-            Beatmap.BindValueChanged(_ => updateSelection());
+            Beatmap.BindValueChanged(_ =>
+            {
+                if (!this.IsCurrentScreen())
+                    return;
+
+                ensureGlobalBeatmapValid();
+
+                ensurePlayingSelected(true);
+                updateBackgroundDim();
+                updateWedgeVisibility();
+            });
         }
 
         protected override void Update()
@@ -320,7 +367,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()
+        private void ensurePlayingSelected(bool restart)
         {
             if (!ControlGlobalMusic)
                 return;
@@ -332,7 +379,7 @@ namespace osu.Game.Screens.SelectV2
             if (!track.IsRunning && (music.UserPauseRequested != true || isNewTrack))
             {
                 Logger.Log($"Song select decided to {nameof(ensurePlayingSelected)}");
-                music.Play(true);
+                music.Play(restart);
             }
 
             lastTrack.SetTarget(track);
@@ -372,58 +419,122 @@ namespace osu.Game.Screens.SelectV2
 
         #region Selection handling
 
-        /// <summary>
-        /// Immediately flush any pending selection. Should be run before performing final actions such as leaving the screen.
-        /// </summary>
-        protected void FinaliseSelection()
-        {
-            if (selectionDebounce?.State == ScheduledDelegate.RunState.Waiting)
-                selectionDebounce.RunTask();
-        }
-
         private ScheduledDelegate? selectionDebounce;
 
-        private void selectRecommendedBeatmap(IEnumerable<BeatmapInfo> beatmaps)
-        {
-            selectBeatmap(difficultyRecommender?.GetRecommendedBeatmap(beatmaps) ?? beatmaps.First());
-        }
-
-        private void selectBeatmap(BeatmapInfo beatmap)
+        /// <summary>
+        /// Finalises selection on the given <see cref="BeatmapInfo"/> and runs the provided action if possible.
+        /// </summary>
+        /// <param name="beatmap">The beatmap which should be selected. If not provided, the current globally selected beatmap will be used.</param>
+        /// <param name="startAction">The action to perform if conditions are met to be able to proceed. May not be invoked if in an invalid state.</param>
+        public void SelectAndRun(BeatmapInfo beatmap, Action startAction)
         {
             if (!this.IsCurrentScreen())
                 return;
 
-            if (beatmap.BeatmapSet!.Protected)
+            if (!checkBeatmapValidForSelection(beatmap, carousel.Criteria))
+                return;
+
+            // 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();
+
+            // Forced refetch is important here to guarantee correct invalidation across all difficulties (editor specific).
+            Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, true);
+
+            if (Beatmap.IsDefault)
+                return;
+
+            startAction();
+        }
+
+        /// <summary>
+        /// Prepares the proposed beatmap for global selection based on a carousel user-performed action.
+        /// </summary>
+        /// <remarks>
+        /// Calling this method will:
+        /// - 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)
+        {
+            if (!this.IsCurrentScreen())
                 return;
 
             carousel.CurrentSelection = beatmap;
 
+            // Debounce consideration is to avoid beatmap churn on key repeat selection.
             selectionDebounce?.Cancel();
-            selectionDebounce = Scheduler.AddDelayed(() => Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap), SELECTION_DEBOUNCE);
+            selectionDebounce = Scheduler.AddDelayed(() =>
+            {
+                if (Beatmap.Value.BeatmapInfo.Equals(beatmap))
+                    return;
+
+                Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap);
+            }, SELECTION_DEBOUNCE);
         }
 
-        private void updateSelection() => Scheduler.AddOnce(() =>
+        /// <summary>
+        /// If any pending selection exists from <see cref="queueBeatmapSelection"/>, run it immediately.
+        /// </summary>
+        private void finaliseBeatmapSelection()
         {
-            var beatmap = Beatmap.Value;
+            if (selectionDebounce?.State == ScheduledDelegate.RunState.Waiting)
+                selectionDebounce?.RunTask();
+        }
 
-            carousel.CurrentSelection = beatmap.BeatmapInfo;
+        private bool ensureGlobalBeatmapValid()
+        {
+            if (!this.IsCurrentScreen())
+                return false;
 
-            if (this.IsCurrentScreen())
-                ensurePlayingSelected();
+            finaliseBeatmapSelection();
 
-            // If not the current screen, this will be applied in OnResuming.
-            if (this.IsCurrentScreen())
+            // 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)
+                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)
             {
-                ApplyToBackground(backgroundModeBeatmap =>
-                {
-                    backgroundModeBeatmap.BlurAmount.Value = 0;
-                    backgroundModeBeatmap.Beatmap = beatmap;
-                    backgroundModeBeatmap.IgnoreUserSettings.Value = true;
-                    backgroundModeBeatmap.DimWhenUserSettingsIgnored.Value = 0.1f;
-                    backgroundModeBeatmap.FadeColour(Color4.White, 250);
-                });
+                validSelection = carousel.NextRandom();
+                finaliseBeatmapSelection();
             }
-        });
+
+            if (validSelection)
+                carousel.CurrentSelection = Beatmap.Value.BeatmapInfo;
+            else
+                Beatmap.SetDefault();
+
+            return validSelection;
+        }
+
+        private bool checkBeatmapValidForSelection(BeatmapInfo beatmap, FilterCriteria? criteria)
+        {
+            if (criteria == null)
+                return false;
+
+            if (!beatmap.AllowGameplayWithRuleset(Ruleset.Value, criteria.AllowConvertedBeatmaps))
+                return false;
+
+            if (beatmap.Hidden)
+                return false;
+
+            if (beatmap.BeatmapSet == null)
+                return false;
+
+            if (beatmap.BeatmapSet.Protected || beatmap.BeatmapSet.DeletePending)
+                return false;
+
+            return true;
+        }
 
         #endregion
 
@@ -434,24 +545,7 @@ namespace osu.Game.Screens.SelectV2
             base.OnEntering(e);
 
             this.FadeIn();
-
-            titleWedge.Show();
-            detailsArea.Show();
-            filterControl.Show();
-
-            modSelectOverlay.Beatmap.BindTo(Beatmap);
-            modSelectOverlay.SelectedMods.BindTo(Mods);
-
-            beginLooping();
-
-            // force reselection if entering song select with a protected beatmap
-            if (Beatmap.Value.BeatmapInfo.BeatmapSet!.Protected)
-            {
-                if (!carousel.NextRandom())
-                    Beatmap.SetDefault();
-            }
-            else
-                updateSelection();
+            onArrivingAtScreen();
         }
 
         public override void OnResuming(ScreenTransitionEvent e)
@@ -459,41 +553,25 @@ namespace osu.Game.Screens.SelectV2
             base.OnResuming(e);
 
             this.FadeIn(fade_duration, Easing.OutQuint);
+            onArrivingAtScreen();
 
-            carousel.VisuallyFocusSelected = false;
+            ensureGlobalBeatmapValid();
 
-            titleWedge.Show();
-            detailsArea.Show();
-            filterControl.Show();
-
-            modSelectOverlay.Beatmap.BindTo(Beatmap);
-
-            // required due to https://github.com/ppy/osu-framework/issues/3218
-            modSelectOverlay.SelectedMods.Disabled = false;
-            modSelectOverlay.SelectedMods.BindTo(Mods);
-
-            beginLooping();
-
-            if (Beatmap.Value.BeatmapInfo.BeatmapSet!.Protected)
-                Beatmap.SetDefault();
-            else
-                updateSelection();
+            if (ControlGlobalMusic)
+            {
+                // restart playback on returning to song select, regardless.
+                // not sure this should be a permanent thing (we may want to leave a user pause paused even on returning)
+                music.ResetTrackAdjustments();
+                music.Play(requestedByUser: true);
+            }
         }
 
         public override void OnSuspending(ScreenTransitionEvent e)
         {
-            this.FadeOut(fade_duration, Easing.OutQuint);
-
-            modSelectOverlay.SelectedMods.UnbindFrom(Mods);
-            modSelectOverlay.Beatmap.UnbindFrom(Beatmap);
-
-            titleWedge.Hide();
-            detailsArea.Hide();
-            filterControl.Hide();
-
             carousel.VisuallyFocusSelected = true;
 
-            endLooping();
+            this.FadeOut(fade_duration, Easing.OutQuint);
+            onLeavingScreen();
 
             base.OnSuspending(e);
         }
@@ -501,16 +579,42 @@ namespace osu.Game.Screens.SelectV2
         public override bool OnExiting(ScreenExitEvent e)
         {
             this.FadeOut(fade_duration, Easing.OutQuint);
-
-            titleWedge.Hide();
-            detailsArea.Hide();
-            filterControl.Hide();
-
-            endLooping();
+            onLeavingScreen();
 
             return base.OnExiting(e);
         }
 
+        private void onArrivingAtScreen()
+        {
+            modSelectOverlay.Beatmap.BindTo(Beatmap);
+            // required due to https://github.com/ppy/osu-framework/issues/3218
+            modSelectOverlay.SelectedMods.Disabled = false;
+            modSelectOverlay.SelectedMods.BindTo(Mods);
+
+            carousel.VisuallyFocusSelected = false;
+
+            updateWedgeVisibility();
+
+            beginLooping();
+
+            ensureGlobalBeatmapValid();
+
+            ensurePlayingSelected(false);
+            updateBackgroundDim();
+        }
+
+        private void onLeavingScreen()
+        {
+            restoreBackground();
+
+            modSelectOverlay.SelectedMods.UnbindFrom(Mods);
+            modSelectOverlay.Beatmap.UnbindFrom(Beatmap);
+
+            updateWedgeVisibility();
+
+            endLooping();
+        }
+
         protected override void LogoArriving(OsuLogo logo, bool resuming)
         {
             base.LogoArriving(logo, resuming);
@@ -529,7 +633,7 @@ namespace osu.Game.Screens.SelectV2
 
             logo.Action = () =>
             {
-                OnStart();
+                SelectAndRun(Beatmap.Value.BeatmapInfo, OnStart);
                 return false;
             };
         }
@@ -550,27 +654,67 @@ namespace osu.Game.Screens.SelectV2
             logo.FadeOut(120, Easing.Out);
         }
 
+        private void updateWedgeVisibility()
+        {
+            // Ensure we don't show an invalid selection before the carousel has finished initially filtering.
+            // This avoids a flicker of a placeholder or invalid beatmap before a proper selection.
+            //
+            // After the carousel finishes filtering, it will attempt a selection then call this method again.
+            if (!CarouselItemsPresented && !checkBeatmapValidForSelection(Beatmap.Value.BeatmapInfo, filterControl.CreateCriteria()))
+                return;
+
+            if (carousel.VisuallyFocusSelected)
+            {
+                titleWedge.Hide();
+                detailsArea.Hide();
+                filterControl.Hide();
+            }
+            else
+            {
+                titleWedge.Show();
+                detailsArea.Show();
+                filterControl.Show();
+            }
+        }
+
+        private void updateBackgroundDim() => ApplyToBackground(backgroundModeBeatmap =>
+        {
+            backgroundModeBeatmap.Beatmap = Beatmap.Value;
+            backgroundModeBeatmap.IgnoreUserSettings.Value = true;
+
+            backgroundModeBeatmap.DimWhenUserSettingsIgnored.Value = 0.1f;
+
+            // Required to undo results screen dimming the background.
+            // Probably needs more thought because this needs to be in every `ApplyToBackground` currently to restore sane defaults.
+            backgroundModeBeatmap.FadeColour(Color4.White, 250);
+
+            backgroundModeBeatmap.BlurAmount.Value = revealingBackground == null && configBackgroundBlur.Value ? 20 : 0f;
+        });
+
         #endregion
 
         #region Filtering
 
+        /// <summary>
+        /// Whether the carousel has finished initial presentation of beatmap panels.
+        /// </summary>
+        public bool CarouselItemsPresented { get; private set; }
+
         private const double filter_delay = 250;
 
         private ScheduledDelegate? filterDebounce;
 
-        /// <summary>
-        /// Set the query to the search text box.
-        /// </summary>
-        /// <param name="query">The string to search.</param>
-        public void Search(string query) => filterControl.Search(query);
-
         private void criteriaChanged(FilterCriteria criteria)
         {
-            // The first filter needs to be applied immediately as this triggers the initial carousel load.
-            double filterDelay = filterDebounce == null ? 0 : filter_delay;
-
             filterDebounce?.Cancel();
-            filterDebounce = Scheduler.AddDelayed(() => { carousel.Filter(criteria); }, filterDelay);
+
+            // The first filter needs to be applied immediately as this triggers the initial carousel load.
+            bool isFirstFilter = filterDebounce == null;
+
+            // 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);
         }
 
         private void newItemsPresented(IEnumerable<CarouselItem> carouselItems)
@@ -578,40 +722,130 @@ namespace osu.Game.Screens.SelectV2
             if (carousel.Criteria == null)
                 return;
 
+            CarouselItemsPresented = true;
+
             int count = carousel.MatchedBeatmapsCount;
 
-            if (count == 0)
-            {
-                noResultsPlaceholder.Show();
-                noResultsPlaceholder.Filter = carousel.Criteria;
-            }
-            else
-                noResultsPlaceholder.Hide();
+            updateNoResultsPlaceholder();
 
             // Intentionally not localised until we have proper support for this (see https://github.com/ppy/osu-framework/pull/4918
             // 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";
 
-            // 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 currentBeatmapNotValid = currentBeatmap.BeatmapInfo.Hidden || currentBeatmap.BeatmapSetInfo?.DeletePending == true;
+            ensureGlobalBeatmapValid();
 
-            // If all results are filtered away don't deselect the current global beatmap selection...
-            if (!carouselItems.Any())
+            updateWedgeVisibility();
+        }
+
+        private void updateNoResultsPlaceholder()
+        {
+            int count = carousel.MatchedBeatmapsCount;
+
+            if (count == 0)
             {
-                // ...unless it has been deleted or hidden
-                if (currentBeatmapNotValid)
-                    Beatmap.SetDefault();
-                return;
-            }
+                if (noResultsPlaceholder.State.Value == Visibility.Hidden)
+                {
+                    // Duck audio temporarily when the no results placeholder becomes visible.
+                    //
+                    // Temporary ducking makes it easier to avoid scenarios where the ducking interacts badly
+                    // with other global UI components (like overlays).
+                    music.DuckMomentarily(400, new DuckParameters
+                    {
+                        DuckVolumeTo = 1,
+                        DuckCutoffTo = 500,
+                        DuckDuration = 250,
+                        RestoreDuration = 2000,
+                    });
+                }
 
-            if (Beatmap.IsDefault || currentBeatmapNotValid)
-                carousel.NextRandom();
+                noResultsPlaceholder.Show();
+                noResultsPlaceholder.Filter = carousel.Criteria!;
+
+                rightGradientBackground.ResizeWidthTo(3, 1000, Easing.OutPow10);
+            }
+            else
+            {
+                noResultsPlaceholder.Hide();
+
+                rightGradientBackground.ResizeWidthTo(1, 400, Easing.OutPow10);
+            }
         }
 
         #endregion
 
-        #region Hotkeys
+        #region Input
+
+        private ScheduledDelegate? revealingBackground;
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            var containingInputManager = GetContainingInputManager();
+
+            // I don't know why this works, but it does.
+            // If the carousel panels are hovered, hovered no longer contains the screen.
+            // Maybe there's a better way of doing this, but I couldn't immediately find a good setup.
+            bool mouseDownPriority = containingInputManager!.HoveredDrawables.Contains(this);
+
+            // Touch input synthesises right clicks, which allow absolute scroll of the carousel.
+            // For simplicity, disable this functionality on mobile.
+            bool isTouchInput = e.CurrentState.Mouse.LastSource is ISourcedFromTouch;
+
+            if (e.Button == MouseButton.Left && !isTouchInput && mouseDownPriority)
+            {
+                revealingBackground = Scheduler.AddDelayed(() =>
+                {
+                    if (containingInputManager.DraggedDrawable != null)
+                    {
+                        revealingBackground = null;
+                        return;
+                    }
+
+                    mainContent.ResizeWidthTo(1.2f, 600, Easing.OutQuint);
+                    mainContent.ScaleTo(1.2f, 600, Easing.OutQuint);
+                    mainContent.FadeOut(200, Easing.OutQuint);
+
+                    skinnableContent.ResizeWidthTo(1.2f, 600, Easing.OutQuint);
+                    skinnableContent.ScaleTo(1.2f, 600, Easing.OutQuint);
+                    skinnableContent.FadeOut(200, Easing.OutQuint);
+
+                    updateBackgroundDim();
+
+                    Footer?.Hide();
+                }, 200);
+            }
+
+            return base.OnMouseDown(e);
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            restoreBackground();
+            base.OnMouseUp(e);
+        }
+
+        private void restoreBackground()
+        {
+            if (revealingBackground == null)
+                return;
+
+            if (revealingBackground.State == ScheduledDelegate.RunState.Complete)
+            {
+                mainContent.ResizeWidthTo(1f, 500, Easing.OutQuint);
+                mainContent.ScaleTo(1, 500, Easing.OutQuint);
+                mainContent.FadeIn(500, Easing.OutQuint);
+
+                skinnableContent.ResizeWidthTo(1f, 500, Easing.OutQuint);
+                skinnableContent.ScaleTo(1, 500, Easing.OutQuint);
+                skinnableContent.FadeIn(500, Easing.OutQuint);
+
+                Footer?.Show();
+            }
+
+            revealingBackground.Cancel();
+            revealingBackground = null;
+
+            updateBackgroundDim();
+        }
 
         public virtual bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
@@ -660,11 +894,11 @@ namespace osu.Game.Screens.SelectV2
 
         #endregion
 
-        /// <summary>
-        /// Opens results screen with the given score.
-        /// This assumes active beatmap and ruleset selection matches the score.
-        /// </summary>
-        public void PresentScore(ScoreInfo score)
+        #region Implementation of ISongSelect
+
+        void ISongSelect.Search(string query) => filterControl.Search(query);
+
+        void ISongSelect.PresentScore(ScoreInfo score)
         {
             Debug.Assert(Beatmap.Value.BeatmapInfo.Equals(score.BeatmapInfo));
             Debug.Assert(Ruleset.Value.Equals(score.Ruleset));
@@ -672,17 +906,7 @@ namespace osu.Game.Screens.SelectV2
             this.Push(new SoloResultsScreen(score));
         }
 
-        /// <summary>
-        /// Finalises selection on the given <see cref="BeatmapInfo"/>.
-        /// </summary>
-        public void SelectAndStart(BeatmapInfo beatmap)
-        {
-            if (!this.IsCurrentScreen())
-                return;
-
-            Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap);
-            OnStart();
-        }
+        #endregion
 
         #region Beatmap management
 
@@ -694,7 +918,7 @@ namespace osu.Game.Screens.SelectV2
 
         public virtual IEnumerable<OsuMenuItem> GetForwardActions(BeatmapInfo beatmap)
         {
-            yield return new OsuMenuItem("Select", MenuItemType.Highlighted, () => SelectAndStart(beatmap))
+            yield return new OsuMenuItem("Select", MenuItemType.Highlighted, () => SelectAndRun(beatmap, OnStart))
             {
                 Icon = FontAwesome.Solid.Check
             };
@@ -724,7 +948,7 @@ namespace osu.Game.Screens.SelectV2
 
             collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
 
-            yield return new OsuMenuItem("Collections") { Items = collectionItems };
+            yield return new OsuMenuItem(CommonStrings.Collections) { Items = collectionItems };
         }
 
         public void ManageCollections() => collectionsDialog?.Show();
diff --git a/osu.Game/Screens/Utility/CircleGameplay.cs b/osu.Game/Screens/Utility/CircleGameplay.cs
index 0f328d04fb..c5c4d7d5b2 100644
--- a/osu.Game/Screens/Utility/CircleGameplay.cs
+++ b/osu.Game/Screens/Utility/CircleGameplay.cs
@@ -226,7 +226,7 @@ namespace osu.Game.Screens.Utility
 
                 HitEvent = new HitEvent(Clock.CurrentTime - HitTime, 1.0, HitResult.Good, new HitObject
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                 }, null, null);
 
                 Hit?.Invoke(HitEvent.Value);
diff --git a/osu.Game/Screens/Utility/ScrollingGameplay.cs b/osu.Game/Screens/Utility/ScrollingGameplay.cs
index c0264f5734..3e0969b625 100644
--- a/osu.Game/Screens/Utility/ScrollingGameplay.cs
+++ b/osu.Game/Screens/Utility/ScrollingGameplay.cs
@@ -188,7 +188,7 @@ namespace osu.Game.Screens.Utility
 
                 HitEvent = new HitEvent(Clock.CurrentTime - HitTime, 1.0, HitResult.Good, new HitObject
                 {
-                    HitWindows = new HitWindows(),
+                    HitWindows = new DefaultHitWindows(),
                 }, null, null);
 
                 Hit?.Invoke(HitEvent.Value);
diff --git a/osu.Game/Skinning/Components/BeatmapAttributeText.cs b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
index 76c8d54f50..58821f869a 100644
--- a/osu.Game/Skinning/Components/BeatmapAttributeText.cs
+++ b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Skinning.Components
     [UsedImplicitly]
     public partial class BeatmapAttributeText : FontAdjustableSkinComponent
     {
-        [SettingSource(typeof(BeatmapAttributeTextStrings), nameof(BeatmapAttributeTextStrings.Attribute), nameof(BeatmapAttributeTextStrings.AttributeDescription))]
+        [SettingSource(typeof(BeatmapAttributeTextStrings), nameof(BeatmapAttributeTextStrings.Attribute))]
         public Bindable<BeatmapAttribute> Attribute { get; } = new Bindable<BeatmapAttribute>(BeatmapAttribute.StarRating);
 
         [SettingSource(typeof(BeatmapAttributeTextStrings), nameof(BeatmapAttributeTextStrings.Template), nameof(BeatmapAttributeTextStrings.TemplateDescription))]
diff --git a/osu.Game/Skinning/Components/BoxElement.cs b/osu.Game/Skinning/Components/BoxElement.cs
index 7f052a8523..ddfa1aa446 100644
--- a/osu.Game/Skinning/Components/BoxElement.cs
+++ b/osu.Game/Skinning/Components/BoxElement.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Skinning.Components
             Precision = 0.01f
         };
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour))]
         public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
 
         public BoxElement()
diff --git a/osu.Game/Skinning/Components/TextElement.cs b/osu.Game/Skinning/Components/TextElement.cs
index 6e875c5590..a271857c03 100644
--- a/osu.Game/Skinning/Components/TextElement.cs
+++ b/osu.Game/Skinning/Components/TextElement.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Skinning.Components
     [UsedImplicitly]
     public partial class TextElement : FontAdjustableSkinComponent
     {
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextElementText), nameof(SkinnableComponentStrings.TextElementTextDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextElementText))]
         public Bindable<string> Text { get; } = new Bindable<string>("Circles!");
 
         private readonly OsuSpriteText text;
diff --git a/osu.Game/Skinning/FontAdjustableSkinComponent.cs b/osu.Game/Skinning/FontAdjustableSkinComponent.cs
index 0821edf7fc..eba29e9b79 100644
--- a/osu.Game/Skinning/FontAdjustableSkinComponent.cs
+++ b/osu.Game/Skinning/FontAdjustableSkinComponent.cs
@@ -1,13 +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.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation.SkinComponents;
+using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Skinning
 {
@@ -18,10 +21,13 @@ namespace osu.Game.Skinning
     {
         public bool UsesFixedAnchor { get; set; }
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Font), nameof(SkinnableComponentStrings.FontDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Font))]
         public Bindable<Typeface> Font { get; } = new Bindable<Typeface>(Typeface.Torus);
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextColour), nameof(SkinnableComponentStrings.TextColourDescription))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextWeight), SettingControlType = typeof(WeightDropdown))]
+        public Bindable<FontWeight> TextWeight { get; } = new Bindable<FontWeight>(FontWeight.Regular);
+
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextColour))]
         public BindableColour4 TextColour { get; } = new BindableColour4(Colour4.White);
 
         /// <summary>
@@ -35,16 +41,69 @@ namespace osu.Game.Skinning
         {
             base.LoadComplete();
 
-            Font.BindValueChanged(e =>
-            {
-                // We only have bold weight for venera, so let's force that.
-                FontWeight fontWeight = e.NewValue == Typeface.Venera ? FontWeight.Bold : FontWeight.Regular;
-
-                FontUsage f = OsuFont.GetFont(e.NewValue, weight: fontWeight);
-                SetFont(f);
-            }, true);
+            Font.BindValueChanged(_ => updateFont());
+            TextWeight.BindValueChanged(_ => updateFont(), true);
 
             TextColour.BindValueChanged(e => SetTextColour(e.NewValue), true);
         }
+
+        private void updateFont() => SetFont(OsuFont.GetFont(Font.Value, weight: TextWeight.Value));
+
+        private partial class WeightDropdown : SettingsDropdown<FontWeight>
+        {
+            public FontAdjustableSkinComponent FontComponent => (FontAdjustableSkinComponent)SettingSourceObject;
+            protected override OsuDropdown<FontWeight> CreateDropdown() => new DropdownControl(this);
+
+            private new partial class DropdownControl : SettingsDropdown<FontWeight>.DropdownControl
+            {
+                private readonly WeightDropdown settingsDropdown;
+
+                private IBindable<Typeface> font = null!;
+
+                public DropdownControl(WeightDropdown settingsDropdown)
+                {
+                    this.settingsDropdown = settingsDropdown;
+                }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+
+                    font = settingsDropdown.FontComponent.Font.GetBoundCopy();
+                    font.BindValueChanged(_ => updateItems(), true);
+                }
+
+                private void updateItems()
+                {
+                    ClearItems();
+
+                    switch (font.Value)
+                    {
+                        case Typeface.Venera:
+                            AddDropdownItem(FontWeight.Light);
+                            AddDropdownItem(FontWeight.Bold);
+                            AddDropdownItem(FontWeight.Black);
+
+                            Current.Default = FontWeight.Bold;
+
+                            if (!Items.Contains(Current.Value))
+                                Current.SetDefault();
+                            break;
+
+                        default:
+                            AddDropdownItem(FontWeight.Light);
+                            AddDropdownItem(FontWeight.Regular);
+                            AddDropdownItem(FontWeight.SemiBold);
+                            AddDropdownItem(FontWeight.Bold);
+
+                            Current.Default = FontWeight.Regular;
+
+                            if (!Items.Contains(Current.Value))
+                                Current.SetDefault();
+                            break;
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/osu.Game/Skinning/LegacyRankDisplay.cs b/osu.Game/Skinning/LegacyRankDisplay.cs
index b11b01b08d..7c2f8ffdef 100644
--- a/osu.Game/Skinning/LegacyRankDisplay.cs
+++ b/osu.Game/Skinning/LegacyRankDisplay.cs
@@ -6,6 +6,10 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Audio;
+using osu.Game.Configuration;
+using osu.Game.Localisation;
+using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osuTK;
@@ -22,9 +26,18 @@ namespace osu.Game.Skinning
         [Resolved]
         private ISkinSource source { get; set; } = null!;
 
+        [SettingSource(typeof(DefaultRankDisplayStrings), nameof(DefaultRankDisplayStrings.PlaySamplesOnRankChange))]
+        public BindableBool PlaySamples { get; set; } = new BindableBool(true);
+
         private readonly Sprite rankDisplay;
 
+        private SkinnableSound rankDownSample = null!;
+        private SkinnableSound rankUpSample = null!;
+
+        private Bindable<double?> lastSamplePlaybackTime = null!;
+
         private IBindable<ScoreRank> rank = null!;
+        private ScoreRank lastRank;
 
         public LegacyRankDisplay()
         {
@@ -37,6 +50,21 @@ namespace osu.Game.Skinning
             });
         }
 
+        [BackgroundDependencyLoader]
+        private void load(SkinEditor? skinEditor, SessionStatics statics)
+        {
+            AddRangeInternal(new Drawable[]
+            {
+                rankDownSample = new SkinnableSound(new SampleInfo("Gameplay/rank-down")),
+                rankUpSample = new SkinnableSound(new SampleInfo("Gameplay/rank-up")),
+            });
+
+            if (skinEditor != null)
+                PlaySamples.Value = false;
+
+            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
+        }
+
         protected override void LoadComplete()
         {
             rank = scoreProcessor.Rank.GetBoundCopy();
@@ -61,6 +89,21 @@ namespace osu.Game.Skinning
                                  .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
                                  .Expire();
                 }
+
+                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+
+                // 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();
+
+                    lastSamplePlaybackTime.Value = Time.Current;
+                }
+
+                lastRank = r.NewValue;
             }, true);
 
             FinishTransforms(true);
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index bbed434b3a..b648299787 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -594,12 +594,17 @@ namespace osu.Game.Skinning
         {
             var lookupNames = hitSample.LookupNames.SelectMany(getFallbackSampleNames);
 
-            if (!UseCustomSampleBanks && !string.IsNullOrEmpty(hitSample.Suffix))
+            if (!string.IsNullOrEmpty(hitSample.Suffix))
             {
-                // for compatibility with stable, exclude the lookup names with the custom sample bank suffix, if they are not valid for use in this skin.
+                // for compatibility with stable:
+                // - if the skin can use custom sample banks, it MUST use the custom sample bank suffix. it is not allowed to fall back to a non-custom sound.
+                // - if the skin cannot use custom sample banks, it MUST NOT use the custom sample bank suffix.
                 // using .EndsWith() is intentional as it ensures parity in all edge cases
-                // (see LegacyTaikoSampleInfo for an example of one - prioritising the taiko prefix should still apply, but the sample bank should not).
-                lookupNames = lookupNames.Where(name => !name.EndsWith(hitSample.Suffix, StringComparison.Ordinal));
+                // (see LegacyTaikoSampleInfo for an example of one - prioritising the taiko prefix should still apply).
+                if (UseCustomSampleBanks)
+                    lookupNames = lookupNames.Where(name => name.EndsWith(hitSample.Suffix, StringComparison.Ordinal));
+                else
+                    lookupNames = lookupNames.Where(name => !name.EndsWith(hitSample.Suffix, StringComparison.Ordinal));
             }
 
             foreach (string l in lookupNames)
diff --git a/osu.Game/Skinning/SkinImporter.cs b/osu.Game/Skinning/SkinImporter.cs
index 70d3195ecd..382a7b56c2 100644
--- a/osu.Game/Skinning/SkinImporter.cs
+++ b/osu.Game/Skinning/SkinImporter.cs
@@ -4,8 +4,10 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
@@ -13,6 +15,7 @@ using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
+using osu.Game.Overlays.Notifications;
 using Realms;
 
 namespace osu.Game.Skinning
@@ -43,6 +46,50 @@ namespace osu.Game.Skinning
 
         private const string unknown_creator_string = @"Unknown";
 
+        /// <summary>
+        /// Update an existing skin with the contents of a path
+        /// </summary>
+        /// <param name="notification">The progress notification</param>
+        /// <param name="task">The <see cref="ImportTask"/> to update the <paramref name="original"/> with</param>
+        /// <param name="original">The <see cref="SkinInfo"/> to update</param>
+        /// <returns></returns>
+        public override async Task<Live<SkinInfo>?> ImportAsUpdate(ProgressNotification notification, ImportTask task, SkinInfo original)
+        {
+            return await Realm.WriteAsync<Live<SkinInfo>?>(r =>
+            {
+                var skinInfo = r.Find<SkinInfo>(original.ID)!;
+                skinInfo.Files.Clear();
+
+                string[] filesInMountedDirectory = Directory.EnumerateFiles(task.Path, "*.*", SearchOption.AllDirectories).Select(f => Path.GetRelativePath(task.Path, f)).ToArray();
+
+                foreach (string file in filesInMountedDirectory)
+                {
+                    using var stream = File.OpenRead(Path.Combine(task.Path, file));
+
+                    modelManager.AddFile(skinInfo, stream, file, r);
+                }
+
+                string skinIniPath = Path.Combine(task.Path, "skin.ini");
+
+                if (File.Exists(skinIniPath))
+                {
+                    using (var stream = File.OpenRead(skinIniPath))
+                    using (var lineReader = new LineBufferedReader(stream))
+                    {
+                        var decodedSkinIni = new LegacySkinDecoder().Decode(lineReader);
+
+                        if (!string.IsNullOrEmpty(decodedSkinIni.SkinInfo.Name))
+                            skinInfo.Name = decodedSkinIni.SkinInfo.Name;
+
+                        if (!string.IsNullOrEmpty(decodedSkinIni.SkinInfo.Creator))
+                            skinInfo.Creator = decodedSkinIni.SkinInfo.Creator;
+                    }
+                }
+
+                return skinInfo.ToLive(Realm);
+            }).ConfigureAwait(false);
+        }
+
         protected override void Populate(SkinInfo model, ArchiveReader? archive, Realm realm, CancellationToken cancellationToken = default)
         {
             var skinInfoFile = model.GetFile(skin_info_file);
diff --git a/osu.Game/Skinning/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 9018c2e2c3..825d2f59c5 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -131,6 +131,10 @@ namespace osu.Game.Skinning
         {
             Realm.Run(r =>
             {
+                // can be the case when the current skin is externally mounted for editing
+                if (CurrentSkinInfo.Disabled)
+                    return;
+
                 // Required local for iOS. Will cause runtime crash if inlined.
                 Guid currentSkinId = CurrentSkinInfo.Value.ID;
 
diff --git a/osu.Game/Skinning/SkinnableSprite.cs b/osu.Game/Skinning/SkinnableSprite.cs
index 47618f6296..49ce7e48ab 100644
--- a/osu.Game/Skinning/SkinnableSprite.cs
+++ b/osu.Game/Skinning/SkinnableSprite.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Skinning
         [Resolved]
         private TextureStore textures { get; set; } = null!;
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.SpriteName), nameof(SkinnableComponentStrings.SpriteNameDescription), SettingControlType = typeof(SpriteSelectorControl))]
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.SpriteName), SettingControlType = typeof(SpriteSelectorControl))]
         public Bindable<string> SpriteName { get; } = new Bindable<string>(string.Empty);
 
         [Resolved]
diff --git a/osu.Game/Tests/Visual/EditorSavingTestScene.cs b/osu.Game/Tests/Visual/EditorSavingTestScene.cs
index 78188d7cf7..d2b216caa8 100644
--- a/osu.Game/Tests/Visual/EditorSavingTestScene.cs
+++ b/osu.Game/Tests/Visual/EditorSavingTestScene.cs
@@ -13,7 +13,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.SelectV2;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual
@@ -74,15 +74,14 @@ namespace osu.Game.Tests.Visual
 
             AddUntilStep("Wait for main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
 
-            SongSelect songSelect = null;
+            SoloSongSelect songSelect = null;
 
-            PushAndConfirm(() => songSelect = new PlaySongSelect());
-            AddUntilStep("wait for carousel load", () => songSelect.BeatmapSetsLoaded);
+            PushAndConfirm(() => songSelect = new SoloSongSelect());
+            AddUntilStep("wait for carousel load", () => songSelect.CarouselItemsPresented);
 
             AddStep("Present same beatmap", () => Game.PresentBeatmap(Game.BeatmapManager.QueryBeatmapSet(set => set.ID == beatmapSetGuid)!.Value, beatmap => beatmap.ID == beatmapGuid));
             AddUntilStep("Wait for beatmap selected", () => Game.Beatmap.Value.BeatmapInfo.ID == beatmapGuid);
-            AddStep("Open options", () => InputManager.Key(Key.F3));
-            AddStep("Enter editor", () => InputManager.Key(Key.Number5));
+            AddStep("Open editor", () => songSelect.Edit(Game.Beatmap.Value.BeatmapInfo));
 
             AddUntilStep("Wait for editor load", () => Editor != null);
         }
diff --git a/osu.Game/Tests/Visual/OsuTestScene.cs b/osu.Game/Tests/Visual/OsuTestScene.cs
index 09cfe5ecad..1cb7b2c840 100644
--- a/osu.Game/Tests/Visual/OsuTestScene.cs
+++ b/osu.Game/Tests/Visual/OsuTestScene.cs
@@ -341,8 +341,6 @@ namespace osu.Game.Tests.Visual
         {
             private readonly Track track;
 
-            private readonly TrackVirtualStore store;
-
             /// <summary>
             /// Create an instance which creates a <see cref="TestBeatmap"/> for the provided ruleset when requested.
             /// </summary>
@@ -372,7 +370,7 @@ namespace osu.Game.Tests.Visual
 
                 if (referenceClock != null)
                 {
-                    store = new TrackVirtualStore(referenceClock);
+                    var store = new TrackVirtualStore(referenceClock);
                     audio.AddItem(store);
                     track = store.GetVirtual(trackLength);
                 }
@@ -385,12 +383,6 @@ namespace osu.Game.Tests.Visual
                 LoadTrack();
             }
 
-            ~ClockBackedTestWorkingBeatmap()
-            {
-                // Remove the track store from the audio manager
-                store?.Dispose();
-            }
-
             protected override Track GetBeatmapTrack() => track;
 
             public override bool TryTransferTrack(WorkingBeatmap target)
diff --git a/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs b/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs
index af41617a7b..a84fb86200 100644
--- a/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs
+++ b/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs
@@ -57,6 +57,11 @@ namespace osu.Game.Tests.Visual
 
             AddStep(@"exit player", () => currentPlayer.Exit());
 
+            // The incoming beatmap is ruleset-typed in every usage, so the incoming hitobjects will be used as-is rather than being converted.
+            // Because we'll be re-using the beatmap (thus also the hitobjects), we need to make sure the previous player has been fully disposed.
+            AddUntilStep("player exited", () => !currentPlayer.IsCurrentScreen());
+            AddStep("dispose player", () => currentPlayer.Dispose());
+
             AddStep(@"encode and decode score", () =>
             {
                 var encoder = new LegacyScoreEncoder(originalScore, beatmap);
diff --git a/osu.Game/Updater/GitHubRelease.cs b/osu.Game/Updater/GitHubRelease.cs
index effabdbc04..9b97dc0994 100644
--- a/osu.Game/Updater/GitHubRelease.cs
+++ b/osu.Game/Updater/GitHubRelease.cs
@@ -3,7 +3,9 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
 using Newtonsoft.Json;
 
 namespace osu.Game.Updater
@@ -18,5 +20,11 @@ namespace osu.Game.Updater
 
         [JsonProperty("assets")]
         public List<GitHubAsset> Assets { get; set; }
+
+        [JsonProperty("prerelease")]
+        public bool Prerelease { get; set; }
+
+        [JsonPropertyName("published_at")]
+        public DateTime? PublishedAt { get; set; }
     }
 }
diff --git a/osu.Game/Updater/MobileUpdateNotifier.cs b/osu.Game/Updater/MobileUpdateNotifier.cs
index 04b54df3c0..3a290c9a63 100644
--- a/osu.Game/Updater/MobileUpdateNotifier.cs
+++ b/osu.Game/Updater/MobileUpdateNotifier.cs
@@ -4,13 +4,14 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
+using osu.Game.Configuration;
 using osu.Game.Online.API;
-using osu.Game.Overlays.Notifications;
 
 namespace osu.Game.Updater
 {
@@ -20,7 +21,10 @@ namespace osu.Game.Updater
     /// </summary>
     public partial class MobileUpdateNotifier : UpdateManager
     {
+        public override ReleaseStream? FixedReleaseStream => stream;
+
         private string version = null!;
+        private ReleaseStream stream;
 
         [Resolved]
         private GameHost host { get; set; } = null!;
@@ -28,27 +32,30 @@ namespace osu.Game.Updater
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game)
         {
-            version = game.Version;
+            version = game.Version.Split('-').First();
+            stream = Enum.TryParse(game.Version.Split('-').Last(), true, out ReleaseStream s) ? s : Configuration.ReleaseStream.Lazer;
         }
 
-        protected override async Task<bool> PerformUpdateCheck()
+        protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
         {
             try
             {
-                var releases = new OsuJsonWebRequest<GitHubRelease>("https://api.github.com/repos/ppy/osu/releases/latest");
+                bool includePrerelease = stream == Configuration.ReleaseStream.Tachyon;
 
-                await releases.PerformAsync().ConfigureAwait(false);
+                OsuJsonWebRequest<GitHubRelease[]> releasesRequest = new OsuJsonWebRequest<GitHubRelease[]>("https://api.github.com/repos/ppy/osu/releases?per_page=10&page=1");
+                await releasesRequest.PerformAsync(cancellationToken).ConfigureAwait(false);
 
-                var latest = releases.ResponseObject;
+                GitHubRelease[] releases = releasesRequest.ResponseObject;
+                GitHubRelease? latest = releases.OrderByDescending(r => r.PublishedAt).FirstOrDefault(r => includePrerelease || !r.Prerelease);
+
+                if (latest == null)
+                    return false;
 
-                // avoid any discrepancies due to build suffixes for now.
-                // eventually we will want to support release streams and consider these.
-                version = version.Split('-').First();
                 string latestTagName = latest.TagName.Split('-').First();
 
                 if (latestTagName != version && tryGetBestUrl(latest, out string? url))
                 {
-                    Notifications.Post(new SimpleNotification
+                    Notifications.Post(new UpdateAvailableNotification(cancellationToken)
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latestTagName}).\n\n"
                                + "Click here to download the new version, which can be installed over the top of your existing installation",
diff --git a/osu.Game/Updater/NoActionUpdateManager.cs b/osu.Game/Updater/NoActionUpdateManager.cs
index f776cd67be..0710797b60 100644
--- a/osu.Game/Updater/NoActionUpdateManager.cs
+++ b/osu.Game/Updater/NoActionUpdateManager.cs
@@ -1,14 +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.
 
-#nullable disable
-
+using System;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
 using osu.Game.Online.API;
-using osu.Game.Overlays.Notifications;
 
 namespace osu.Game.Updater
 {
@@ -18,36 +17,42 @@ namespace osu.Game.Updater
     /// </summary>
     public partial class NoActionUpdateManager : UpdateManager
     {
-        private string version;
+        public override ReleaseStream? FixedReleaseStream => externalReleaseStream;
+
+        private static ReleaseStream? externalReleaseStream => Enum.TryParse(Environment.GetEnvironmentVariable("OSU_EXTERNAL_UPDATE_STREAM"), true, out ReleaseStream stream) ? stream : null;
+
+        private string version = string.Empty;
 
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game)
         {
-            version = game.Version;
+            version = game.Version.Split('-').First();
         }
 
-        protected override async Task<bool> PerformUpdateCheck()
+        protected override async Task<bool> PerformUpdateCheck(CancellationToken cancellationToken)
         {
             try
             {
-                var releases = new OsuJsonWebRequest<GitHubRelease>("https://api.github.com/repos/ppy/osu/releases/latest");
+                ReleaseStream stream = externalReleaseStream ?? ReleaseStream.Value;
+                bool includePrerelease = stream == Configuration.ReleaseStream.Tachyon;
 
-                await releases.PerformAsync().ConfigureAwait(false);
+                OsuJsonWebRequest<GitHubRelease[]> releasesRequest = new OsuJsonWebRequest<GitHubRelease[]>("https://api.github.com/repos/ppy/osu/releases?per_page=10&page=1");
+                await releasesRequest.PerformAsync(cancellationToken).ConfigureAwait(false);
 
-                var latest = releases.ResponseObject;
+                GitHubRelease[] releases = releasesRequest.ResponseObject;
+                GitHubRelease? latest = releases.OrderByDescending(r => r.PublishedAt).FirstOrDefault(r => includePrerelease || !r.Prerelease);
+
+                if (latest == null)
+                    return false;
 
-                // avoid any discrepancies due to build suffixes for now.
-                // eventually we will want to support release streams and consider these.
-                version = version.Split('-').First();
                 string latestTagName = latest.TagName.Split('-').First();
 
                 if (latestTagName != version)
                 {
-                    Notifications.Post(new SimpleNotification
+                    Notifications.Post(new UpdateAvailableNotification(cancellationToken)
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latestTagName}).\n\n"
                                + "Check with your package manager / provider to bring osu! up-to-date!",
-                        Icon = FontAwesome.Solid.Download,
                     });
 
                     return true;
diff --git a/osu.Game/Updater/UpdateManager.cs b/osu.Game/Updater/UpdateManager.cs
index c114e3a8d0..335f6085a9 100644
--- a/osu.Game/Updater/UpdateManager.cs
+++ b/osu.Game/Updater/UpdateManager.cs
@@ -2,9 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -30,6 +32,8 @@ namespace osu.Game.Updater
                                          // only implementations will actually check for updates.
                                          GetType() != typeof(UpdateManager);
 
+        public virtual ReleaseStream? FixedReleaseStream => null;
+
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
 
@@ -39,14 +43,17 @@ namespace osu.Game.Updater
         [Resolved]
         protected INotificationOverlay Notifications { get; private set; } = null!;
 
+        protected IBindable<ReleaseStream> ReleaseStream => releaseStream;
+
+        private readonly Bindable<ReleaseStream> releaseStream = new Bindable<ReleaseStream>();
+
+        private CancellationTokenSource updateCancellationSource = new CancellationTokenSource();
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            Schedule(() => Task.Run(CheckForUpdateAsync));
-
             string version = game.Version;
-
             string lastVersion = config.Get<string>(OsuSetting.Version);
 
             if (game.IsDeployedBuild && version != lastVersion)
@@ -62,35 +69,52 @@ namespace osu.Game.Updater
             // 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).
             config.SetValue(OsuSetting.Version, version);
+
+            config.BindWith(OsuSetting.ReleaseStream, releaseStream);
+            releaseStream.BindValueChanged(_ => CheckForUpdate());
+
+            CheckForUpdate();
         }
 
-        private readonly object updateTaskLock = new object();
+        /// <summary>
+        /// Immediately checks for any available update.
+        /// </summary>
+        public void CheckForUpdate()
+        {
+            _ = CheckForUpdateAsync();
+        }
 
-        private Task<bool>? updateCheckTask;
-
-        public async Task<bool> CheckForUpdateAsync()
+        /// <summary>
+        /// Immediately checks for any available update.
+        /// </summary>
+        /// <returns><c>true</c> if any updates are available, <c>false</c> otherwise.</returns>
+        public async Task<bool> CheckForUpdateAsync(CancellationToken cancellationToken = default) => await Task.Run(async () =>
         {
             if (!CanCheckForUpdate)
                 return false;
 
-            Task<bool> waitTask;
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 
-            lock (updateTaskLock)
-                waitTask = (updateCheckTask ??= PerformUpdateCheck());
+            // Cancels the last update and closes any existing notifications as stale.
+            using (var lastCts = Interlocked.Exchange(ref updateCancellationSource, cts))
+                await lastCts.CancelAsync().ConfigureAwait(false);
 
-            bool hasUpdates = await waitTask.ConfigureAwait(false);
-
-            lock (updateTaskLock)
-                updateCheckTask = null;
-
-            return hasUpdates;
-        }
+            return await PerformUpdateCheck(cts.Token).ConfigureAwait(false);
+        }, cancellationToken).ConfigureAwait(false);
 
         /// <summary>
         /// Performs an asynchronous check for application updates.
         /// </summary>
         /// <returns>Whether any update is waiting. May return true if an error occured (there is potentially an update available).</returns>
-        protected virtual Task<bool> PerformUpdateCheck() => Task.FromResult(false);
+        protected virtual Task<bool> PerformUpdateCheck(CancellationToken cancellationToken) => Task.FromResult(false);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            updateCancellationSource.Cancel();
+            updateCancellationSource.Dispose();
+        }
 
         private partial class UpdateCompleteNotification : SimpleNotification
         {
@@ -111,26 +135,20 @@ namespace osu.Game.Updater
                 Activated = delegate
                 {
                     notificationOverlay.Hide();
-                    changelog.ShowBuild(OsuGameBase.CLIENT_STREAM_NAME, version);
+                    changelog.ShowBuild(version);
                     return true;
                 };
             }
         }
 
-        public partial class UpdateApplicationCompleteNotification : ProgressCompletionNotification
+        public partial class UpdateDownloadProgressNotification : ProgressNotification
         {
-            public UpdateApplicationCompleteNotification()
-            {
-                Text = NotificationsStrings.UpdateReadyToInstall;
-            }
-        }
+            private readonly CancellationToken cancellationToken;
 
-        public partial class UpdateProgressNotification : ProgressNotification
-        {
-            protected override Notification CreateCompletionNotification() => new UpdateApplicationCompleteNotification
+            public UpdateDownloadProgressNotification(CancellationToken cancellationToken)
             {
-                Activated = CompletionClickAction
-            };
+                this.cancellationToken = cancellationToken;
+            }
 
             [BackgroundDependencyLoader]
             private void load()
@@ -149,24 +167,12 @@ namespace osu.Game.Updater
                 });
             }
 
-            protected override void LoadComplete()
+            protected override void Update()
             {
-                base.LoadComplete();
-                StartDownload();
-            }
+                base.Update();
 
-            public override void Close(bool runFlingAnimation)
-            {
-                // cancelling updates is not currently supported by the underlying updater.
-                // only allow dismissing for now.
-
-                switch (State)
-                {
-                    case ProgressNotificationState.Cancelled:
-                    case ProgressNotificationState.Completed:
-                        base.Close(runFlingAnimation);
-                        break;
-                }
+                if (cancellationToken.IsCancellationRequested)
+                    FailDownload();
             }
 
             public void StartDownload()
@@ -181,6 +187,55 @@ namespace osu.Game.Updater
                 State = ProgressNotificationState.Cancelled;
                 Close(false);
             }
+
+            protected override Notification CreateCompletionNotification() => new UpdateReadyNotification(cancellationToken)
+            {
+                Activated = () =>
+                {
+                    if (cancellationToken.IsCancellationRequested)
+                        return true;
+
+                    return CompletionClickAction?.Invoke() ?? true;
+                }
+            };
+        }
+
+        public partial class UpdateReadyNotification : ProgressCompletionNotification
+        {
+            private readonly CancellationToken cancellationToken;
+
+            public UpdateReadyNotification(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+                Text = NotificationsStrings.UpdateReadyToInstall;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (cancellationToken.IsCancellationRequested)
+                    Close(false);
+            }
+        }
+
+        public partial class UpdateAvailableNotification : SimpleNotification
+        {
+            private readonly CancellationToken cancellationToken;
+
+            public UpdateAvailableNotification(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+                Icon = FontAwesome.Solid.Download;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (cancellationToken.IsCancellationRequested)
+                    Close(false);
+            }
         }
     }
 }
diff --git a/osu.Game/Users/ConfirmBlockActionDialog.cs b/osu.Game/Users/ConfirmBlockActionDialog.cs
new file mode 100644
index 0000000000..4dccc77ebc
--- /dev/null
+++ b/osu.Game/Users/ConfirmBlockActionDialog.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;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+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;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Overlays.Notifications;
+
+namespace osu.Game.Users
+{
+    public partial class ConfirmBlockActionDialog : DangerousActionDialog
+    {
+        private readonly APIUser user;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private NotificationOverlay? notifications { get; set; }
+
+        private ConfirmBlockActionDialog(APIUser user, LocalisableString text, Action<ConfirmBlockActionDialog> action)
+        {
+            this.user = user;
+            BodyText = text;
+            DangerousAction = () => action(this);
+        }
+
+        public static ConfirmBlockActionDialog Block(APIUser user) => new ConfirmBlockActionDialog(user, ContextMenuStrings.ConfirmBlockUser(user.Username), d => d.toggleBlock(true));
+        public static ConfirmBlockActionDialog Unblock(APIUser user) => new ConfirmBlockActionDialog(user, ContextMenuStrings.ConfirmUnblockUser(user.Username), d => d.toggleBlock(false));
+
+        private void toggleBlock(bool block)
+        {
+            APIRequest req = block ? new BlockUserRequest(user.OnlineID) : new UnblockUserRequest(user.OnlineID);
+
+            req.Success += () =>
+            {
+                api.UpdateLocalBlocks();
+            };
+
+            req.Failure += e =>
+            {
+                notifications?.Post(new SimpleNotification
+                {
+                    Text = e.Message,
+                    Icon = FontAwesome.Solid.Times,
+                });
+            };
+
+            api.Queue(req);
+        }
+    }
+}
diff --git a/osu.Game/Users/UserPanel.cs b/osu.Game/Users/UserPanel.cs
index fc261163da..808958311c 100644
--- a/osu.Game/Users/UserPanel.cs
+++ b/osu.Game/Users/UserPanel.cs
@@ -14,7 +14,6 @@ using osu.Game.Overlays;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Framework.Screens;
 using osu.Game.Graphics.Containers;
@@ -23,10 +22,8 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Chat;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Localisation;
-using osu.Game.Online.API.Requests;
 using osu.Game.Online.Metadata;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Overlays.Notifications;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
 using osu.Game.Users.Drawables;
@@ -68,6 +65,9 @@ namespace osu.Game.Users
         [Resolved]
         private ChatOverlay? chatOverlay { get; set; }
 
+        [Resolved]
+        private IDialogOverlay? dialogOverlay { get; set; }
+
         [Resolved]
         protected OverlayColourProvider? ColourProvider { get; private set; }
 
@@ -83,9 +83,6 @@ namespace osu.Game.Users
         [Resolved]
         private MetadataClient? metadataClient { get; set; }
 
-        [Resolved]
-        private INotificationOverlay? notifications { get; set; }
-
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -163,9 +160,9 @@ namespace osu.Game.Users
                     chatOverlay?.Show();
                 }));
 
-                items.Add(isUserBlocked()
-                    ? new OsuMenuItem(UsersStrings.BlocksButtonUnblock, MenuItemType.Standard, () => toggleBlock(false))
-                    : new OsuMenuItem(UsersStrings.BlocksButtonBlock, MenuItemType.Destructive, () => toggleBlock(true)));
+                items.Add(!isUserBlocked()
+                    ? new OsuMenuItem(UsersStrings.BlocksButtonBlock, MenuItemType.Destructive, () => dialogOverlay?.Push(ConfirmBlockActionDialog.Block(User)))
+                    : new OsuMenuItem(UsersStrings.BlocksButtonUnblock, MenuItemType.Standard, () => dialogOverlay?.Push(ConfirmBlockActionDialog.Unblock(User))));
 
                 if (isUserOnline())
                 {
@@ -193,27 +190,6 @@ namespace osu.Game.Users
             }
         }
 
-        private void toggleBlock(bool block)
-        {
-            APIRequest req = block ? new BlockUserRequest(User.OnlineID) : new UnblockUserRequest(User.OnlineID);
-
-            req.Success += () =>
-            {
-                api.UpdateLocalBlocks();
-            };
-
-            req.Failure += e =>
-            {
-                notifications?.Post(new SimpleNotification
-                {
-                    Text = e.Message,
-                    Icon = FontAwesome.Solid.Times,
-                });
-            };
-
-            api.Queue(req);
-        }
-
         public IEnumerable<LocalisableString> FilterTerms => [User.Username];
 
         public bool MatchingFilter
diff --git a/osu.Game/Utils/FormatUtils.cs b/osu.Game/Utils/FormatUtils.cs
index f7250c6833..29e402144a 100644
--- a/osu.Game/Utils/FormatUtils.cs
+++ b/osu.Game/Utils/FormatUtils.cs
@@ -10,6 +10,12 @@ namespace osu.Game.Utils
 {
     public static class FormatUtils
     {
+        public static double FloorToDecimalDigits(this double value, uint digits)
+        {
+            double base10 = Math.Pow(10, digits);
+            return Math.Floor(value * base10) / base10;
+        }
+
         /// <summary>
         /// Turns the provided accuracy into a percentage with 2 decimal places.
         /// </summary>
@@ -21,22 +27,27 @@ namespace osu.Game.Utils
             // ie. a score which gets 89.99999% shouldn't ever show as 90%.
             // the reasoning for this is that cutoffs for grade increases are at whole numbers and displaying the required
             // percentile with a non-matching grade is confusing.
-            accuracy = Math.Floor(accuracy * 10000) / 10000;
-
-            return accuracy.ToLocalisableString("0.00%");
+            return accuracy.FloorToDecimalDigits(4).ToLocalisableString("0.00%");
         }
 
         /// <summary>
         /// Formats the supplied rank/leaderboard position in a consistent, simplified way.
         /// </summary>
         /// <param name="rank">The rank/position to be formatted.</param>
-        public static string FormatRank(this int rank) => rank.ToMetric(decimals: rank < 100_000 ? 1 : 0);
+        public static string FormatRank(this int rank) => rank.ToMetric(decimals: rank < 10_000 ? 1 : 0);
 
         /// <summary>
         /// Formats the supplied star rating in a consistent, simplified way.
         /// </summary>
         /// <param name="starRating">The star rating to be formatted.</param>
-        public static LocalisableString FormatStarRating(this double starRating) => starRating.ToLocalisableString("0.00");
+        public static LocalisableString FormatStarRating(this double starRating)
+        {
+            // for the sake of display purposes, we don't want to show a user a "rounded up" star rating to the next whole number.
+            // i.e. a beatmap which has a star rating of 6.9999* should never show as 7.00*.
+            // this matters for star rating medals which use hard cutoffs at whole numbers,
+            // which then confuses users when they beat a 6.9999* beatmap but don't get the 7-star medal.
+            return starRating.FloorToDecimalDigits(2).ToLocalisableString("0.00");
+        }
 
         /// <summary>
         /// Finds the number of digits after the decimal.
diff --git a/osu.Game/Utils/SentryLogger.cs b/osu.Game/Utils/SentryLogger.cs
index 95086c501f..4f916f810e 100644
--- a/osu.Game/Utils/SentryLogger.cs
+++ b/osu.Game/Utils/SentryLogger.cs
@@ -52,7 +52,7 @@ namespace osu.Game.Utils
                 options.IsGlobalModeEnabled = true;
                 options.CacheDirectoryPath = storage?.GetFullPath(string.Empty);
                 // The reported release needs to match version as reported to Sentry in .github/workflows/sentry-release.yml
-                options.Release = $"osu@{game.Version.Replace($@"-{OsuGameBase.BUILD_SUFFIX}", string.Empty)}";
+                options.Release = $"osu@{game.Version.Split('-').First()}";
             });
 
             Logger.NewEntry += processLogEntry;
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index d246877ef5..107f54d4ac 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.512.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.530.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2025.704.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.707.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 205e85ba51..bb5e3da49e 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.512.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.704.0" />
   </ItemGroup>
 </Project>